qubu 0.6.0 → 0.6.2

package/dist/mysql.d.mts

@@ -1,5 +1,5 @@
-import { V as Dialect } from "./types-C0VkiwpR.mjs";
+import { Cr as onDuplicateKeyUpdate, Pt as Dialect, Sr as incoming, br as IncomingIdentity, xr as OnDuplicateKeyUpdateClause, yr as IncomingColumns } from "./types-Dqr4o2I1.mjs";
 //#region src/dialects/mysql.d.ts
-declare function mysqlDialect(): Dialect<"json" | "row-locking">;
+declare function mysqlDialect(): Dialect<"row-locking" | "on-duplicate-key-update" | "json">;
 //#endregion
-export { mysqlDialect };
+export { type IncomingColumns, type IncomingIdentity, type OnDuplicateKeyUpdateClause, incoming, mysqlDialect, onDuplicateKeyUpdate };

package/dist/mysql.mjs

@@ -1,6 +1,7 @@
-import { o as createDialect, t as mysqlJson } from "./json-Db7XRD91.mjs";
-import { n as queryValidationError } from "./errors-Dxv73YJu.mjs";
-import { t as mysqlExplain } from "./explain-CkIK13L_.mjs";
+import { K as mysqlJson, Z as createDialect } from "./column-DDRvD7SF.mjs";
+import { r as queryValidationError } from "./omit-VEr9Ydux.mjs";
+import { r as onDuplicateKeyUpdate, t as incoming } from "./on-duplicate-key-update-Czsw1Yq-.mjs";
+import { t as mysqlExplain } from "./explain-BIqEmZha.mjs";
 //#region src/dialects/mysql.ts
 const mysqlRowLocking = { render(context, mode, wait) {
 	if (mode !== "update" && mode !== "share") throw queryValidationError({
@@ -14,7 +15,7 @@ const mysqlRowLocking = { render(context, mode, wait) {
 	if (wait === "nowait") context.append(" NOWAIT");
 	if (wait === "skip-locked") context.append(" SKIP LOCKED");
 } };
-function renderMySqlPagination(context, parts) {
+function renderPagination(context, parts) {
 	const fetch = parts.find((part) => part.kind === "fetch");
 	const offset = parts.find((part) => part.kind === "offset");
 	context.append("LIMIT ");
@@ -30,10 +31,10 @@ function mysqlDialect() {
 		name: "mysql",
 		quoteIdentifier: (identifier) => `\`${identifier.replaceAll("`", "``")}\``,
 		placeholder: () => "?",
-		pagination: { render: renderMySqlPagination },
+		pagination: { render: renderPagination },
 		rowLocking: mysqlRowLocking,
 		json: mysqlJson,
-		capabilities: ["row-locking"],
+		capabilities: ["row-locking", "on-duplicate-key-update"],
 		castTypes: {
 			integer: "SIGNED",
 			text: "CHAR",
@@ -47,4 +48,4 @@ function mysqlDialect() {
 	});
 }
 //#endregion
-export { mysqlDialect };
+export { incoming, mysqlDialect, onDuplicateKeyUpdate };

package/dist/{errors-Dxv73YJu.mjs → omit-VEr9Ydux.mjs}

@@ -23,4 +23,8 @@ function queryValidationError(issue) {
 	return new QueryValidationError(issue);
 }
 //#endregion
-export { queryValidationError as n, QueryValidationError as t };
+//#region src/query/omit.ts
+/** An explicit placeholder for a safely omitted SELECT clause or projection field. */
+const omit = Symbol("qubu.omit");
+//#endregion
+export { QueryValidationError as n, queryValidationError as r, omit as t };

package/dist/{on-conflict-DZQ85f1t.mjs → on-conflict-B2rFyHGF.mjs}

@@ -1,9 +1,8 @@
-import { a as assertDialectCapability } from "./json-Db7XRD91.mjs";
-import { n as queryValidationError } from "./errors-Dxv73YJu.mjs";
-import { C as fragment, g as isExpression, i as identifier, t as createColumnReference } from "./column-r1Y4ivwt.mjs";
-import { a as columnResultValue, s as encodeColumnParameter } from "./column-Da37jYSD.mjs";
-import { t as omit } from "./omit-OxV58AwX.mjs";
-import { r as exposeColumns, t as createSource } from "./source-SqrKWjFJ.mjs";
+import { A as fragment, C as isExpression, X as assertDialectCapability, i as identifier, t as createColumnReference } from "./column-DDRvD7SF.mjs";
+import { r as queryValidationError, t as omit } from "./omit-VEr9Ydux.mjs";
+import { a as columnResultValue, c as encodeColumnParameter, o as columnSqlType } from "./column-Cyc2CMnG.mjs";
+import { r as exposeColumns, t as createSource } from "./source-DYSUqzvb.mjs";
+import { a as renderSchemaExpression, t as SchemaExpressionError } from "./expressions-_6JF_J77.mjs";
 //#region src/query/mutation/on-conflict.ts
 /** Columns from the proposed INSERT row, available inside DO UPDATE. */
 function excluded(table) {
@@ -41,12 +40,31 @@ function onConflict(...args) {
 			assertDialectCapability(context.dialect, "on-conflict");
 			context.append("ON CONFLICT");
 			if (target !== void 0) {
+				if (target.kind === "index" && context.dialect.name !== "postgresql") throw queryValidationError({
+					code: "invalid-mutation",
+					context: "upsert.conflict.target",
+					path: [
+						"onConflict",
+						"target",
+						"dialect"
+					],
+					message: "Unique-index conflict targets require the PostgreSQL dialect",
+					hint: "Render this query with postgresDialect(), or use a declared key constraint."
+				});
 				context.append(" (");
-				target.columns.forEach((column, index) => {
+				if (target.kind === "index") target.terms.forEach((term, index) => {
+					if (index > 0) context.append(", ");
+					renderConflictIndexTerm(context, term, index);
+				});
+				else target.columns.forEach((column, index) => {
 					if (index > 0) context.append(", ");
 					context.render(identifier(table?.sqlNames[column.fieldName] ?? column.columnName));
 				});
 				context.append(")");
+				if (target.kind === "index" && target.predicate !== void 0) {
+					context.append(" WHERE ");
+					context.append(renderConflictIndexExpression(context, target.predicate, "predicate"));
+				}
 			}
 			if (action.actionKind === "do-nothing") {
 				context.append(" DO NOTHING");
@@ -60,7 +78,7 @@ function onConflict(...args) {
 				if (isExpression(value)) context.render(value);
 				else {
 					const definition = table?.definitions[columnName];
-					context.parameter(definition === void 0 ? value : encodeColumnParameter(definition, value));
+					context.parameter(definition === void 0 ? value : encodeColumnParameter(definition, value), definition === void 0 ? void 0 : columnSqlType(definition));
 				}
 			});
 			if (action.where !== void 0) {
@@ -71,6 +89,35 @@ function onConflict(...args) {
 	});
 }
 function validateConflictTarget(table, target) {
+	if (target.kind === "index") {
+		const indexes = "indexes" in table ? table.indexes : {};
+		if (!Object.values(indexes).includes(target)) throw queryValidationError({
+			code: "invalid-mutation",
+			context: "upsert.conflict.target",
+			path: ["onConflict", "target"],
+			message: "ON CONFLICT index target must be declared on the target table",
+			hint: "Use a unique index from the INSERT target table's indexes record."
+		});
+		if (!target.unique || target.terms.length === 0) throw queryValidationError({
+			code: "invalid-mutation",
+			context: "upsert.conflict.target",
+			path: ["onConflict", "target"],
+			message: "ON CONFLICT index target must be a non-empty unique index",
+			hint: "Declare the target with index(terms, { unique: true })."
+		});
+		if (target.dialect !== void 0 && target.dialect.dialect !== "postgresql") throw queryValidationError({
+			code: "invalid-mutation",
+			context: "upsert.conflict.target",
+			path: [
+				"onConflict",
+				"target",
+				"dialect"
+			],
+			message: `ON CONFLICT cannot use an index declared for ${target.dialect.dialect}`,
+			hint: "Use a portable unique index or one declared for PostgreSQL."
+		});
+		return;
+	}
 	if (target.kind !== "primary-key" && target.kind !== "unique" || target.columns.length === 0) throw queryValidationError({
 		code: "invalid-mutation",
 		context: "upsert.conflict.target",
@@ -91,6 +138,29 @@ function validateConflictTarget(table, target) {
 		hint: "Use the key constraint declared on the INSERT target table."
 	});
 }
+function renderConflictIndexTerm(context, term, index) {
+	const expression = "orderKind" in term ? term.expression : term;
+	const text = renderConflictIndexExpression(context, expression, ["terms", index]);
+	context.append(expression.expressionKind === "column" ? text : `(${text})`);
+}
+function renderConflictIndexExpression(context, expression, path) {
+	try {
+		return renderSchemaExpression(expression, "index", context.dialect).text;
+	} catch (error) {
+		if (!(error instanceof SchemaExpressionError)) throw error;
+		throw queryValidationError({
+			code: "invalid-mutation",
+			context: "upsert.conflict.target",
+			path: [
+				"onConflict",
+				"target",
+				...typeof path === "string" ? [path] : path
+			],
+			message: `ON CONFLICT index target is not representable: ${error.message}`,
+			hint: "Use deterministic PostgreSQL index terms and a deterministic partial predicate."
+		});
+	}
+}
 function validateConflictAction(table, action) {
 	if (action.actionKind === "do-nothing") {
 		if (table === void 0) return;

package/dist/on-duplicate-key-update-Czsw1Yq-.mjs

@@ -0,0 +1,95 @@
+import { A as fragment, C as isExpression, X as assertDialectCapability, i as identifier, t as createColumnReference } from "./column-DDRvD7SF.mjs";
+import { r as queryValidationError, t as omit } from "./omit-VEr9Ydux.mjs";
+import { a as columnResultValue, c as encodeColumnParameter, o as columnSqlType } from "./column-Cyc2CMnG.mjs";
+//#region src/query/mutation/on-duplicate-key-update.ts
+const assignmentTargets = /* @__PURE__ */ new WeakMap();
+function renderDuplicateKeyUpdate(context, clause, columns) {
+	assignmentTargets.set(context, {
+		table: clause.table,
+		columns
+	});
+	try {
+		clause.render(context);
+	} finally {
+		assignmentTargets.delete(context);
+	}
+}
+function incomingAlias(table) {
+	return table.tableName.toLowerCase() === "__qubu_incoming" ? "__qubu_incoming_row" : "__qubu_incoming";
+}
+/**
+* Reference the incoming row in MySQL duplicate-key assignments. INSERT SELECT exposes only its
+* explicit target columns; other references fail during rendering. These references cannot be used
+* as a FROM source.
+*/
+function incoming(table) {
+	const reference = fragment((context) => {
+		assertDialectCapability(context.dialect, "on-duplicate-key-update");
+		if (assignmentTargets.get(context)?.table !== table) throw invalid("Incoming columns require duplicate-key assignments for the same target table");
+		context.render(identifier(incomingAlias(table)));
+	});
+	return Object.freeze(Object.fromEntries(Object.keys(table.definitions).map((field) => [field, (() => {
+		const column = createColumnReference(table.sqlNames[field] ?? field, reference, field, columnResultValue(table.definitions[field]));
+		return Object.freeze({
+			...column,
+			render(context) {
+				const scope = assignmentTargets.get(context);
+				if (scope?.columns && !scope.columns.includes(field)) throw invalid(`Incoming column "${field}" is not projected by INSERT SELECT`, field);
+				column.render(context);
+			}
+		});
+	})()])));
+}
+/**
+* Update writable columns when a MySQL INSERT row conflicts with a key. Raw values use target
+* column encoders. Expressions may reference the target table or incoming(table). At least one
+* non-omitted assignment is required.
+*/
+function onDuplicateKeyUpdate(table, assignments) {
+	const entries = Object.entries(assignments).filter(([, value]) => value !== omit);
+	if (entries.length === 0) throw invalid("Duplicate-key updates require at least one assignment");
+	for (const [field] of entries) if (!Object.hasOwn(table.definitions, field) || table.definitions[field].generated) throw invalid(`Column "${field}" is not a writable target column`, field);
+	return Object.freeze({
+		clauseKind: "on-duplicate-key-update",
+		table,
+		render(context) {
+			assertDialectCapability(context.dialect, "on-duplicate-key-update");
+			const scope = assignmentTargets.get(context);
+			if (scope?.table !== table) throw invalid("Duplicate-key clauses require their matching INSERT target");
+			context.append("ON DUPLICATE KEY UPDATE ");
+			const scoped = {
+				...context,
+				render(part) {
+					part.render(scoped);
+				}
+			};
+			assignmentTargets.set(scoped, scope);
+			try {
+				entries.forEach(([field, value], index) => {
+					if (index) context.append(", ");
+					context.render(identifier(table.sqlNames[field] ?? field));
+					context.append(" = ");
+					if (isExpression(value)) scoped.render(value);
+					else context.parameter(encodeColumnParameter(table.definitions[field], value), columnSqlType(table.definitions[field]));
+				});
+			} finally {
+				assignmentTargets.delete(scoped);
+			}
+		}
+	});
+}
+function invalid(message, field) {
+	return queryValidationError({
+		code: "invalid-update",
+		context: "upsert.duplicate-key.assignments",
+		path: [
+			"onDuplicateKeyUpdate",
+			"assignments",
+			...field ? [field] : []
+		],
+		message,
+		hint: "Use writable columns and incoming values from the INSERT target table."
+	});
+}
+//#endregion
+export { renderDuplicateKeyUpdate as i, incomingAlias as n, onDuplicateKeyUpdate as r, incoming as t };

package/dist/postgres-hFhd0I9n.mjs

@@ -0,0 +1,68 @@
+import { X as assertDialectCapability, Z as createDialect, k as withDialectCapability, q as postgresJson } from "./column-DDRvD7SF.mjs";
+import { t as comparison } from "./relational-CoPBETjI.mjs";
+import { n as postgresExplain } from "./explain-BIqEmZha.mjs";
+//#region src/query/mutation/update-from.ts
+/** Introduce one or more PostgreSQL sources to an UPDATE statement. */
+function updateFrom(...sources) {
+	return Object.freeze({
+		clauseKind: "update-from",
+		sources,
+		render(context) {
+			assertDialectCapability(context.dialect, "update-from");
+			context.append("FROM ");
+			sources.forEach((source, index) => {
+				if (index > 0) context.append(", ");
+				context.render(source);
+			});
+		}
+	});
+}
+//#endregion
+//#region src/dialects/postgres.ts
+const postgresRowLockModeSql = {
+	update: "UPDATE",
+	"no-key-update": "NO KEY UPDATE",
+	share: "SHARE",
+	"key-share": "KEY SHARE"
+};
+const postgresRowLocking = { render(context, mode, wait) {
+	context.append(`FOR ${postgresRowLockModeSql[mode]}`);
+	if (wait === "nowait") context.append(" NOWAIT");
+	if (wait === "skip-locked") context.append(" SKIP LOCKED");
+} };
+const postgresPagination = { render(context, parts) {
+	[...parts].sort((left, right) => {
+		return (left.kind === "fetch" ? 0 : 1) - (right.kind === "fetch" ? 0 : 1);
+	}).forEach((part, index) => {
+		if (index > 0) context.append(" ");
+		context.append(part.kind === "fetch" ? "LIMIT " : "OFFSET ");
+		context.parameter(part.rows, "integer");
+	});
+} };
+/**
+* PostgreSQL's only core rendering difference is positional parameters. PostgreSQL-specific
+* expressions and clauses should remain separate modules.
+*/
+function postgresDialect() {
+	return createDialect({
+		name: "postgresql",
+		placeholder: (position) => `$${position}`,
+		pagination: postgresPagination,
+		rowLocking: postgresRowLocking,
+		castTypes: { binary: "BYTEA" },
+		capabilities: [
+			"ilike",
+			"on-conflict",
+			"row-locking",
+			"update-from"
+		],
+		json: postgresJson,
+		explain: postgresExplain
+	});
+}
+/** PostgreSQL's case-insensitive pattern-match operator. */
+function ilike(left, pattern) {
+	return withDialectCapability(comparison("ILIKE", left, pattern), "ilike");
+}
+//#endregion
+export { postgresDialect as n, updateFrom as r, ilike as t };

package/dist/postgres.d.mts

@@ -1,10 +1,10 @@
-import { Do as SqlCapabilityValidation, Eo as OperandSqlType, Fl as SchemaExpression, Ku as SqlBoolean, Ou as RequiresCapabilityMeta, Pl as ExpressionWithOutput, Pu as ResultMeta, To as OperandNullability, Uu as AnySqlType, V as Dialect, _n as doNothing, _u as MetadataOf, bn as onConflict, dn as ConflictAction, fn as ConflictTarget, gn as OnConflictClause, hn as ExcludedSource, id as SqlTextLike, mn as DoUpdateAction, ou as ExpressionMeta, pn as DoNothingAction, sd as SqlUnknown, so as ComparisonValidation, vn as doUpdate, wo as Operand, yn as excluded } from "./types-C0VkiwpR.mjs";
+import { Ad as MetadataOf, Dr as UpdateFromClause, Gu as ExpressionWithOutput, Ku as SchemaExpression, Ms as OperandNullability, Ns as OperandSqlType, Or as UpdateFromScope, Ps as SqlCapabilityValidation, Pt as Dialect, Vd as RequiresCapabilityMeta, _f as SqlTextLike, _r as excluded, af as SqlBoolean, dr as DoNothingAction, fr as DoUpdateAction, gr as doUpdate, hr as doNothing, js as Operand, kr as updateFrom, lr as ConflictAction, mr as OnConflictClause, ms as ComparisonValidation, nf as AnySqlType, pr as ExcludedSource, qd as ResultMeta, ur as ConflictTarget, vr as onConflict, xf as SqlUnknown, yd as ExpressionMeta } from "./types-Dqr4o2I1.mjs";
 //#region src/dialects/postgres.d.ts
 /**
  * PostgreSQL's only core rendering difference is positional parameters. PostgreSQL-specific
  * expressions and clauses should remain separate modules.
  */
-declare function postgresDialect(): Dialect<"on-conflict" | "json" | "ilike" | "row-locking">;
+declare function postgresDialect(): Dialect<"row-locking" | "json" | "on-conflict" | "ilike" | "update-from">;
 /** PostgreSQL's case-insensitive pattern-match operator. */
 declare function ilike<TLeft extends ExpressionWithOutput<string>, R extends Operand<string>>(left: TLeft & ComparisonValidation<TLeft, R, "ILIKE">, pattern: R): SchemaExpression<ResultMeta<boolean, ((MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
   readonly kind: "result";
@@ -120,4 +120,4 @@ declare function ilike<TLeft extends ExpressionWithOutput<string>, R extends Ope
   readonly kind: "result" | "cardinality";
 } ? never : T_54 : never : never) | RequiresCapabilityMeta<"ilike">, "operator">;
 //#endregion
-export { type ConflictAction, type ConflictTarget, type DoNothingAction, type DoUpdateAction, type ExcludedSource, type OnConflictClause, doNothing, doUpdate, excluded, ilike, onConflict, postgresDialect };
+export { type ConflictAction, type ConflictTarget, type DoNothingAction, type DoUpdateAction, type ExcludedSource, type OnConflictClause, type UpdateFromClause, type UpdateFromScope, doNothing, doUpdate, excluded, ilike, onConflict, postgresDialect, updateFrom };

package/dist/postgres.mjs

@@ -1,52 +1,3 @@
-import { n as postgresJson, o as createDialect } from "./json-Db7XRD91.mjs";
-import { S as withDialectCapability } from "./column-r1Y4ivwt.mjs";
-import { t as comparison } from "./relational-CxnLCqZQ.mjs";
-import { n as postgresExplain } from "./explain-CkIK13L_.mjs";
-import { i as onConflict, n as doUpdate, r as excluded, t as doNothing } from "./on-conflict-DZQ85f1t.mjs";
-//#region src/dialects/postgres.ts
-const postgresRowLockModeSql = {
-	update: "UPDATE",
-	"no-key-update": "NO KEY UPDATE",
-	share: "SHARE",
-	"key-share": "KEY SHARE"
-};
-const postgresRowLocking = { render(context, mode, wait) {
-	context.append(`FOR ${postgresRowLockModeSql[mode]}`);
-	if (wait === "nowait") context.append(" NOWAIT");
-	if (wait === "skip-locked") context.append(" SKIP LOCKED");
-} };
-const postgresPagination = { render(context, parts) {
-	[...parts].sort((left, right) => {
-		return (left.kind === "fetch" ? 0 : 1) - (right.kind === "fetch" ? 0 : 1);
-	}).forEach((part, index) => {
-		if (index > 0) context.append(" ");
-		context.append(part.kind === "fetch" ? "LIMIT " : "OFFSET ");
-		context.parameter(part.rows);
-	});
-} };
-/**
-* PostgreSQL's only core rendering difference is positional parameters. PostgreSQL-specific
-* expressions and clauses should remain separate modules.
-*/
-function postgresDialect() {
-	return createDialect({
-		name: "postgresql",
-		placeholder: (position) => `$${position}`,
-		pagination: postgresPagination,
-		rowLocking: postgresRowLocking,
-		castTypes: { binary: "BYTEA" },
-		capabilities: [
-			"ilike",
-			"on-conflict",
-			"row-locking"
-		],
-		json: postgresJson,
-		explain: postgresExplain
-	});
-}
-/** PostgreSQL's case-insensitive pattern-match operator. */
-function ilike(left, pattern) {
-	return withDialectCapability(comparison("ILIKE", left, pattern), "ilike");
-}
-//#endregion
-export { doNothing, doUpdate, excluded, ilike, onConflict, postgresDialect };
+import { i as onConflict, n as doUpdate, r as excluded, t as doNothing } from "./on-conflict-B2rFyHGF.mjs";
+import { n as postgresDialect, r as updateFrom, t as ilike } from "./postgres-hFhd0I9n.mjs";
+export { doNothing, doUpdate, excluded, ilike, onConflict, postgresDialect, updateFrom };

package/dist/registry-BXE_4M9P.mjs

@@ -0,0 +1,127 @@
+import { S as snakeCaseIdentifier } from "./column-DDRvD7SF.mjs";
+//#region src/schema/registry.ts
+/** The first naming-policy version used by schema metadata. */
+const schemaNamingPolicyVersion = 1;
+/**
+* The built-in naming policy for schema-generated physical names.
+*
+* Explicit names supplied to `table()` remain unchanged. The policy is used by tooling when it
+* needs a physical name for a logical table ID.
+*/
+const defaultSchemaNamingPolicy = Object.freeze({
+	version: 1,
+	tableName: snakeCaseIdentifier
+});
+/** Error thrown when a root schema fails registry or naming validation. */
+var SchemaValidationError = class extends Error {
+	name = "SchemaValidationError";
+	diagnostics;
+	/** Alias matching validation libraries that call findings "issues". */
+	issues;
+	constructor(diagnostics) {
+		const frozenDiagnostics = Object.freeze(diagnostics.map((diagnostic) => Object.freeze({
+			...diagnostic,
+			path: Object.freeze([...diagnostic.path]),
+			relatedPaths: diagnostic.relatedPaths ? Object.freeze(diagnostic.relatedPaths.map((path) => Object.freeze([...path]))) : void 0
+		})));
+		super(frozenDiagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+		this.diagnostics = frozenDiagnostics;
+		this.issues = frozenDiagnostics;
+	}
+};
+function entriesOf(input) {
+	if (Array.isArray(input)) return input;
+	return Object.entries(input);
+}
+function validLogicalId(id) {
+	return id.length > 0 && id === id.trim() && !/[.\\/\u0000-\u001f\u007f]/u.test(id);
+}
+function validNamespace(namespace) {
+	return namespace.length > 0 && namespace === namespace.trim() && !/[.\\/\u0000-\u001f\u007f"']/u.test(namespace);
+}
+function validateEntries(entries, namespace, namingPolicy) {
+	const diagnostics = [];
+	const ids = /* @__PURE__ */ new Map();
+	const physicalNames = /* @__PURE__ */ new Map();
+	const generatedNames = /* @__PURE__ */ new Map();
+	for (const [index, [id, table]] of entries.entries()) {
+		const path = ["tables", id];
+		const previousId = ids.get(id);
+		if (previousId !== void 0) diagnostics.push({
+			code: "duplicate-table-id",
+			message: `Table ID "${id}" is declared more than once`,
+			path,
+			relatedPaths: [["tables", entries[previousId][0]]]
+		});
+		else ids.set(id, index);
+		if (!validLogicalId(id)) diagnostics.push({
+			code: "invalid-table-id",
+			message: `Table ID "${id}" must be a non-empty logical identifier`,
+			path
+		});
+		const physicalName = table.tableName || namingPolicy.tableName(id);
+		const previousPhysicalName = physicalNames.get(physicalName);
+		if (previousPhysicalName !== void 0) diagnostics.push({
+			code: "duplicate-physical-name",
+			message: `Tables "${entries[previousPhysicalName][0]}" and "${id}" both use physical name "${physicalName}"`,
+			path: [...path, "physicalName"],
+			relatedPaths: [[
+				"tables",
+				entries[previousPhysicalName][0],
+				"physicalName"
+			]]
+		});
+		else physicalNames.set(physicalName, index);
+		const generatedName = namingPolicy.tableName(id);
+		const previousGeneratedName = generatedNames.get(generatedName);
+		if (previousGeneratedName !== void 0) diagnostics.push({
+			code: "generated-name-collision",
+			message: `Logical table IDs "${entries[previousGeneratedName][0]}" and "${id}" generate the same physical name "${generatedName}"`,
+			path: [...path, "generatedName"],
+			relatedPaths: [[
+				"tables",
+				entries[previousGeneratedName][0],
+				"generatedName"
+			]]
+		});
+		else generatedNames.set(generatedName, index);
+	}
+	if (namespace !== void 0 && !validNamespace(namespace)) diagnostics.push({
+		code: "invalid-namespace",
+		message: `Schema namespace "${namespace}" must be a non-empty identifier without qualification or control characters`,
+		path: ["namespace"]
+	});
+	return Object.freeze(diagnostics);
+}
+function freezeTableNames(entries, namingPolicy) {
+	return Object.freeze(Object.fromEntries(entries.map(([id, table]) => [id, table.tableName || namingPolicy.tableName(id)])));
+}
+function createSchema(entries, tables, options = {}) {
+	const namingPolicy = options.namingPolicy ?? defaultSchemaNamingPolicy;
+	const diagnostics = validateEntries(entries, options.namespace, namingPolicy);
+	if (diagnostics.length > 0) throw new SchemaValidationError(diagnostics);
+	const tableNames = freezeTableNames(entries, namingPolicy);
+	const registry = Object.freeze(Object.fromEntries(entries.map(([id, table]) => [id, Object.freeze({
+		id,
+		table,
+		physicalName: tableNames[id]
+	})])));
+	return Object.freeze({
+		schemaKind: "schema",
+		tables: Object.freeze({ ...tables }),
+		registry,
+		tableNames,
+		namespace: options.namespace,
+		namingPolicy: Object.freeze({ ...namingPolicy })
+	});
+}
+function schema(tables, options) {
+	const entries = entriesOf(tables);
+	return createSchema(entries, Object.fromEntries(entries), options);
+}
+/** Generate a v1 physical name for a logical table ID. */
+function generatedTableName(logicalId, namingPolicy = defaultSchemaNamingPolicy) {
+	return namingPolicy.tableName(logicalId);
+}
+//#endregion
+export { schemaNamingPolicyVersion as a, schema as i, defaultSchemaNamingPolicy as n, generatedTableName as r, SchemaValidationError as t };

package/dist/{relational-CxnLCqZQ.mjs → relational-CoPBETjI.mjs}

@@ -1,6 +1,6 @@
-import { n as queryValidationError } from "./errors-Dxv73YJu.mjs";
-import { P as resultValue, y as makeSchemaExpression } from "./column-r1Y4ivwt.mjs";
-import { n as isValueExpression, t as asValue } from "./value-D14I_XgL.mjs";
+import { E as makeSchemaExpression, U as resultValue } from "./column-DDRvD7SF.mjs";
+import { n as isValueExpression, t as asValue } from "./value-CpaUFtjw.mjs";
+import { r as queryValidationError } from "./omit-VEr9Ydux.mjs";
 //#region src/expressions/operators/shared.ts
 function isNullOperand(value) {
 	return value === null || isValueExpression(value) && value.value === null;

package/dist/schema.d.mts

@@ -1,2 +1,2 @@
-import { $i as SourceIndexesRecord, $o as ColumnStorageDialectOf, $r as generatedTableName, $s as ResolvedColumnBehavior, Ai as catalogCheck, Ar as SchemaExpressionErrorCode, As as numeric, At as SourceSqlTypeMap, Bi as AliasedSource, Bo as ColumnHasDefault, Br as renderSchemaSql, Bs as DefaultDescriptor, Bt as TableDefinitions, Ci as SourceConstraintsRecord, Cs as date, Ct as SourceColumns, Di as UniqueConstraint, Dr as createSchemaDialect, Ds as nativeColumn, Dt as SourceKind, Ei as TableLike, Er as SchemaDialectHooks, Es as json, Et as SourceIdentity, Fi as references, Fo as ColumnDefaultOf, Fr as UnsafeSchemaSqlExpression, Fs as CanonicalLiteral, Ft as exposeColumns, Gi as alias, Go as ColumnIsNullable, Gr as SchemaNamingPolicy, Gs as GeneratedColumnDescriptor, Gt as TableRow, Hi as LateralSource, Ho as ColumnIdentityOf, Hr as unsafeSchemaSql, Hs as ExpressionGeneratedColumnDescriptor, Ht as TableInsertInput, Ii as unique, Io as ColumnDefinition, Ir as defineSchemaExpression, Is as ColumnBehaviorError, It as sourceIdentity, Ji as IndexOptions, Jo as ColumnOutput, Jr as SchemaTableNames, Js as IdentityDescriptor, Jt as table, Ki as lateral, Ko as ColumnOnUpdateOf, Kr as SchemaOptions, Ks as GeneratedColumnMode, Kt as TableSqlTypes, Li as uniqueConstraint, Lo as ColumnDefinitionConfig, Lr as isUnsafeSchemaSql, Ls as ColumnBehaviorErrorCode, Lt as AnyTable, Mi as check, Mr as SchemaExpressionMode, Ms as text, Mt as UnknownSourceSqlTypes, Ni as foreignKey, Nr as SchemaRenderContext, Ns as timestamp, Nt as createSource, Oi as UniqueConstraintOptions, Or as RenderedSchemaExpression, Os as nativeStorage, Ot as SourceProvision, Pi as primaryKey, Po as ColumnCodec, Pr as SchemaRenderOptions, Ps as uuid, Pt as customSource, Qi as SourceIndex, Qo as ColumnStorageDescriptor, Qr as defaultSchemaNamingPolicy, Qs as MysqlIdentityExtension, Ri as validateConstraintDialect, Ro as ColumnFromOptions, Rr as normalizeSchemaSql, Rs as ColumnDefault, Rt as Table, Si as SourceConstraint, Ss as columnResultValue, St as Source, Ti as SqliteConstraintExtension, Tr as SchemaDialect, Ts as integer, Tt as SourceConstraints, Ui as QueryAliasIdentity, Uo as ColumnInsertInput, Ur as Schema, Us as ExternalDefaultDescriptor, Ut as TableMetadataCallback, Vi as LateralIdentity, Vo as ColumnHasRuntimeDefault, Vr as schemaExpression, Vs as ExpressionDefaultDescriptor, Vt as TableIdentity, Wi as QuerySource, Wo as ColumnIsGenerated, Wr as SchemaDiagnostic, Ws as ExternalGeneratedColumnDescriptor, Wt as TableOptions, Xi as MysqlIndexExtension, Xo as ColumnStorage, Xr as SchemaTableRegistry, Xs as IdentityGeneration, Yi as IndexTerm, Yo as ColumnSqlType, Yr as SchemaTableRecord, Ys as IdentityDialectExtension, Zi as PostgresIndexExtension, Zo as ColumnStorageDeclarationOf, Zr as SchemaValidationError, Zs as LiteralDefaultDescriptor, _c as generatedSchemaObjectName, _i as KeyConstraint, _s as StorageTypeOf, _t as AnySource, ac as generatedColumn, ai as CheckConstraint, as as DialectNativeStorage, bc as materializeSchemaObjectRecord, bi as PostgresConstraintExtension, bs as boolean, bt as ProvidedSourceIdentity, cc as SchemaDialectExtension, ci as ConstraintOptions, cs as NativeStorageDescriptor, dc as SchemaMetadataValidationError, di as FieldLikeOptions, ds as PortableStorageDescriptor, ea as SqliteIndexExtension, ec as SchemaLiteralValue, ei as schema, es as ColumnStorageKindOf, fc as SchemaObjectIdentity, fi as ForeignKeyConstraint, fs as PortableStorageType, gc as freezeSchemaMetadata, gi as ForeignKeyTargetInput, gs as StorageOf, hc as dialectMismatchDiagnostic, hi as ForeignKeyTarget, hs as StorageDialectOf, ia as DeclaredColumnNullability, ic as externalGeneratedColumn, ii as CatalogCheckSql, is as ColumnUpdateInput, ji as catalogForeignKey, jr as SchemaExpressionInput, js as portableStorage, jt as SourceSqlTypes, ki as UniqueNullSemantics, kr as SchemaExpressionError, ks as nullable, kt as SourceRow, lc as SchemaDialectName, li as ConstraintTiming, ls as PortableColumnStorage, mc as assertSchemaDialectSupport, mi as ForeignKeyOptions, ms as StorageDescriptor, na as index, nc as canonicalLiteral, ni as AnyKeyColumn, ns as ColumnStorageType, oc as identityColumn, oi as CheckConstraintOptions, os as NativeColumnStorage, pc as SchemaObjectNameOptions, pi as ForeignKeyMatch, ps as StorageDeclarationOf, qi as IndexDialectExtension, qo as ColumnOptions, qr as SchemaTableEntry, qs as GeneratedDescriptor, qt as TableUpdateInput, ra as validateIndexDialect, rc as externalDefault, ri as CatalogCheckExpression, rs as ColumnStorageTypeOf, sc as resolveColumnBehavior, si as ConstraintDialectExtension, ss as NativeStorage, ta as TableIndex, tc as SqliteIdentityExtension, ti as schemaNamingPolicyVersion, ts as ColumnStorageOf, uc as SchemaMetadataDiagnostic, ui as FieldLike, us as PortableStorage, vc as isValidSchemaObjectName, vi as KeyConstraintOptions, vs as bigint, vt as CustomSource, wi as SourceLike, ws as encodeColumnParameter, wt as SourceConfig, xi as ReferentialAction, xs as column, xt as ProvidedSourceRow, yc as materializeSchemaObjectIdentity, yi as MysqlConstraintExtension, ys as binary, yt as CustomSourceOptions, zi as AliasIdentity, zo as ColumnGeneratedOf, zr as renderSchemaExpression, zs as ColumnDefaultInput, zt as TableColumns } from "./types-C0VkiwpR.mjs";
-export { AliasIdentity, AliasedSource, AnyKeyColumn, AnySource, AnyTable, CanonicalLiteral, CatalogCheckExpression, CatalogCheckSql, CheckConstraint, CheckConstraintOptions, ColumnBehaviorError, ColumnBehaviorErrorCode, ColumnCodec, ColumnDefault, ColumnDefaultInput, ColumnDefaultOf, ColumnDefinition, ColumnDefinitionConfig, ColumnFromOptions, ColumnGeneratedOf, ColumnHasDefault, ColumnHasRuntimeDefault, ColumnIdentityOf, ColumnInsertInput, ColumnIsGenerated, ColumnIsNullable, ColumnOnUpdateOf, ColumnOptions, ColumnOutput, ColumnSqlType, ColumnStorage, ColumnStorageDeclarationOf, ColumnStorageDescriptor, ColumnStorageDialectOf, ColumnStorageKindOf, ColumnStorageOf, ColumnStorageType, ColumnStorageTypeOf, ColumnUpdateInput, ConstraintDialectExtension, ConstraintOptions, ConstraintTiming, CustomSource, CustomSourceOptions, type DeclaredColumnNullability, DefaultDescriptor, DialectNativeStorage, ExpressionDefaultDescriptor, ExpressionGeneratedColumnDescriptor, ExternalDefaultDescriptor, ExternalGeneratedColumnDescriptor, FieldLike, FieldLikeOptions, ForeignKeyConstraint, ForeignKeyMatch, ForeignKeyOptions, ForeignKeyTarget, ForeignKeyTargetInput, GeneratedColumnDescriptor, GeneratedColumnMode, GeneratedDescriptor, IdentityDescriptor, IdentityDialectExtension, IdentityGeneration, IndexDialectExtension, IndexOptions, IndexTerm, KeyConstraint, KeyConstraintOptions, LateralIdentity, LateralSource, LiteralDefaultDescriptor, MysqlConstraintExtension, MysqlIdentityExtension, MysqlIndexExtension, NativeColumnStorage, NativeStorage, NativeStorageDescriptor, PortableColumnStorage, PortableStorage, PortableStorageDescriptor, PortableStorageType, PostgresConstraintExtension, PostgresIndexExtension, ProvidedSourceIdentity, ProvidedSourceRow, QueryAliasIdentity, QuerySource, ReferentialAction, RenderedSchemaExpression, ResolvedColumnBehavior, Schema, SchemaDiagnostic, SchemaDialect, SchemaDialectExtension, SchemaDialectHooks, SchemaDialectName, SchemaExpressionError, SchemaExpressionErrorCode, SchemaExpressionInput, SchemaExpressionMode, SchemaLiteralValue, SchemaMetadataDiagnostic, SchemaMetadataValidationError, SchemaNamingPolicy, SchemaObjectIdentity, SchemaObjectNameOptions, SchemaOptions, SchemaRenderContext, SchemaRenderOptions, SchemaTableEntry, SchemaTableNames, SchemaTableRecord, SchemaTableRegistry, SchemaValidationError, Source, SourceColumns, SourceConfig, SourceConstraint, SourceConstraints, SourceConstraintsRecord, SourceIdentity, SourceIndex, SourceIndexesRecord, SourceKind, SourceLike, SourceProvision, SourceRow, SourceSqlTypeMap, SourceSqlTypes, SqliteConstraintExtension, SqliteIdentityExtension, SqliteIndexExtension, StorageDeclarationOf, StorageDescriptor, StorageDialectOf, StorageOf, StorageTypeOf, Table, TableColumns, TableDefinitions, TableIdentity, TableIndex, TableInsertInput, TableLike, TableMetadataCallback, TableOptions, TableRow, TableSqlTypes, TableUpdateInput, UniqueConstraint, UniqueConstraintOptions, UniqueNullSemantics, UnknownSourceSqlTypes, UnsafeSchemaSqlExpression, alias, assertSchemaDialectSupport, bigint, binary, boolean, canonicalLiteral, catalogCheck, catalogForeignKey, check, column, columnResultValue, createSchemaDialect, createSource, customSource, date, defaultSchemaNamingPolicy, defineSchemaExpression, dialectMismatchDiagnostic, encodeColumnParameter, exposeColumns, externalDefault, externalGeneratedColumn, foreignKey, freezeSchemaMetadata, generatedColumn, generatedSchemaObjectName, generatedTableName, identityColumn, index, integer, isUnsafeSchemaSql, isValidSchemaObjectName, json, lateral, materializeSchemaObjectIdentity, materializeSchemaObjectRecord, nativeColumn, nativeStorage, normalizeSchemaSql, nullable, numeric, portableStorage, primaryKey, references, renderSchemaExpression, renderSchemaSql, resolveColumnBehavior, schema, schemaExpression, schemaNamingPolicyVersion, sourceIdentity, table, text, timestamp, unique, uniqueConstraint, unsafeSchemaSql, uuid, validateConstraintDialect, validateIndexDialect };
+import { $a as IndexDialectExtension, $c as GeneratedColumnDescriptor, $i as SchemaTableEntry, $s as ColumnOnUpdateOf, Aa as SourceLike, Ac as columnSqlType, Al as materializeSchemaObjectRecord, An as sourceIdentity, Ba as primaryKey, Bc as text, Bi as SchemaRenderOptions, Bn as TableSqlTypes, Ca as KeyConstraint, Cc as StorageOf, Cl as SchemaObjectNameOptions, Cn as SourceRow, Da as ReferentialAction, Dc as boolean, Dl as generatedSchemaObjectName, Dn as createSource, Ea as PostgresConstraintExtension, Ec as binary, El as freezeSchemaMetadata, En as UnknownSourceSqlTypes, Fa as UniqueNullSemantics, Fc as nativeColumn, Fi as SchemaExpressionError, Fn as TableIdentity, Ga as AliasIdentity, Gc as ColumnBehaviorErrorCode, Gi as renderSchemaExpression, Gs as ColumnFromOptions, Ha as unique, Hc as uuid, Hi as defineSchemaExpression, Hn as table, Hs as ColumnDefaultOf, Ia as catalogCheck, Ic as nativeStorage, Ii as SchemaExpressionErrorCode, In as TableInsertInput, Ja as LateralSource, Jc as DefaultDescriptor, Ji as unsafeSchemaSql, Js as ColumnHasRuntimeDefault, Ka as AliasedSource, Kc as ColumnDefault, Ki as renderSchemaSql, Ks as ColumnGeneratedOf, La as catalogForeignKey, Lc as nullable, Li as SchemaExpressionInput, Ln as TableMetadataCallback, Ma as TableLike, Mc as encodeColumnParameter, Mi as SchemaDialectHooks, Mn as Table, Na as UniqueConstraint, Nc as integer, Ni as createSchemaDialect, Nn as TableColumns, Oa as SourceConstraint, Oc as column, Ol as isValidSchemaObjectName, On as customSource, Pa as UniqueConstraintOptions, Pc as json, Pi as RenderedSchemaExpression, Pn as TableDefinitions, Qa as lateral, Qc as ExternalGeneratedColumnDescriptor, Qi as SchemaOptions, Qs as ColumnIsNullable, Ra as check, Rc as numeric, Ri as SchemaExpressionMode, Rn as TableOptions, Sa as ForeignKeyTargetInput, Sc as StorageDialectOf, Sl as SchemaObjectIdentity, Sn as SourceProvision, Ta as MysqlConstraintExtension, Tc as bigint, Tl as dialectMismatchDiagnostic, Tn as SourceSqlTypes, Ua as uniqueConstraint, Uc as CanonicalLiteral, Ui as isUnsafeSchemaSql, Us as ColumnDefinition, Va as references, Vc as timestamp, Vi as UnsafeSchemaSqlExpression, Vn as TableUpdateInput, Vs as ColumnCodec, Wa as validateConstraintDialect, Wc as ColumnBehaviorError, Wi as normalizeSchemaSql, Ws as ColumnDefinitionConfig, Xa as QuerySource, Xc as ExpressionGeneratedColumnDescriptor, Xi as SchemaDiagnostic, Xs as ColumnInsertInput, Ya as QueryAliasIdentity, Yc as ExpressionDefaultDescriptor, Yi as Schema, Ys as ColumnIdentityOf, Za as alias, Zc as ExternalDefaultDescriptor, Zi as SchemaNamingPolicy, Zs as ColumnIsGenerated, _a as FieldLikeOptions, _c as PortableStorage, _l as resolveColumnBehavior, _n as SourceColumns, aa as generatedTableName, ac as ColumnStorageDescriptor, al as IdentityOptionValue, ao as SourceIndex, ba as ForeignKeyOptions, bc as StorageDeclarationOf, bl as SchemaMetadataDiagnostic, bn as SourceIdentity, ca as AnyKeyColumn, cc as ColumnStorageOf, cl as MysqlIdentityExtension, co as TableIndex, da as CheckConstraint, dc as ColumnUpdateInput, dl as SqliteIdentityExtension, dn as AnySource, do as DeclaredColumnNullability, ea as SchemaTableNames, ec as ColumnOptions, el as GeneratedColumnMode, eo as IndexOptions, fa as CheckConstraintOptions, fc as DialectNativeStorage, fl as canonicalLiteral, fn as CustomSource, ga as FieldLike, gc as PortableColumnStorage, gl as identityColumn, gn as Source, ha as ConstraintTiming, hc as NativeStorageDescriptor, hl as generatedColumn, hn as ProvidedSourceRow, ia as defaultSchemaNamingPolicy, ic as ColumnStorageDeclarationOf, il as IdentityGeneration, io as PostgresIndexExtension, ja as SqliteConstraintExtension, jc as date, ji as SchemaDialect, jn as AnyTable, ka as SourceConstraintsRecord, kc as columnResultValue, kl as materializeSchemaObjectIdentity, kn as exposeColumns, la as CatalogCheckExpression, lc as ColumnStorageType, ll as ResolvedColumnBehavior, lo as index, ma as ConstraintOptions, mc as NativeStorage, ml as externalGeneratedColumn, mn as ProvidedSourceIdentity, na as SchemaTableRegistry, nc as ColumnSqlType, nl as IdentityDescriptor, no as IndexTermOptions, oa as schema, oc as ColumnStorageDialectOf, ol as IdentityOptions, oo as SourceIndexesRecord, pa as ConstraintDialectExtension, pc as NativeColumnStorage, pl as externalDefault, pn as CustomSourceOptions, qa as LateralIdentity, qc as ColumnDefaultInput, qi as schemaExpression, qs as ColumnHasDefault, ra as SchemaValidationError, rc as ColumnStorage, rl as IdentityDialectExtension, ro as MysqlIndexExtension, sa as schemaNamingPolicyVersion, sc as ColumnStorageKindOf, sl as LiteralDefaultDescriptor, so as SqliteIndexExtension, ta as SchemaTableRecord, tc as ColumnOutput, tl as GeneratedDescriptor, to as IndexTerm, ua as CatalogCheckSql, uc as ColumnStorageTypeOf, ul as SchemaLiteralValue, uo as validateIndexDialect, va as ForeignKeyConstraint, vc as PortableStorageDescriptor, vl as SchemaDialectExtension, vn as SourceConfig, wa as KeyConstraintOptions, wc as StorageTypeOf, wl as assertSchemaDialectSupport, wn as SourceSqlTypeMap, xa as ForeignKeyTarget, xc as StorageDescriptor, xl as SchemaMetadataValidationError, xn as SourceKind, ya as ForeignKeyMatch, yc as PortableStorageType, yl as SchemaDialectName, yn as SourceConstraints, za as foreignKey, zc as portableStorage, zi as SchemaRenderContext, zn as TableRow } from "./types-Dqr4o2I1.mjs";
+export { AliasIdentity, AliasedSource, AnyKeyColumn, AnySource, AnyTable, CanonicalLiteral, CatalogCheckExpression, CatalogCheckSql, CheckConstraint, CheckConstraintOptions, ColumnBehaviorError, ColumnBehaviorErrorCode, ColumnCodec, ColumnDefault, ColumnDefaultInput, ColumnDefaultOf, ColumnDefinition, ColumnDefinitionConfig, ColumnFromOptions, ColumnGeneratedOf, ColumnHasDefault, ColumnHasRuntimeDefault, ColumnIdentityOf, ColumnInsertInput, ColumnIsGenerated, ColumnIsNullable, ColumnOnUpdateOf, ColumnOptions, ColumnOutput, ColumnSqlType, ColumnStorage, ColumnStorageDeclarationOf, ColumnStorageDescriptor, ColumnStorageDialectOf, ColumnStorageKindOf, ColumnStorageOf, ColumnStorageType, ColumnStorageTypeOf, ColumnUpdateInput, ConstraintDialectExtension, ConstraintOptions, ConstraintTiming, CustomSource, CustomSourceOptions, type DeclaredColumnNullability, DefaultDescriptor, DialectNativeStorage, ExpressionDefaultDescriptor, ExpressionGeneratedColumnDescriptor, ExternalDefaultDescriptor, ExternalGeneratedColumnDescriptor, FieldLike, FieldLikeOptions, ForeignKeyConstraint, ForeignKeyMatch, ForeignKeyOptions, ForeignKeyTarget, ForeignKeyTargetInput, GeneratedColumnDescriptor, GeneratedColumnMode, GeneratedDescriptor, IdentityDescriptor, IdentityDialectExtension, IdentityGeneration, IdentityOptionValue, IdentityOptions, IndexDialectExtension, IndexOptions, IndexTerm, IndexTermOptions, KeyConstraint, KeyConstraintOptions, LateralIdentity, LateralSource, LiteralDefaultDescriptor, MysqlConstraintExtension, MysqlIdentityExtension, MysqlIndexExtension, NativeColumnStorage, NativeStorage, NativeStorageDescriptor, PortableColumnStorage, PortableStorage, PortableStorageDescriptor, PortableStorageType, PostgresConstraintExtension, PostgresIndexExtension, ProvidedSourceIdentity, ProvidedSourceRow, QueryAliasIdentity, QuerySource, ReferentialAction, RenderedSchemaExpression, ResolvedColumnBehavior, Schema, SchemaDiagnostic, SchemaDialect, SchemaDialectExtension, SchemaDialectHooks, SchemaDialectName, SchemaExpressionError, SchemaExpressionErrorCode, SchemaExpressionInput, SchemaExpressionMode, SchemaLiteralValue, SchemaMetadataDiagnostic, SchemaMetadataValidationError, SchemaNamingPolicy, SchemaObjectIdentity, SchemaObjectNameOptions, SchemaOptions, SchemaRenderContext, SchemaRenderOptions, SchemaTableEntry, SchemaTableNames, SchemaTableRecord, SchemaTableRegistry, SchemaValidationError, Source, SourceColumns, SourceConfig, SourceConstraint, SourceConstraints, SourceConstraintsRecord, SourceIdentity, SourceIndex, SourceIndexesRecord, SourceKind, SourceLike, SourceProvision, SourceRow, SourceSqlTypeMap, SourceSqlTypes, SqliteConstraintExtension, SqliteIdentityExtension, SqliteIndexExtension, StorageDeclarationOf, StorageDescriptor, StorageDialectOf, StorageOf, StorageTypeOf, Table, TableColumns, TableDefinitions, TableIdentity, TableIndex, TableInsertInput, TableLike, TableMetadataCallback, TableOptions, TableRow, TableSqlTypes, TableUpdateInput, UniqueConstraint, UniqueConstraintOptions, UniqueNullSemantics, UnknownSourceSqlTypes, UnsafeSchemaSqlExpression, alias, assertSchemaDialectSupport, bigint, binary, boolean, canonicalLiteral, catalogCheck, catalogForeignKey, check, column, columnResultValue, columnSqlType, createSchemaDialect, createSource, customSource, date, defaultSchemaNamingPolicy, defineSchemaExpression, dialectMismatchDiagnostic, encodeColumnParameter, exposeColumns, externalDefault, externalGeneratedColumn, foreignKey, freezeSchemaMetadata, generatedColumn, generatedSchemaObjectName, generatedTableName, identityColumn, index, integer, isUnsafeSchemaSql, isValidSchemaObjectName, json, lateral, materializeSchemaObjectIdentity, materializeSchemaObjectRecord, nativeColumn, nativeStorage, normalizeSchemaSql, nullable, numeric, portableStorage, primaryKey, references, renderSchemaExpression, renderSchemaSql, resolveColumnBehavior, schema, schemaExpression, schemaNamingPolicyVersion, sourceIdentity, table, text, timestamp, unique, uniqueConstraint, unsafeSchemaSql, uuid, validateConstraintDialect, validateIndexDialect };