qubu 0.6.1 → 0.6.2

package/dist/introspection/sqlite.d.mts

@@ -1,4 +1,4 @@
-import { kt as CatalogConnection, st as IntrospectionCatalog, ut as IntrospectionOptions } from "../types-BEn0N_al.mjs";
+import { ft as IntrospectionOptions, jt as CatalogConnection, lt as IntrospectionCatalog } from "../types-CiMvKi5V.mjs";
 //#region src/introspection/sqlite.d.ts
 declare const sqliteServerQuery = "SELECT sqlite_version() AS version, sqlite_source_id() AS source_id";
 declare const sqliteDatabaseListQuery = "\n  SELECT seq, name, file\n  FROM pragma_database_list()\n  ORDER BY seq\n";

package/dist/introspection/sqlite.mjs

@@ -83,6 +83,7 @@ async function readCatalog(connection, options) {
 	const tableRows = await query(connection, sqliteTableListQuery, [options.namespace], options, diagnostics, "table-list");
 	const tableSql = new Map(schemaRows.map((row) => [text(row.name), text(row.sql)]).filter((entry) => entry[0] !== void 0));
 	const tables = tableRows.filter((row) => normalizeType(row.type) === "table").map((row) => table(row, tableSql.get(text(row.name) ?? "") ?? void 0, options.namespace));
+	const tableByName = new Map(tables.map((currentTable) => [currentTable.physicalName, currentTable]));
 	const deferredObjects = [];
 	const opaqueObjects = [];
 	for (const row of tableRows) {
@@ -141,7 +142,11 @@ async function readCatalog(connection, options) {
 		const rowidPrimaryKey = rows.filter((row) => (number(row.pk) ?? 0) > 0).length === 1;
 		const columns = rows.filter((row) => number(row.hidden) !== 1).map((row) => column(row, currentTable, options.namespace, sqlText, rowidPrimaryKey, diagnostics));
 		currentTable.columns = columns;
-		currentTable.constraints = tableConstraints(currentTable, rows, columns, sqlText, options.namespace);
+		currentTable.constraints = tableConstraints(currentTable, rows, columns, sqlText, options.namespace, diagnostics, opaqueObjects);
+	}
+	for (const currentTable of tables) {
+		const tableName = currentTable.physicalName;
+		const sqlText = tableSql.get(tableName);
 		const indexRows = await query(connection, sqliteIndexListQuery, [tableName, options.namespace], options, diagnostics, `index-list:${tableName}`);
 		const mappedIndexes = [];
 		const mappedConstraints = [...currentTable.constraints];
@@ -154,7 +159,8 @@ async function readCatalog(connection, options) {
 			else mappedConstraints.push(index);
 		}
 		const foreignRows = await query(connection, sqliteForeignKeyQuery, [tableName, options.namespace], options, diagnostics, `foreign-key:${tableName}`);
-		mappedConstraints.push(...foreignKeys(currentTable, foreignRows, options.namespace));
+		for (const value of foreignKeys(currentTable, foreignRows, tableByName, options.namespace, diagnostics)) if (value.kind === "opaque-object") opaqueObjects.push(value);
+		else mappedConstraints.push(value);
 		currentTable.indexes = mappedIndexes;
 		currentTable.constraints = mappedConstraints;
 	}
@@ -691,7 +697,7 @@ function column(row, table, namespace, sqlText, rowidPrimaryKey, diagnostics) {
 		id: stableId(physicalName),
 		identitySource: "physical-name",
 		physicalName,
-		ordinalPosition: number(row.cid) ?? 0,
+		ordinalPosition: (number(row.cid) ?? 0) + 1,
 		nullable: !boolean(row.not_null) && !(rowid || (number(row.pk) ?? 0) > 0 && (/WITHOUT\s+ROWID/i.test(sqlText ?? "") || /\bSTRICT\b/i.test(sqlText ?? ""))),
 		storage: { nativeType: type || "BLOB" },
 		default: defaultValue !== void 0 && !generatedExpression ? {
@@ -712,7 +718,7 @@ function column(row, table, namespace, sqlText, rowidPrimaryKey, diagnostics) {
 		})
 	};
 }
-function tableConstraints(table, rows, columns, sqlText, namespace) {
+function tableConstraints(table, rows, columns, sqlText, namespace, diagnostics, opaqueObjects) {
 	const primaryNames = new Map(rows.filter((row) => (number(row.pk) ?? 0) > 0).map((row) => [text(row.name), number(row.pk) ?? 0]));
 	const primaryColumns = columns.filter((column) => primaryNames.has(column.physicalName)).sort((left, right) => primaryNames.get(left.physicalName) - primaryNames.get(right.physicalName));
 	const constraints = [];
@@ -730,20 +736,142 @@ function tableConstraints(table, rows, columns, sqlText, namespace) {
 		};
 		constraints.push(primary);
 	}
-	[...sqlText?.matchAll(/(?:CONSTRAINT\s+("(?:[^"]|"")*"|`[^`]*`|\[[^\]]*\]|[A-Za-z_][A-Za-z0-9_$]*)\s+)?CHECK\s*\(([^()]*(?:\([^()]*\)[^()]*)*)\)/gi) ?? []].forEach((match, index) => {
-		const name = unquoteIdentifier(match[1]) ?? `check_${index}_${table.physicalName}`;
+	const checkResult = checkExpressions(sqlText);
+	checkResult.values.forEach((checkValue, index) => {
+		const name = checkValue.name ?? `check_${index}_${table.physicalName}`;
 		const check = {
 			kind: "check",
 			id: stableId(name),
 			identitySource: "deterministic-fallback",
 			physicalName: name,
-			expression: sql(match[2] ?? "true", namespace, table, name),
+			expression: sql(checkValue.expression, namespace, table, name),
 			dialect: extension({ source: "create-sql" })
 		};
 		constraints.push(check);
 	});
+	if (checkResult.unrecoverable) {
+		const name = checkResult.unrecoverableName ?? `check_${checkResult.values.length}_${table.physicalName}`;
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "expression-parse-failed",
+			message: `SQLite CHECK constraint ${name} could not be recovered from CREATE TABLE SQL`,
+			path: [
+				table.id,
+				"constraints",
+				name
+			],
+			physicalReference: reference("opaque-object", name, namespace, "sqlite_schema", "name"),
+			remediation: "Preserve the complete CREATE TABLE SQL or use lossy mode."
+		}));
+		opaqueObjects.push(opaqueCheckConstraint(table, name, sqlText, namespace));
+	}
 	return constraints;
 }
+function checkExpressions(sqlText) {
+	if (!sqlText) return {
+		values: [],
+		unrecoverable: false
+	};
+	const values = [];
+	let offset = 0;
+	while (offset < sqlText.length) {
+		const checkIndex = findSqlKeyword(sqlText, "CHECK", offset);
+		if (checkIndex < 0) return {
+			values,
+			unrecoverable: false
+		};
+		let open = checkIndex + 5;
+		while (/\s/.test(sqlText[open] ?? "")) open++;
+		if (sqlText[open] !== "(") {
+			offset = checkIndex + 5;
+			continue;
+		}
+		const close = matchingParen(sqlText, open);
+		if (close < 0) return {
+			values,
+			unrecoverable: true,
+			unrecoverableName: checkConstraintName(sqlText, checkIndex)
+		};
+		values.push({
+			name: checkConstraintName(sqlText, checkIndex),
+			expression: sqlText.slice(open + 1, close).trim()
+		});
+		offset = close + 1;
+	}
+	return {
+		values,
+		unrecoverable: false
+	};
+}
+function findSqlKeyword(source, keyword, start) {
+	let quote;
+	for (let index = start; index < source.length; index++) {
+		const character = source[index];
+		if (quote === "single") {
+			if (character === "'" && source[index + 1] === "'") index++;
+			else if (character === "'") quote = void 0;
+			continue;
+		}
+		if (quote === "double") {
+			if (character === "\"" && source[index + 1] === "\"") index++;
+			else if (character === "\"") quote = void 0;
+			continue;
+		}
+		if (quote === "backtick") {
+			if (character === "`") quote = void 0;
+			continue;
+		}
+		if (quote === "bracket") {
+			if (character === "]") quote = void 0;
+			continue;
+		}
+		if (character === "'") {
+			quote = "single";
+			continue;
+		}
+		if (character === "\"") {
+			quote = "double";
+			continue;
+		}
+		if (character === "`") {
+			quote = "backtick";
+			continue;
+		}
+		if (character === "[") {
+			quote = "bracket";
+			continue;
+		}
+		if (source.slice(index, index + keyword.length).toUpperCase() === keyword.toUpperCase() && !isSqlIdentifierCharacter(source[index - 1]) && !isSqlIdentifierCharacter(source[index + keyword.length])) return index;
+	}
+	return -1;
+}
+function isSqlIdentifierCharacter(value) {
+	return value !== void 0 && /[A-Za-z0-9_$]/.test(value);
+}
+function checkConstraintName(source, checkIndex) {
+	return unquoteIdentifier(source.slice(0, checkIndex).match(/CONSTRAINT\s+("(?:[^"]|"")*"|`[^`]*`|\[[^\]]*\]|[A-Za-z_][A-Za-z0-9_$]*)\s*$/i)?.[1]);
+}
+function opaqueCheckConstraint(table, constraintName, sqlText, namespace) {
+	const physicalReference = reference("opaque-object", constraintName, namespace, "sqlite_schema", "name", table.physicalName);
+	return {
+		kind: "opaque-object",
+		id: stableId(`check:${table.physicalName}:${constraintName}`),
+		identitySource: "deterministic-fallback",
+		objectKind: "check-constraint",
+		physicalName: constraintName,
+		data: {
+			table: table.physicalName,
+			reason: "definition-unavailable"
+		},
+		...sqlText === void 0 ? {} : { sql: sql(sqlText, namespace, table, constraintName) },
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "sqlite",
+			reference: physicalReference
+		}
+	};
+}
 function mapIndex(table, row, infoRows, sqlText, namespace, diagnostics, opaqueObjects) {
 	const physicalName = text(row.name);
 	if (!physicalName) return;
@@ -848,7 +976,7 @@ function declaredConstraintName(sqlText, keyword, columns) {
 		if (found.length === columns.length && found.every((value, index) => value === columns[index])) return unquoteIdentifier(match[1]);
 	}
 }
-function foreignKeys(table, rows, namespace) {
+function foreignKeys(table, rows, tables, namespace, diagnostics) {
 	const grouped = /* @__PURE__ */ new Map();
 	for (const row of rows) {
 		const id = text(row.id) ?? "0";
@@ -857,17 +985,53 @@ function foreignKeys(table, rows, namespace) {
 		grouped.set(id, group);
 	}
 	return [...grouped.entries()].map(([key, group]) => {
-		const first = group[0];
+		const ordered = [...group].sort((left, right) => (number(left.seq) ?? 0) - (number(right.seq) ?? 0));
+		const first = ordered[0];
 		const physicalName = `foreign_key_${table.physicalName}_${key}`;
+		const targetTableName = text(first.target_table);
+		const targetTable = targetTableName === void 0 ? void 0 : tables.get(targetTableName);
+		const targetColumns = ordered.map((row) => text(row.target_column));
+		const sourceColumns = ordered.map((row) => text(row.source_column));
+		const explicitTargetColumns = targetColumns.every((column) => column !== void 0);
+		const implicitTargetColumns = targetColumns.every((column) => column === void 0);
+		let normalizedTargetColumns;
+		let problem;
+		if (targetTableName === void 0) problem = "has no referenced table";
+		else if (targetTable === void 0) problem = `references table ${targetTableName}, which is not visible`;
+		else if (implicitTargetColumns) {
+			const primaryKey = targetTable.constraints.find((constraint) => constraint.kind === "primary-key");
+			if (primaryKey === void 0) problem = `references ${targetTableName} without target columns, but that table has no declared primary key`;
+			else if (primaryKey.columns.length !== ordered.length) problem = `references ${targetTableName} without target columns with an incompatible primary-key width`;
+			else normalizedTargetColumns = primaryKey.columns;
+		} else if (explicitTargetColumns) normalizedTargetColumns = targetColumns;
+		else problem = "has a mixture of explicit and implicit target columns";
+		if (sourceColumns.some((column) => column === void 0)) problem = problem ?? "has an unresolved source column";
+		const physicalReference = reference("opaque-object", physicalName, namespace, "pragma_foreign_key_list", "id", key);
+		if (problem !== void 0 || targetTableName === void 0 || normalizedTargetColumns === void 0) {
+			diagnostics.push(createIntrospectionDiagnostic({
+				severity: "error",
+				code: "unresolved-reference",
+				message: `SQLite foreign key ${physicalName} ${problem ?? "has no recoverable target columns"}`,
+				path: [
+					table.id,
+					"constraints",
+					physicalName,
+					"target"
+				],
+				physicalReference,
+				remediation: "Declare explicit target columns or expose the referenced table primary key."
+			}));
+			return opaqueForeignKey(table, physicalName, key, targetTableName, sourceColumns, targetColumns, physicalReference);
+		}
 		return {
 			kind: "foreign-key",
 			id: stableId(physicalName),
 			identitySource: "deterministic-fallback",
 			physicalName,
-			columns: group.sort((left, right) => (number(left.seq) ?? 0) - (number(right.seq) ?? 0)).map((row) => text(row.source_column) ?? "unknown"),
+			columns: sourceColumns,
 			target: {
-				table: text(first.target_table) ?? "unknown",
-				columns: group.map((row) => text(row.target_column) ?? "unknown")
+				table: targetTableName,
+				columns: normalizedTargetColumns
 			},
 			onUpdate: action(first.on_update),
 			onDelete: action(first.on_delete),
@@ -877,6 +1041,28 @@ function foreignKeys(table, rows, namespace) {
 		};
 	});
 }
+function opaqueForeignKey(table, physicalName, key, targetTable, sourceColumns, targetColumns, physicalReference) {
+	return {
+		kind: "opaque-object",
+		id: stableId(`foreign-key:${table.physicalName}:${key}`),
+		identitySource: "deterministic-fallback",
+		objectKind: "foreign-key",
+		physicalName,
+		data: {
+			table: table.physicalName,
+			foreignKeyId: key,
+			...targetTable === void 0 ? {} : { targetTable },
+			sourceColumns: sourceColumns.map((column) => column ?? null),
+			targetColumns: targetColumns.map((column) => column ?? null)
+		},
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "sqlite",
+			reference: physicalReference
+		}
+	};
+}
 function partialPredicate(sqlText, indexName, namespace, table) {
 	const predicate = (sqlText?.match(/\bWHERE\s+([\s\S]+)$/i))?.[1]?.trim().replace(/;\s*$/, "");
 	return predicate ? sql(predicate, namespace, table, indexName) : void 0;

package/dist/introspection.d.mts

@@ -1,5 +1,5 @@
-import { $ as CatalogTrigger, A as CatalogNamespace, At as CatalogQuery, B as CatalogPrimaryKeyConstraint, C as CatalogForeignKeyTarget, Ct as IntrospectionDiagnosticCode, D as CatalogIndexTerm, Dt as createIntrospectionDiagnostic, E as CatalogIndex, Et as IntrospectionError, F as CatalogOpaqueObject, G as CatalogRoutine, H as CatalogProvenanceKind, I as CatalogOwnership, J as CatalogSequence, K as CatalogRoutineParameter, L as CatalogPartition, M as CatalogObjectBase, N as CatalogObjectMetadata, O as CatalogIntrospector, Ot as hasIntrospectionErrors, P as CatalogObjectReference, Q as CatalogTable, R as CatalogPolicy, S as CatalogForeignKeyConstraint, St as IntrospectionDiagnostic, T as CatalogIdentity, Tt as IntrospectionDiagnosticSeverity, U as CatalogQueryRow, V as CatalogProvenance, W as CatalogReference, X as CatalogSqlExpression, Y as CatalogServerInfo, Z as CatalogStorageType, _ as CatalogEntityReference, _t as CatalogIdentityPolicy, a as CatalogCollation, at as CatalogView, b as CatalogExpressionFact, bt as CatalogResolvedIdentity, c as CatalogCompleteObject, ct as IntrospectionFailure, d as CatalogDeferredObject, dt as IntrospectionResult, et as CatalogUniqueConstraint, f as CatalogDeferredObjectKind, ft as IntrospectionSuccess, g as CatalogEntityKind, gt as CatalogIdentityHints, h as CatalogDomain, ht as CatalogIdentityHint, i as CatalogClassificationConfidence, it as CatalogVersion, j as CatalogObject, jt as CatalogQueryOptions, k as CatalogLiteralFact, kt as CatalogConnection, l as CatalogConstraint, lt as IntrospectionMode, m as CatalogDialectExtension, mt as CatalogIdentityFallback, n as CatalogCatalogReference, nt as CatalogUnknownObject, o as CatalogColumn, ot as CompleteIntrospectionCatalog, p as CatalogDialect, pt as CatalogIdentityEntityKind, q as CatalogScalar, r as CatalogCheckConstraint, rt as CatalogValueFact, s as CatalogComment, st as IntrospectionCatalog, t as CatalogCapabilities, tt as CatalogUnknownField, u as CatalogData, ut as IntrospectionOptions, v as CatalogEnum, vt as CatalogIdentitySource, w as CatalogGeneratedColumn, wt as IntrospectionDiagnosticInput, x as CatalogExtensionObject, xt as introspectedPhysicalIdentityPolicy, y as CatalogEnumValue, yt as CatalogPreviousSnapshotIdentitySource, z as CatalogPortableStorageType } from "./types-BEn0N_al.mjs";
-import { t as CompleteSchemaSnapshot } from "./complete-types-CNMWBWap.mjs";
+import { $ as CatalogStorageType, A as CatalogNamespace, At as hasIntrospectionErrors, B as CatalogPolicy, C as CatalogForeignKeyTarget, Ct as introspectedPhysicalIdentityPolicy, D as CatalogIndexTerm, Dt as IntrospectionDiagnosticSeverity, E as CatalogIndex, Et as IntrospectionDiagnosticInput, F as CatalogObjectOwnerKind, G as CatalogQueryRow, H as CatalogPrimaryKeyConstraint, I as CatalogObjectReference, J as CatalogRoutineParameter, K as CatalogReference, L as CatalogOpaqueObject, M as CatalogObjectBase, Mt as CatalogQuery, N as CatalogObjectMetadata, Nt as CatalogQueryOptions, O as CatalogIntrospector, Ot as IntrospectionError, P as CatalogObjectOwner, Q as CatalogSqlExpression, R as CatalogOwnership, S as CatalogForeignKeyConstraint, St as CatalogResolvedIdentity, T as CatalogIdentity, Tt as IntrospectionDiagnosticCode, U as CatalogProvenance, V as CatalogPortableStorageType, W as CatalogProvenanceKind, X as CatalogSequence, Y as CatalogScalar, Z as CatalogServerInfo, _ as CatalogEntityReference, _t as CatalogIdentityHint, a as CatalogCollation, at as CatalogValueFact, b as CatalogExpressionFact, bt as CatalogIdentitySource, c as CatalogCompleteObject, ct as CompleteIntrospectionCatalog, d as CatalogDeferredObject, dt as IntrospectionMode, et as CatalogTable, f as CatalogDeferredObjectKind, ft as IntrospectionOptions, g as CatalogEntityKind, gt as CatalogIdentityFallback, h as CatalogDomain, ht as CatalogIdentityEntityKind, i as CatalogClassificationConfidence, it as CatalogUnknownObject, j as CatalogObject, jt as CatalogConnection, k as CatalogLiteralFact, kt as createIntrospectionDiagnostic, l as CatalogConstraint, lt as IntrospectionCatalog, m as CatalogDialectExtension, mt as IntrospectionSuccess, n as CatalogCatalogReference, nt as CatalogUniqueConstraint, o as CatalogColumn, ot as CatalogVersion, p as CatalogDialect, pt as IntrospectionResult, q as CatalogRoutine, r as CatalogCheckConstraint, rt as CatalogUnknownField, s as CatalogComment, st as CatalogView, t as CatalogCapabilities, tt as CatalogTrigger, u as CatalogData, ut as IntrospectionFailure, v as CatalogEnum, vt as CatalogIdentityHints, w as CatalogGeneratedColumn, wt as IntrospectionDiagnostic, x as CatalogExtensionObject, xt as CatalogPreviousSnapshotIdentitySource, y as CatalogEnumValue, yt as CatalogIdentityPolicy, z as CatalogPartition } from "./types-CiMvKi5V.mjs";
+import { B as CompleteSchemaSnapshot } from "./types-Dqr4o2I1.mjs";
 //#region src/introspection/catalog.d.ts
 /**
  * Materialize every optional object-family collection and deeply freeze the normalized catalog.
@@ -13,13 +13,19 @@ declare const freezeIntrospectionCatalog: typeof createCompleteIntrospectionCata
 declare function toIntrospectionCatalog(catalog: CompleteIntrospectionCatalog): IntrospectionCatalog;
 //#endregion
 //#region src/introspection/complete-snapshot.d.ts
-/** Result returned by the strict normalized-catalog to Snapshot v2 mapper. */
+/** Result returned by the normalized-catalog-to-Snapshot v1 mapper, including lossiness status. */
 type CompleteSnapshotMappingResult = {
   readonly ok: true;
   readonly catalog: CompleteIntrospectionCatalog;
   readonly snapshot: CompleteSchemaSnapshot;
   readonly diagnostics: readonly IntrospectionDiagnostic[];
   readonly lossy: false;
+} | {
+  readonly ok: true;
+  readonly catalog: CompleteIntrospectionCatalog;
+  readonly snapshot: CompleteSchemaSnapshot;
+  readonly diagnostics: readonly IntrospectionDiagnostic[];
+  readonly lossy: true;
 } | {
   readonly ok: false;
   readonly catalog: CompleteIntrospectionCatalog;
@@ -27,16 +33,24 @@ type CompleteSnapshotMappingResult = {
   readonly lossy: false;
 };
 /**
- * Map a normalized catalog to strict Snapshot v2 data. This is intentionally separate from the
- * Snapshot v1 mapper: complete objects are never fabricated as tables, and catalog references
- * remain evidence rather than logical IDs.
+ * Map a normalized catalog to validated Snapshot v1 data.
+ *
+ * Strict mode reports mapping errors as failure. Explicit lossy mode may omit only recoverable
+ * unsafe facts and marks a successful result as lossy. Complete objects are never fabricated as
+ * tables, and catalog references remain evidence rather than logical IDs.
  */
-declare function mapCatalogToCompleteSnapshot(input: IntrospectionCatalog): CompleteSnapshotMappingResult;
-/** Numbered alias for callers that keep both snapshot mappers available. */
-declare const mapCatalogToSnapshotV2: typeof mapCatalogToCompleteSnapshot;
+declare function mapCatalogToCompleteSnapshot(input: IntrospectionCatalog, options?: IntrospectionOptions): CompleteSnapshotMappingResult;
+/** Numbered alias for callers that prefer the explicit Snapshot v1 mapper name. */
+declare const mapCatalogToSnapshotV1: typeof mapCatalogToCompleteSnapshot;
 //#endregion
 //#region src/introspection/snapshot.d.ts
-/** Construct and validate a canonical Snapshot v1 from a normalized catalog. */
-declare function mapCatalogToSnapshot(catalog: IntrospectionCatalog, options: IntrospectionOptions): IntrospectionResult;
+/**
+ * Map a normalized catalog to the canonical Snapshot v1 object model.
+ *
+ * Snapshot identity and namespace facts come from the normalized catalog, with explicit identity
+ * continuity options applied during the mapping step. Strict mode fails on mapping errors; lossy
+ * mode may omit recoverable facts and marks successful output accordingly.
+ */
+declare function mapCatalogToSnapshot(catalog: IntrospectionCatalog, options?: IntrospectionOptions): IntrospectionResult;
 //#endregion
-export { CatalogCapabilities, CatalogCatalogReference, CatalogCheckConstraint, CatalogClassificationConfidence, CatalogCollation, CatalogColumn, CatalogComment, CatalogCompleteObject, CatalogConnection, CatalogConstraint, CatalogData, CatalogDeferredObject, CatalogDeferredObjectKind, CatalogDialect, CatalogDialectExtension, CatalogDomain, CatalogEntityKind, CatalogEntityReference, CatalogEnum, CatalogEnumValue, CatalogExpressionFact, CatalogExtensionObject, CatalogForeignKeyConstraint, CatalogForeignKeyTarget, CatalogGeneratedColumn, CatalogIdentity, CatalogIdentityEntityKind, CatalogIdentityFallback, CatalogIdentityHint, CatalogIdentityHints, CatalogIdentityPolicy, CatalogIdentitySource, CatalogIndex, CatalogIndexTerm, CatalogIntrospector, CatalogLiteralFact, CatalogNamespace, CatalogObject, CatalogObjectBase, CatalogObjectMetadata, CatalogObjectReference, CatalogOpaqueObject, CatalogOwnership, CatalogPartition, CatalogPolicy, CatalogPortableStorageType, CatalogPreviousSnapshotIdentitySource, CatalogPrimaryKeyConstraint, CatalogProvenance, CatalogProvenanceKind, CatalogQuery, CatalogQueryOptions, CatalogQueryRow, CatalogReference, CatalogResolvedIdentity, CatalogRoutine, CatalogRoutineParameter, CatalogScalar, CatalogSequence, CatalogServerInfo, CatalogSqlExpression, CatalogStorageType, CatalogTable, CatalogTrigger, CatalogUniqueConstraint, CatalogUnknownField, CatalogUnknownObject, CatalogValueFact, CatalogVersion, CatalogView, CompleteIntrospectionCatalog, CompleteSnapshotMappingResult, IntrospectionCatalog, IntrospectionDiagnostic, IntrospectionDiagnosticCode, IntrospectionDiagnosticInput, IntrospectionDiagnosticSeverity, IntrospectionError, IntrospectionFailure, IntrospectionMode, IntrospectionOptions, IntrospectionResult, IntrospectionSuccess, createCompleteIntrospectionCatalog, createIntrospectionDiagnostic, freezeIntrospectionCatalog, hasIntrospectionErrors, introspectedPhysicalIdentityPolicy, mapCatalogToCompleteSnapshot, mapCatalogToSnapshot, mapCatalogToSnapshotV2, toIntrospectionCatalog };
+export { CatalogCapabilities, CatalogCatalogReference, CatalogCheckConstraint, CatalogClassificationConfidence, CatalogCollation, CatalogColumn, CatalogComment, CatalogCompleteObject, CatalogConnection, CatalogConstraint, CatalogData, CatalogDeferredObject, CatalogDeferredObjectKind, CatalogDialect, CatalogDialectExtension, CatalogDomain, CatalogEntityKind, CatalogEntityReference, CatalogEnum, CatalogEnumValue, CatalogExpressionFact, CatalogExtensionObject, CatalogForeignKeyConstraint, CatalogForeignKeyTarget, CatalogGeneratedColumn, CatalogIdentity, CatalogIdentityEntityKind, CatalogIdentityFallback, CatalogIdentityHint, CatalogIdentityHints, CatalogIdentityPolicy, CatalogIdentitySource, CatalogIndex, CatalogIndexTerm, CatalogIntrospector, CatalogLiteralFact, CatalogNamespace, CatalogObject, CatalogObjectBase, CatalogObjectMetadata, CatalogObjectOwner, CatalogObjectOwnerKind, CatalogObjectReference, CatalogOpaqueObject, CatalogOwnership, CatalogPartition, CatalogPolicy, CatalogPortableStorageType, CatalogPreviousSnapshotIdentitySource, CatalogPrimaryKeyConstraint, CatalogProvenance, CatalogProvenanceKind, CatalogQuery, CatalogQueryOptions, CatalogQueryRow, CatalogReference, CatalogResolvedIdentity, CatalogRoutine, CatalogRoutineParameter, CatalogScalar, CatalogSequence, CatalogServerInfo, CatalogSqlExpression, CatalogStorageType, CatalogTable, CatalogTrigger, CatalogUniqueConstraint, CatalogUnknownField, CatalogUnknownObject, CatalogValueFact, CatalogVersion, CatalogView, CompleteIntrospectionCatalog, CompleteSnapshotMappingResult, IntrospectionCatalog, IntrospectionDiagnostic, IntrospectionDiagnosticCode, IntrospectionDiagnosticInput, IntrospectionDiagnosticSeverity, IntrospectionError, IntrospectionFailure, IntrospectionMode, IntrospectionOptions, IntrospectionResult, IntrospectionSuccess, createCompleteIntrospectionCatalog, createIntrospectionDiagnostic, freezeIntrospectionCatalog, hasIntrospectionErrors, introspectedPhysicalIdentityPolicy, mapCatalogToCompleteSnapshot, mapCatalogToSnapshot, mapCatalogToSnapshotV1, toIntrospectionCatalog };