qubu 0.5.1 → 0.6.1

package/dist/snapshot/sqlite.mjs

@@ -0,0 +1,321 @@
+import { g as isValidSchemaObjectName, r as isColumnReference } from "../column-BzN8KFJa.mjs";
+import { d as validateIndexDialect, l as validateConstraintDialect } from "../constraints-DM_tarXc.mjs";
+import { a as renderSchemaExpression, r as isUnsafeSchemaSql } from "../expressions-BCjc08zw.mjs";
+import { t as createSchemaDialect } from "../dialect-wUKrnPMB.mjs";
+import { a as toSnapshotJsonValue } from "../canonical-DMvR9yBe.mjs";
+import { sqliteDialect } from "../sqlite.mjs";
+import { n as createSchemaSnapshot$1, s as tryCreateSchemaSnapshot$1 } from "../serialize-CE-gw5_s.mjs";
+//#region src/snapshot/sqlite.ts
+/** SQLite's v1 snapshot extension identity. */
+const sqliteSnapshotDialect = Object.freeze({
+	name: "sqlite",
+	version: 1
+});
+var SqliteSnapshotDialectError = class extends TypeError {
+	code = "dialect-mismatch";
+};
+const sqliteStorageTypes = Object.freeze({
+	integer: "INTEGER",
+	numeric: "NUMERIC",
+	text: "TEXT",
+	boolean: "INTEGER",
+	date: "TEXT",
+	timestamp: "TEXT",
+	uuid: "TEXT",
+	json: "TEXT",
+	bigint: "INTEGER",
+	binary: "BLOB"
+});
+/**
+* Resolve SQLite's declared-type affinity without changing the declaration. SQLite applies these
+* ordered substring rules at table creation time; the returned affinity is useful metadata, not a
+* replacement for the exact type.
+*/
+function storageAffinity(declaration) {
+	const upper = declaration.toUpperCase();
+	if (upper.includes("INT")) return "integer";
+	if (upper.includes("CHAR") || upper.includes("CLOB") || upper.includes("TEXT")) return "text";
+	if (upper.includes("BLOB") || upper.trim().length === 0) return "blob";
+	if (upper.includes("REAL") || upper.includes("FLOA") || upper.includes("DOUB")) return "real";
+	return "numeric";
+}
+/** SQLite's query dialect plus its schema metadata behavior. */
+const sqliteSchemaDialect = createSchemaDialect(sqliteDialect(), {
+	version: 1,
+	validate: validateSchema,
+	encodeStorage(storage, context) {
+		return encodeStorage(storage, context.dialect);
+	},
+	encodeExpression(expression, context) {
+		return encodeExpression(expression, context.mode, context.dialect);
+	},
+	encodeDialectExtension(extension, context) {
+		return encodeExtension(extension, context.dialect);
+	}
+});
+/** Snapshot adapter retaining the historical adapter-shaped entry point. */
+const sqliteSnapshotAdapter = Object.freeze({ dialect: sqliteSchemaDialect });
+/** Create a canonical SQLite schema snapshot. */
+function createSchemaSnapshot(schema, options = {}) {
+	return createSchemaSnapshot$1(schema, {
+		...options,
+		adapter: sqliteSnapshotAdapter
+	});
+}
+/** Return SQLite capability diagnostics without throwing. */
+function tryCreateSchemaSnapshot(schema, options = {}) {
+	return tryCreateSchemaSnapshot$1(schema, {
+		...options,
+		adapter: sqliteSnapshotAdapter
+	});
+}
+function encodeStorage(storage, dialect) {
+	if (storage.kind === "native") {
+		if (storage.dialect !== dialect.name) throw new SqliteSnapshotDialectError(`SQLite storage cannot encode a native declaration owned by "${storage.dialect}"`);
+		if (storage.type.trim().length === 0) throw new TypeError("SQLite native storage declarations cannot be empty");
+		return {
+			kind: "native",
+			dialect: dialect.name,
+			type: storage.type,
+			affinity: storageAffinity(storage.type)
+		};
+	}
+	const type = sqliteStorageTypes[storage.type];
+	if (type === void 0) throw new TypeError(`Unsupported portable storage type for SQLite: ${String(storage.type)}`);
+	return {
+		kind: "native",
+		dialect: dialect.name,
+		type,
+		affinity: storageAffinity(type)
+	};
+}
+function encodeExpression(expression, mode, dialect) {
+	if (isUnsafeSchemaSql(expression) && expression.schemaSqlDialect !== dialect.name) throw new SqliteSnapshotDialectError(`Schema SQL is tagged for "${expression.schemaSqlDialect}" but the SQLite schema dialect is "${dialect.name}"`);
+	const rendered = renderSchemaExpression(expression, {
+		mode,
+		dialect
+	});
+	if (rendered.parameters.length !== 0) throw new TypeError("SQLite schema expressions must be parameter-free");
+	return {
+		kind: "expression",
+		expressionKind: expression.expressionKind,
+		sql: rendered.text,
+		...isUnsafeSchemaSql(expression) ? { dialect: dialect.name } : {}
+	};
+}
+function encodeExtension(extension, dialect) {
+	if (extension.dialect !== dialect.name) throw new TypeError(`SQLite schema extensions require dialect "${dialect.name}"`);
+	const data = Object.fromEntries(Object.entries(extension).filter(([key]) => key !== "dialect").sort(([left], [right]) => left.localeCompare(right)));
+	return {
+		dialect: dialect.name,
+		version: dialect.schema.version,
+		data: sortSnapshotJson(toSnapshotJsonValue(data))
+	};
+}
+function sortSnapshotJson(value) {
+	if (Array.isArray(value)) return value.map(sortSnapshotJson);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortSnapshotJson(child)]));
+}
+function validateSchema(schema, context) {
+	const diagnostics = [];
+	const tableEntries = Object.entries(schema.registry).sort(([left], [right]) => compareIds(left, right));
+	const relationNames = /* @__PURE__ */ new Map();
+	if (schema.namespace !== void 0) validateName(schema.namespace, ["namespace"], "SQLite namespace", diagnostics);
+	for (const [id, entry] of tableEntries) {
+		const tablePath = ["tables", id];
+		validateName(entry.physicalName, [...tablePath, "physicalName"], "SQLite table", diagnostics);
+		addRelationName(relationNames, entry.physicalName, [...tablePath, "physicalName"], "table", diagnostics);
+	}
+	for (const [id, entry] of tableEntries) validateTable(id, entry, context, relationNames, diagnostics);
+	return Object.freeze(diagnostics);
+}
+function validateTable(tableId, entry, context, relationNames, diagnostics) {
+	const table = entry.table;
+	const tablePath = ["tables", tableId];
+	const definitions = table.definitions;
+	const metadata = table;
+	for (const [columnId, definition] of Object.entries(definitions).sort(([left], [right]) => compareIds(left, right))) {
+		validateName(table.sqlNames[columnId] ?? columnId, [
+			...tablePath,
+			"columns",
+			columnId,
+			"physicalName"
+		], "SQLite column", diagnostics);
+		if (definition.onUpdate !== void 0) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL ON UPDATE expressions are not supported by SQLite",
+			path: [
+				...tablePath,
+				"columns",
+				columnId,
+				"onUpdate"
+			]
+		});
+		const storage = definition.storage;
+		const identity = definition.identity;
+		if (identity !== void 0) {
+			const identityPath = [
+				...tablePath,
+				"columns",
+				columnId,
+				"identity"
+			];
+			const extension = identity.dialect;
+			if (extension !== void 0 && extension.dialect === "sqlite" && extension.autoIncrement !== void 0 && typeof extension.autoIncrement !== "boolean") diagnostics.push({
+				code: "unsupported-dialect-option",
+				message: "SQLite identity autoIncrement must be boolean",
+				path: [
+					...identityPath,
+					"dialect",
+					"autoIncrement"
+				]
+			});
+			const primary = primaryKeyForColumn(metadata.constraints, columnId);
+			const declaration = declarationFor(storage);
+			if ((declaration === void 0 ? void 0 : storageAffinity(declaration)) !== "integer") diagnostics.push({
+				code: "unsupported-dialect-option",
+				message: "SQLite identity columns must use INTEGER affinity so they can be rowid aliases",
+				path: [...identityPath, "generation"]
+			});
+			if (primary === void 0 || primary.length !== 1) diagnostics.push({
+				code: "unsupported-dialect-option",
+				message: "SQLite identity columns must be the sole column of a PRIMARY KEY constraint",
+				path: [...identityPath, "generation"]
+			});
+			if (extension?.dialect === "sqlite" && extension.autoIncrement === true && declaration?.trim().toUpperCase() !== "INTEGER") diagnostics.push({
+				code: "unsupported-dialect-option",
+				message: "SQLite AUTOINCREMENT requires an exact INTEGER PRIMARY KEY declaration",
+				path: [
+					...identityPath,
+					"dialect",
+					"autoIncrement"
+				]
+			});
+		}
+		if (definition.generatedColumn?.kind === "expression" && primaryKeyForColumn(metadata.constraints, columnId) !== void 0) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "SQLite generated columns cannot be part of a PRIMARY KEY",
+			path: [
+				...tablePath,
+				"columns",
+				columnId,
+				"generatedColumn"
+			]
+		});
+	}
+	const constraintNames = /* @__PURE__ */ new Map();
+	const constraints = Object.entries(metadata.constraints);
+	for (const [constraintId, constraint] of constraints.sort(([left], [right]) => compareIds(left, right))) {
+		const constraintPath = [
+			...tablePath,
+			"constraints",
+			constraintId
+		];
+		const physicalName = constraint.physicalName ?? constraintId;
+		validateName(physicalName, [...constraintPath, "physicalName"], "SQLite constraint", diagnostics);
+		addScopedName(constraintNames, physicalName, [...constraintPath, "physicalName"], "constraint", diagnostics);
+		appendMetadataDiagnostics(diagnostics, validateConstraintDialect(constraint, context.dialect.name, constraintPath));
+		if ((constraint.kind === "primary-key" || constraint.kind === "unique" || constraint.kind === "unique-constraint" || constraint.kind === "check") && (constraint.deferrable === true || constraint.initially !== void 0)) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "SQLite only supports DEFERRABLE timing on foreign-key constraints",
+			path: [...constraintPath, constraint.deferrable ? "deferrable" : "initially"]
+		});
+		if (constraint.kind === "foreign-key" && constraint.match !== void 0 && constraint.match !== "simple") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "SQLite supports MATCH SIMPLE foreign keys only",
+			path: [...constraintPath, "match"]
+		});
+		if (constraint.kind === "unique-constraint" && constraint.nulls === "not-distinct") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "SQLite UNIQUE constraints always use distinct NULL semantics in v1",
+			path: [...constraintPath, "nulls"]
+		});
+		if (constraint.dialect?.dialect === "sqlite" && "onConflict" in constraint.dialect && constraint.dialect.onConflict !== void 0 && ![
+			"rollback",
+			"abort",
+			"fail",
+			"ignore",
+			"replace"
+		].includes(String(constraint.dialect.onConflict))) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "SQLite constraint onConflict has an unsupported value",
+			path: [
+				...constraintPath,
+				"dialect",
+				"onConflict"
+			]
+		});
+	}
+	const indexes = Object.entries(metadata.indexes);
+	for (const [indexId, index] of indexes.sort(([left], [right]) => compareIds(left, right))) {
+		const indexPath = [
+			...tablePath,
+			"indexes",
+			indexId
+		];
+		const physicalName = index.physicalName ?? indexId;
+		validateName(physicalName, [...indexPath, "physicalName"], "SQLite index", diagnostics);
+		addRelationName(relationNames, physicalName, [...indexPath, "physicalName"], "index", diagnostics);
+		appendMetadataDiagnostics(diagnostics, validateIndexDialect(index, context.dialect.name, indexPath));
+		if (index.dialect?.dialect === "sqlite" && "auto" in index.dialect && index.dialect.auto !== void 0 && typeof index.dialect.auto !== "boolean") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "SQLite index auto must be boolean",
+			path: [
+				...indexPath,
+				"dialect",
+				"auto"
+			]
+		});
+	}
+}
+function declarationFor(storage) {
+	if (storage === void 0) return;
+	if (storage.kind === "native") return storage.type;
+	return sqliteStorageTypes[storage.type];
+}
+function primaryKeyForColumn(constraints, columnId) {
+	for (const constraint of Object.values(constraints)) {
+		if (constraint.kind !== "primary-key") continue;
+		if (constraint.columns.some((column) => isColumnReference(column) && column.fieldName === columnId)) return constraint.columns;
+	}
+}
+function validateName(name, path, kind, diagnostics) {
+	if (!isValidSchemaObjectName(name) || name.length === 0) diagnostics.push({
+		code: "invalid-schema",
+		message: `${kind} name "${name}" is not a valid unqualified identifier`,
+		path
+	});
+}
+function addRelationName(names, name, path, kind, diagnostics) {
+	addScopedName(names, name, path, kind, diagnostics);
+}
+function addScopedName(names, name, path, kind, diagnostics) {
+	const previousPath = names.get(name);
+	if (previousPath !== void 0) {
+		diagnostics.push({
+			code: "invalid-schema",
+			message: `SQLite ${kind} name "${name}" collides with another table or index`,
+			path,
+			relatedPaths: [previousPath]
+		});
+		return;
+	}
+	names.set(name, path);
+}
+function appendMetadataDiagnostics(diagnostics, issues) {
+	for (const issue of issues) {
+		if (issue.code === "dialect-mismatch") continue;
+		diagnostics.push({
+			code: issue.code === "unsupported-dialect-option" ? "unsupported-dialect-option" : "invalid-schema",
+			message: issue.message,
+			path: issue.path,
+			...issue.relatedPaths === void 0 ? {} : { relatedPaths: issue.relatedPaths }
+		});
+	}
+}
+function compareIds(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+//#endregion
+export { createSchemaSnapshot, sqliteSchemaDialect, sqliteSnapshotAdapter, sqliteSnapshotDialect, storageAffinity, tryCreateSchemaSnapshot };

package/dist/{snapshot-BSraiLtH.mjs → snapshot-DgsOhf_8.mjs}

@@ -1,44 +1,6 @@
 import { s as assertSchemaSnapshot } from "./canonical-DMvR9yBe.mjs";
-import { a as sqliteStorageAffinity } from "./sqlite-CsIUtZ2Q.mjs";
-//#region src/introspection/diagnostics.ts
-/**
-* Create one immutable diagnostic without interpreting catalog text or copying driver error details
-* into the structured fields.
-*/
-function createIntrospectionDiagnostic(diagnostic) {
-	return freezeDiagnostic(diagnostic);
-}
-/** Return whether a diagnostic list prevents strict introspection output. */
-function hasIntrospectionErrors(diagnostics) {
-	return diagnostics.some((diagnostic) => diagnostic.severity === "error");
-}
-/** Error raised by a throwing introspection operation after collecting findings. */
-var IntrospectionError = class extends Error {
-	name = "IntrospectionError";
-	diagnostics;
-	issues;
-	constructor(diagnostics) {
-		const frozenDiagnostics = Object.freeze(diagnostics.map((diagnostic) => freezeDiagnostic(diagnostic)));
-		super(frozenDiagnostics.map((diagnostic) => diagnostic.message).join("\n"));
-		this.diagnostics = frozenDiagnostics;
-		this.issues = frozenDiagnostics;
-	}
-};
-function freezeDiagnostic(diagnostic) {
-	return Object.freeze({
-		...diagnostic,
-		path: Object.freeze([...diagnostic.path]),
-		physicalReference: diagnostic.physicalReference ? freezeReference(diagnostic.physicalReference) : void 0,
-		relatedReferences: diagnostic.relatedReferences ? Object.freeze(diagnostic.relatedReferences.map((reference) => freezeReference(reference))) : void 0
-	});
-}
-function freezeReference(reference) {
-	return Object.freeze({
-		...reference,
-		catalog: reference.catalog ? Object.freeze({ ...reference.catalog }) : void 0
-	});
-}
-//#endregion
+import { storageAffinity } from "./snapshot/sqlite.mjs";
+import { n as createIntrospectionDiagnostic } from "./diagnostics-I9vVtXkc.mjs";
 //#region src/introspection/identity.ts
 /** The naming policy used by the first introspection snapshot mapper. */
 const introspectedPhysicalIdentityPolicy = Object.freeze({
@@ -119,7 +81,7 @@ function mapColumn(dialect, table, column, options, diagnostics) {
 		kind: "native",
 		dialect,
 		type: column.storage.nativeType,
-		...dialect === "sqlite" ? { affinity: sqliteStorageAffinity(column.storage.nativeType) } : {}
+		...dialect === "sqlite" ? { affinity: storageAffinity(column.storage.nativeType) } : {}
 	};
 	return {
 		id: resolveId("column", column.id, column.physicalName, table.physicalName, options),
@@ -389,4 +351,4 @@ function isError(value) {
 	return value.severity === "error";
 }
 //#endregion
-export { hasIntrospectionErrors as a, createIntrospectionDiagnostic as i, introspectedPhysicalIdentityPolicy as n, IntrospectionError as r, mapCatalogToSnapshot as t };
+export { introspectedPhysicalIdentityPolicy as n, mapCatalogToSnapshot as t };

package/dist/snapshot.d.mts

@@ -1,4 +1,5 @@
-import { A as SnapshotStorage, C as SnapshotIndexTerm, D as SnapshotLiteral, Dr as createSchemaDialect, E as SnapshotKeyConstraint, Er as SchemaDialectHooks, F as neutralSnapshotDialect, I as schemaSnapshotDialectVersion, L as schemaSnapshotFormat, M as SnapshotTable, N as SnapshotUniqueConstraint, O as SnapshotNamingPolicy, P as SnapshotValidationContext, R as schemaSnapshotNamingPolicyVersion, S as SnapshotIndex, T as SnapshotJsonValue, Tr as SchemaDialect, _ as SnapshotExpressionContext, a as SnapshotBigInt, b as SnapshotGeneratedColumn, c as SnapshotConstraint, d as SnapshotDefault, f as SnapshotDiagnostic, g as SnapshotExpression, h as SnapshotDialectExtension, i as SchemaSnapshotInput, j as SnapshotStorageContext, k as SnapshotSpecialNumber, l as SnapshotCreateResult, ls as PortableColumnStorage, m as SnapshotDialect, n as SchemaSnapshot, o as SnapshotCheckConstraint, os as NativeColumnStorage, p as SnapshotDiagnosticCode, r as SchemaSnapshotAdapter, s as SnapshotColumn, t as AnySchema, u as SnapshotDecodeResult, v as SnapshotExtensionContext, w as SnapshotIndexTermExpression, x as SnapshotIdentity, y as SnapshotForeignKey, z as schemaSnapshotVersion } from "./types-C0VkiwpR.mjs";
-import { A as CompleteSnapshotProvenance, B as SchemaSnapshotV2Input, C as CompleteSnapshotObjectMetadata, D as CompleteSnapshotPartition, E as CompleteSnapshotOwnership, F as CompleteSnapshotTrigger, G as schemaSnapshotVersion2, H as completeSchemaSnapshotVersion, I as CompleteSnapshotValueFact, L as CompleteSnapshotView, M as CompleteSnapshotRoutineParameter, N as CompleteSnapshotSequence, O as CompleteSnapshotPhysicalReference, P as CompleteSnapshotTable, R as SchemaSnapshotV2, S as CompleteSnapshotObjectKind, T as CompleteSnapshotOpaqueObject, U as schemaSnapshotCompleteVersion, V as completeSchemaSnapshotFormat, W as schemaSnapshotV2Version, _ as CompleteSnapshotIndex, a as CompleteSnapshotCollation, b as CompleteSnapshotNamespace, c as CompleteSnapshotConstraint, d as CompleteSnapshotDeferredObject, f as CompleteSnapshotDomain, g as CompleteSnapshotIdentity, h as CompleteSnapshotForeignKey, i as CompleteSnapshotCheckConstraint, j as CompleteSnapshotRoutine, k as CompleteSnapshotPolicy, l as CompleteSnapshotCreateResult, m as CompleteSnapshotExtension, n as CompleteSchemaSnapshotInput, o as CompleteSnapshotColumn, p as CompleteSnapshotEnum, r as CompleteSnapshotCapabilities, s as CompleteSnapshotComment, t as CompleteSchemaSnapshot, u as CompleteSnapshotDecodeResult, v as CompleteSnapshotIndexTerm, w as CompleteSnapshotObjectReference, x as CompleteSnapshotObject, y as CompleteSnapshotKeyConstraint, z as SchemaSnapshotV2DecodeResult } from "./complete-types-CY0KbzNw.mjs";
-import { A as assertSchemaSnapshot, B as decodeCompleteSchemaSnapshot, C as createSchemaSnapshot, D as serializeSchema, E as fingerprintSchemaSnapshot, F as assertCompleteSnapshot, G as encodeSchemaSnapshotV2, H as decodeSchemaSnapshotV2, I as assertSchemaSnapshotV2, J as SnapshotCanonicalError, K as fingerprintCompleteSchemaSnapshot, L as canonicalizeCompleteSchemaSnapshot, M as decodeSchemaSnapshot, N as CompleteSnapshotValidationError, O as tryCreateSchemaSnapshot, P as assertCompleteSchemaSnapshot, Q as toSnapshotJsonValue, R as canonicalizeSchemaSnapshotV2, S as SnapshotSerializationError, T as encodeSnapshot, U as encodeCompleteSchemaSnapshot, V as decodeCompleteSnapshot, W as encodeCompleteSnapshot, X as encodeCanonicalSnapshot, Y as canonicalJson, Z as schemaSnapshotFingerprint, _ as postgresSchemaDialect, a as mysqlSnapshotDialect, b as tryCreatePostgresSchemaSnapshot, c as SqliteStorageAffinity, d as sqliteSnapshotAdapter, f as sqliteSnapshotDialect, g as createPostgresSchemaSnapshot, h as PostgresSnapshotOptions, i as mysqlSnapshotAdapter, j as canonicalizeSchemaSnapshot, k as SnapshotValidationError, l as createSqliteSchemaSnapshot, m as tryCreateSqliteSchemaSnapshot, n as createMysqlSchemaSnapshot, o as tryCreateMysqlSchemaSnapshot, p as sqliteStorageAffinity, q as schemaSnapshotV2Fingerprint, r as mysqlSchemaDialect, s as SqliteSnapshotOptions, t as MysqlSnapshotOptions, u as sqliteSchemaDialect, v as postgresSnapshotAdapter, w as encodeSchemaSnapshot, x as SchemaSnapshotOptions, y as postgresSnapshotDialect, z as completeSchemaSnapshotFingerprint } from "./index-C-480HmV.mjs";
-export { AnySchema, CompleteSchemaSnapshot, CompleteSchemaSnapshotInput, CompleteSnapshotCapabilities, CompleteSnapshotCheckConstraint, CompleteSnapshotCollation, CompleteSnapshotColumn, CompleteSnapshotComment, CompleteSnapshotConstraint, CompleteSnapshotCreateResult, CompleteSnapshotDecodeResult, CompleteSnapshotDeferredObject, CompleteSnapshotDomain, CompleteSnapshotEnum, CompleteSnapshotExtension, CompleteSnapshotForeignKey, CompleteSnapshotIdentity, CompleteSnapshotIndex, CompleteSnapshotIndexTerm, CompleteSnapshotKeyConstraint, CompleteSnapshotNamespace, CompleteSnapshotObject, CompleteSnapshotObjectKind, CompleteSnapshotObjectMetadata, CompleteSnapshotObjectReference, CompleteSnapshotOpaqueObject, CompleteSnapshotOwnership, CompleteSnapshotPartition, CompleteSnapshotPhysicalReference, CompleteSnapshotPolicy, CompleteSnapshotProvenance, CompleteSnapshotRoutine, CompleteSnapshotRoutineParameter, CompleteSnapshotSequence, CompleteSnapshotTable, CompleteSnapshotTrigger, CompleteSnapshotValidationError, CompleteSnapshotValueFact, CompleteSnapshotView, MysqlSnapshotOptions, type NativeColumnStorage, type PortableColumnStorage, PostgresSnapshotOptions, type SchemaDialect, type SchemaDialectHooks, SchemaSnapshot, SchemaSnapshotAdapter, SchemaSnapshotInput, SchemaSnapshotOptions, SchemaSnapshotV2, SchemaSnapshotV2DecodeResult, SchemaSnapshotV2Input, SnapshotBigInt, SnapshotCanonicalError, SnapshotCheckConstraint, SnapshotColumn, SnapshotConstraint, SnapshotCreateResult, SnapshotDecodeResult, SnapshotDefault, SnapshotDiagnostic, SnapshotDiagnosticCode, SnapshotDialect, SnapshotDialectExtension, SnapshotExpression, SnapshotExpressionContext, SnapshotExtensionContext, SnapshotForeignKey, SnapshotGeneratedColumn, SnapshotIdentity, SnapshotIndex, SnapshotIndexTerm, SnapshotIndexTermExpression, SnapshotJsonValue, SnapshotKeyConstraint, SnapshotLiteral, SnapshotNamingPolicy, SnapshotSerializationError, SnapshotSpecialNumber, SnapshotStorage, SnapshotStorageContext, SnapshotTable, SnapshotUniqueConstraint, SnapshotValidationContext, SnapshotValidationError, SqliteSnapshotOptions, SqliteStorageAffinity, assertCompleteSchemaSnapshot, assertCompleteSnapshot, assertSchemaSnapshot, assertSchemaSnapshotV2, canonicalJson, canonicalizeCompleteSchemaSnapshot, canonicalizeSchemaSnapshot, canonicalizeSchemaSnapshotV2, completeSchemaSnapshotFingerprint, completeSchemaSnapshotFormat, completeSchemaSnapshotVersion, createMysqlSchemaSnapshot, createPostgresSchemaSnapshot, createSchemaDialect, createSchemaSnapshot, createSqliteSchemaSnapshot, decodeCompleteSchemaSnapshot, decodeCompleteSnapshot, decodeSchemaSnapshot, decodeSchemaSnapshotV2, encodeCanonicalSnapshot, encodeCompleteSchemaSnapshot, encodeCompleteSnapshot, encodeSchemaSnapshot, encodeSchemaSnapshotV2, encodeSnapshot, fingerprintCompleteSchemaSnapshot, fingerprintSchemaSnapshot, mysqlSchemaDialect, mysqlSnapshotAdapter, mysqlSnapshotDialect, neutralSnapshotDialect, postgresSchemaDialect, postgresSnapshotAdapter, postgresSnapshotDialect, schemaSnapshotCompleteVersion, schemaSnapshotDialectVersion, schemaSnapshotFingerprint, schemaSnapshotFormat, schemaSnapshotNamingPolicyVersion, schemaSnapshotV2Fingerprint, schemaSnapshotV2Version, schemaSnapshotVersion, schemaSnapshotVersion2, serializeSchema, sqliteSchemaDialect, sqliteSnapshotAdapter, sqliteSnapshotDialect, sqliteStorageAffinity, toSnapshotJsonValue, tryCreateMysqlSchemaSnapshot, tryCreatePostgresSchemaSnapshot, tryCreateSchemaSnapshot, tryCreateSqliteSchemaSnapshot };
+import { A as SnapshotStorage, Ar as SchemaDialect, C as SnapshotIndexTerm, D as SnapshotLiteral, E as SnapshotKeyConstraint, F as neutralSnapshotDialect, I as schemaSnapshotDialectVersion, L as schemaSnapshotFormat, M as SnapshotTable, Mr as createSchemaDialect, N as SnapshotUniqueConstraint, O as SnapshotNamingPolicy, P as SnapshotValidationContext, R as schemaSnapshotNamingPolicyVersion, S as SnapshotIndex, T as SnapshotJsonValue, _ as SnapshotExpressionContext, a as SnapshotBigInt, b as SnapshotGeneratedColumn, c as SnapshotConstraint, d as SnapshotDefault, ds as NativeColumnStorage, f as SnapshotDiagnostic, g as SnapshotExpression, h as SnapshotDialectExtension, i as SchemaSnapshotInput, j as SnapshotStorageContext, jr as SchemaDialectHooks, k as SnapshotSpecialNumber, l as SnapshotCreateResult, m as SnapshotDialect, ms as PortableColumnStorage, n as SchemaSnapshot, o as SnapshotCheckConstraint, p as SnapshotDiagnosticCode, r as SchemaSnapshotAdapter, s as SnapshotColumn, t as AnySchema, u as SnapshotDecodeResult, v as SnapshotExtensionContext, w as SnapshotIndexTermExpression, x as SnapshotIdentity, y as SnapshotForeignKey, z as schemaSnapshotVersion } from "./types-DUe6eeI0.mjs";
+import { A as CompleteSnapshotProvenance, B as SchemaSnapshotV2Input, C as CompleteSnapshotObjectMetadata, D as CompleteSnapshotPartition, E as CompleteSnapshotOwnership, F as CompleteSnapshotTrigger, G as schemaSnapshotVersion2, H as completeSchemaSnapshotVersion, I as CompleteSnapshotValueFact, L as CompleteSnapshotView, M as CompleteSnapshotRoutineParameter, N as CompleteSnapshotSequence, O as CompleteSnapshotPhysicalReference, P as CompleteSnapshotTable, R as SchemaSnapshotV2, S as CompleteSnapshotObjectKind, T as CompleteSnapshotOpaqueObject, U as schemaSnapshotCompleteVersion, V as completeSchemaSnapshotFormat, W as schemaSnapshotV2Version, _ as CompleteSnapshotIndex, a as CompleteSnapshotCollation, b as CompleteSnapshotNamespace, c as CompleteSnapshotConstraint, d as CompleteSnapshotDeferredObject, f as CompleteSnapshotDomain, g as CompleteSnapshotIdentity, h as CompleteSnapshotForeignKey, i as CompleteSnapshotCheckConstraint, j as CompleteSnapshotRoutine, k as CompleteSnapshotPolicy, l as CompleteSnapshotCreateResult, m as CompleteSnapshotExtension, n as CompleteSchemaSnapshotInput, o as CompleteSnapshotColumn, p as CompleteSnapshotEnum, r as CompleteSnapshotCapabilities, s as CompleteSnapshotComment, t as CompleteSchemaSnapshot, u as CompleteSnapshotDecodeResult, v as CompleteSnapshotIndexTerm, w as CompleteSnapshotObjectReference, x as CompleteSnapshotObject, y as CompleteSnapshotKeyConstraint, z as SchemaSnapshotV2DecodeResult } from "./complete-types-CNMWBWap.mjs";
+import { _ as toSnapshotJsonValue, a as encodeSnapshot, c as tryCreateSchemaSnapshot, d as canonicalizeSchemaSnapshot, f as decodeSchemaSnapshot, g as schemaSnapshotFingerprint, h as encodeCanonicalSnapshot, i as encodeSchemaSnapshot, l as SnapshotValidationError, m as canonicalJson, n as SnapshotSerializationError, o as fingerprintSchemaSnapshot, p as SnapshotCanonicalError, r as createSchemaSnapshot, s as serializeSchema, t as SchemaSnapshotOptions, u as assertSchemaSnapshot } from "./serialize-OvXCLzjm.mjs";
+import { a as canonicalizeCompleteSchemaSnapshot, c as decodeCompleteSchemaSnapshot, d as encodeCompleteSchemaSnapshot, f as encodeCompleteSnapshot, h as schemaSnapshotV2Fingerprint, i as assertSchemaSnapshotV2, l as decodeCompleteSnapshot, m as fingerprintCompleteSchemaSnapshot, n as assertCompleteSchemaSnapshot, o as canonicalizeSchemaSnapshotV2, p as encodeSchemaSnapshotV2, r as assertCompleteSnapshot, s as completeSchemaSnapshotFingerprint, t as CompleteSnapshotValidationError, u as decodeSchemaSnapshotV2 } from "./index-CGui70hi.mjs";
+export { AnySchema, CompleteSchemaSnapshot, CompleteSchemaSnapshotInput, CompleteSnapshotCapabilities, CompleteSnapshotCheckConstraint, CompleteSnapshotCollation, CompleteSnapshotColumn, CompleteSnapshotComment, CompleteSnapshotConstraint, CompleteSnapshotCreateResult, CompleteSnapshotDecodeResult, CompleteSnapshotDeferredObject, CompleteSnapshotDomain, CompleteSnapshotEnum, CompleteSnapshotExtension, CompleteSnapshotForeignKey, CompleteSnapshotIdentity, CompleteSnapshotIndex, CompleteSnapshotIndexTerm, CompleteSnapshotKeyConstraint, CompleteSnapshotNamespace, CompleteSnapshotObject, CompleteSnapshotObjectKind, CompleteSnapshotObjectMetadata, CompleteSnapshotObjectReference, CompleteSnapshotOpaqueObject, CompleteSnapshotOwnership, CompleteSnapshotPartition, CompleteSnapshotPhysicalReference, CompleteSnapshotPolicy, CompleteSnapshotProvenance, CompleteSnapshotRoutine, CompleteSnapshotRoutineParameter, CompleteSnapshotSequence, CompleteSnapshotTable, CompleteSnapshotTrigger, CompleteSnapshotValidationError, CompleteSnapshotValueFact, CompleteSnapshotView, type NativeColumnStorage, type PortableColumnStorage, type SchemaDialect, type SchemaDialectHooks, SchemaSnapshot, SchemaSnapshotAdapter, SchemaSnapshotInput, SchemaSnapshotOptions, SchemaSnapshotV2, SchemaSnapshotV2DecodeResult, SchemaSnapshotV2Input, SnapshotBigInt, SnapshotCanonicalError, SnapshotCheckConstraint, SnapshotColumn, SnapshotConstraint, SnapshotCreateResult, SnapshotDecodeResult, SnapshotDefault, SnapshotDiagnostic, SnapshotDiagnosticCode, SnapshotDialect, SnapshotDialectExtension, SnapshotExpression, SnapshotExpressionContext, SnapshotExtensionContext, SnapshotForeignKey, SnapshotGeneratedColumn, SnapshotIdentity, SnapshotIndex, SnapshotIndexTerm, SnapshotIndexTermExpression, SnapshotJsonValue, SnapshotKeyConstraint, SnapshotLiteral, SnapshotNamingPolicy, SnapshotSerializationError, SnapshotSpecialNumber, SnapshotStorage, SnapshotStorageContext, SnapshotTable, SnapshotUniqueConstraint, SnapshotValidationContext, SnapshotValidationError, assertCompleteSchemaSnapshot, assertCompleteSnapshot, assertSchemaSnapshot, assertSchemaSnapshotV2, canonicalJson, canonicalizeCompleteSchemaSnapshot, canonicalizeSchemaSnapshot, canonicalizeSchemaSnapshotV2, completeSchemaSnapshotFingerprint, completeSchemaSnapshotFormat, completeSchemaSnapshotVersion, createSchemaDialect, createSchemaSnapshot, decodeCompleteSchemaSnapshot, decodeCompleteSnapshot, decodeSchemaSnapshot, decodeSchemaSnapshotV2, encodeCanonicalSnapshot, encodeCompleteSchemaSnapshot, encodeCompleteSnapshot, encodeSchemaSnapshot, encodeSchemaSnapshotV2, encodeSnapshot, fingerprintCompleteSchemaSnapshot, fingerprintSchemaSnapshot, neutralSnapshotDialect, schemaSnapshotCompleteVersion, schemaSnapshotDialectVersion, schemaSnapshotFingerprint, schemaSnapshotFormat, schemaSnapshotNamingPolicyVersion, schemaSnapshotV2Fingerprint, schemaSnapshotV2Version, schemaSnapshotVersion, schemaSnapshotVersion2, serializeSchema, toSnapshotJsonValue, tryCreateSchemaSnapshot };