@wrtnlabs/evidence 0.0.0

package/lib/adapters/postgresql/PostgresqlOwnership.js

@@ -0,0 +1,668 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresqlOwnership = void 0;
+const _assertGuard_1 = __importStar(require("typia/lib/internal/_assertGuard"));
+const typia_1 = __importDefault(require("typia"));
+/** Reconciles ALTER and COMMENT sites independently of selected file ordering.
+ *
+ * PostgreSQL permits extension statements in other files, so publication waits
+ * until a unique selected declaration can establish their semantic ownership.
+ */
+var PostgresqlOwnership;
+(function (PostgresqlOwnership) {
+    /** Resolves every deferred extension against exactly one declaration.
+     *
+     * Ambiguity makes analysis incomplete rather than allowing an ALTER or COMMENT
+     * to silently attach to an arbitrary same-named table.
+     */
+    function resolve(input) {
+        const analyses = (() => {
+            const _ip0 = input => "string" === typeof input["id"];
+            const _ip1 = input => Array.isArray(input["identity"]) && input["identity"].every(elem => "string" === typeof elem);
+            const _ip2 = input => "string" === typeof input["file"];
+            const _ip3 = input => "object" === typeof input["range"] && null !== input["range"] && _io5(input["range"]);
+            const _ip4 = input => "boolean" === typeof input["tagBoundaries"];
+            const _ip5 = input => "boolean" === typeof input["allowWithdrawal"];
+            const _ip6 = input => "string" === typeof input["declarationId"];
+            const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["id"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".id",
+                expected: "string",
+                value: input["id"]
+            }, _errorFactory);
+            const _ap1 = (input, _path, _exceptionable = true) => (Array.isArray(input["identity"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".identity",
+                expected: "Array<string>",
+                value: input["identity"]
+            }, _errorFactory)) && input["identity"].every((elem, _index21) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".identity[" + _index21 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".identity",
+                expected: "Array<string>",
+                value: input["identity"]
+            }, _errorFactory);
+            const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["file"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".file",
+                expected: "string",
+                value: input["file"]
+            }, _errorFactory);
+            const _ap3 = (input, _path, _exceptionable = true) => ("object" === typeof input["range"] && null !== input["range"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".range",
+                expected: "IEvidenceSourceRange",
+                value: input["range"]
+            }, _errorFactory)) && _ao5(input["range"], _path + ".range", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".range",
+                expected: "IEvidenceSourceRange",
+                value: input["range"]
+            }, _errorFactory);
+            const _ap4 = (input, _path, _exceptionable = true) => "boolean" === typeof input["tagBoundaries"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".tagBoundaries",
+                expected: "boolean",
+                value: input["tagBoundaries"]
+            }, _errorFactory);
+            const _ap5 = (input, _path, _exceptionable = true) => "boolean" === typeof input["allowWithdrawal"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".allowWithdrawal",
+                expected: "boolean",
+                value: input["allowWithdrawal"]
+            }, _errorFactory);
+            const _ap6 = (input, _path, _exceptionable = true) => "string" === typeof input["declarationId"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".declarationId",
+                expected: "string",
+                value: input["declarationId"]
+            }, _errorFactory);
+            const _ao0 = (input, _path, _exceptionable = true) => (("object" === typeof input.source && null !== input.source || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".source",
+                expected: "IEvidenceSourceFile",
+                value: input.source
+            }, _errorFactory)) && _ao1(input.source, _path + ".source", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".source",
+                expected: "IEvidenceSourceFile",
+                value: input.source
+            }, _errorFactory)) && ((Array.isArray(input.declarations) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".declarations",
+                expected: "Array<ISqlDeclaration>",
+                value: input.declarations
+            }, _errorFactory)) && input.declarations.every((elem, _index16) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".declarations[" + _index16 + "]",
+                expected: "ISqlDeclaration",
+                value: elem
+            }, _errorFactory)) && _ao3(elem, _path + ".declarations[" + _index16 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".declarations[" + _index16 + "]",
+                expected: "ISqlDeclaration",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".declarations",
+                expected: "Array<ISqlDeclaration>",
+                value: input.declarations
+            }, _errorFactory)) && ((Array.isArray(input.documentation) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".documentation",
+                expected: "Array<ISqlDocumentation>",
+                value: input.documentation
+            }, _errorFactory)) && input.documentation.every((elem, _index17) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".documentation[" + _index17 + "]",
+                expected: "ISqlDocumentation",
+                value: elem
+            }, _errorFactory)) && _ao7(elem, _path + ".documentation[" + _index17 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".documentation[" + _index17 + "]",
+                expected: "ISqlDocumentation",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".documentation",
+                expected: "Array<ISqlDocumentation>",
+                value: input.documentation
+            }, _errorFactory)) && ((Array.isArray(input.diagnostics) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics",
+                expected: "Array<IEvidenceDiagnostic>",
+                value: input.diagnostics
+            }, _errorFactory)) && input.diagnostics.every((elem, _index18) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics[" + _index18 + "]",
+                expected: "IEvidenceDiagnostic",
+                value: elem
+            }, _errorFactory)) && _ao11(elem, _path + ".diagnostics[" + _index18 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics[" + _index18 + "]",
+                expected: "IEvidenceDiagnostic",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics",
+                expected: "Array<IEvidenceDiagnostic>",
+                value: input.diagnostics
+            }, _errorFactory)) && ("boolean" === typeof input.complete || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".complete",
+                expected: "boolean",
+                value: input.complete
+            }, _errorFactory)) && (undefined === input.references || (Array.isArray(input.references) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".references",
+                expected: "(Array<IPostgresqlReference> | undefined)",
+                value: input.references
+            }, _errorFactory)) && input.references.every((elem, _index19) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".references[" + _index19 + "]",
+                expected: "IPostgresqlReference",
+                value: elem
+            }, _errorFactory)) && _ao13(elem, _path + ".references[" + _index19 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".references[" + _index19 + "]",
+                expected: "IPostgresqlReference",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".references",
+                expected: "(Array<IPostgresqlReference> | undefined)",
+                value: input.references
+            }, _errorFactory));
+            const _ao1 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && ("string" === typeof input.physicalPath || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".physicalPath",
+                expected: "string",
+                value: input.physicalPath
+            }, _errorFactory)) && ("string" === typeof input.content || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".content",
+                expected: "string",
+                value: input.content
+            }, _errorFactory)) && ("string" === typeof input.digest || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".digest",
+                expected: "string",
+                value: input.digest
+            }, _errorFactory)) && ((Array.isArray(input.addresses) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses",
+                expected: "Array<IEvidenceSourceAddress>",
+                value: input.addresses
+            }, _errorFactory)) && input.addresses.every((elem, _index20) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses[" + _index20 + "]",
+                expected: "IEvidenceSourceAddress",
+                value: elem
+            }, _errorFactory)) && _ao2(elem, _path + ".addresses[" + _index20 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses[" + _index20 + "]",
+                expected: "IEvidenceSourceAddress",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses",
+                expected: "Array<IEvidenceSourceAddress>",
+                value: input.addresses
+            }, _errorFactory));
+            const _ao10 = (input, _path, _exceptionable = true) => _ap6(input, _path, true && _exceptionable) && ("string" === typeof input.siteId || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".siteId",
+                expected: "string",
+                value: input.siteId
+            }, _errorFactory));
+            const _ao11 = (input, _path, _exceptionable = true) => ("string" === typeof input.code || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".code",
+                expected: "string",
+                value: input.code
+            }, _errorFactory)) && ("error" === input.severity || "warning" === input.severity || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".severity",
+                expected: "(\"error\" | \"warning\")",
+                value: input.severity
+            }, _errorFactory)) && ("string" === typeof input.message || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".message",
+                expected: "string",
+                value: input.message
+            }, _errorFactory)) && ("string" === typeof input.repair || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".repair",
+                expected: "string",
+                value: input.repair
+            }, _errorFactory)) && (undefined === input.location || ("object" === typeof input.location && null !== input.location || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".location",
+                expected: "(IEvidenceSourceLocation | undefined)",
+                value: input.location
+            }, _errorFactory)) && _ao12(input.location, _path + ".location", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".location",
+                expected: "(IEvidenceSourceLocation | undefined)",
+                value: input.location
+            }, _errorFactory)) && (undefined === input.claim || "number" === typeof input.claim || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".claim",
+                expected: "(number | undefined)",
+                value: input.claim
+            }, _errorFactory)) && (undefined === input.reference || "number" === typeof input.reference || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".reference",
+                expected: "(number | undefined)",
+                value: input.reference
+            }, _errorFactory)) && (undefined === input.hostId || "string" === typeof input.hostId || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".hostId",
+                expected: "(string | undefined)",
+                value: input.hostId
+            }, _errorFactory)) && (undefined === input.target || "string" === typeof input.target || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".target",
+                expected: "(string | undefined)",
+                value: input.target
+            }, _errorFactory));
+            const _ao12 = (input, _path, _exceptionable = true) => _ap2(input, _path, true && _exceptionable) && (undefined === input.range || ("object" === typeof input.range && null !== input.range || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".range",
+                expected: "(IEvidenceSourceRange | undefined)",
+                value: input.range
+            }, _errorFactory)) && _ao5(input.range, _path + ".range", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".range",
+                expected: "(IEvidenceSourceRange | undefined)",
+                value: input.range
+            }, _errorFactory));
+            const _ao13 = (input, _path, _exceptionable = true) => _ap6(input, _path, true && _exceptionable) && _ap1(input, _path, true && _exceptionable) && ("boolean" === typeof input.comment || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".comment",
+                expected: "boolean",
+                value: input.comment
+            }, _errorFactory));
+            const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.absolute || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".absolute",
+                expected: "string",
+                value: input.absolute
+            }, _errorFactory)) && ("string" === typeof input.relative || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".relative",
+                expected: "string",
+                value: input.relative
+            }, _errorFactory)) && ("string" === typeof input.display || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".display",
+                expected: "string",
+                value: input.display
+            }, _errorFactory)) && (undefined === input.selected || "boolean" === typeof input.selected || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".selected",
+                expected: "(boolean | undefined)",
+                value: input.selected
+            }, _errorFactory));
+            const _ao3 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && ("string" === typeof input.name || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".name",
+                expected: "string",
+                value: input.name
+            }, _errorFactory)) && ("column" === input.symbol || "model" === input.symbol || "relation" === input.symbol || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".symbol",
+                expected: "(\"column\" | \"model\" | \"relation\")",
+                value: input.symbol
+            }, _errorFactory)) && _ap1(input, _path, true && _exceptionable) && ((Array.isArray(input.address) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".address",
+                expected: "Array<string>",
+                value: input.address
+            }, _errorFactory)) && input.address.every((elem, _index22) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".address[" + _index22 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".address",
+                expected: "Array<string>",
+                value: input.address
+            }, _errorFactory)) && (undefined === input.aliases || (Array.isArray(input.aliases) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".aliases",
+                expected: "(Array<Array<string>> | undefined)",
+                value: input.aliases
+            }, _errorFactory)) && input.aliases.every((elem, _index23) => (Array.isArray(elem) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".aliases[" + _index23 + "]",
+                expected: "Array<string>",
+                value: elem
+            }, _errorFactory)) && elem.every((elem, _index24) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".aliases[" + _index23 + "][" + _index24 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".aliases[" + _index23 + "]",
+                expected: "Array<string>",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".aliases",
+                expected: "(Array<Array<string>> | undefined)",
+                value: input.aliases
+            }, _errorFactory)) && (("object" === typeof input.site && null !== input.site || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".site",
+                expected: "IEvidenceUnitSite",
+                value: input.site
+            }, _errorFactory)) && _ao4(input.site, _path + ".site", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".site",
+                expected: "IEvidenceUnitSite",
+                value: input.site
+            }, _errorFactory)) && ("boolean" === typeof input["public"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + "[\"public\"]",
+                expected: "boolean",
+                value: input["public"]
+            }, _errorFactory)) && (undefined === input.ownerDeclarationId || "string" === typeof input.ownerDeclarationId || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".ownerDeclarationId",
+                expected: "(string | undefined)",
+                value: input.ownerDeclarationId
+            }, _errorFactory)) && (undefined === input.merge || "boolean" === typeof input.merge || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".merge",
+                expected: "(boolean | undefined)",
+                value: input.merge
+            }, _errorFactory));
+            const _ao4 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && ((Array.isArray(input.content) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".content",
+                expected: "Array<IEvidenceSourceRange>",
+                value: input.content
+            }, _errorFactory)) && input.content.every((elem, _index25) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".content[" + _index25 + "]",
+                expected: "IEvidenceSourceRange",
+                value: elem
+            }, _errorFactory)) && _ao5(elem, _path + ".content[" + _index25 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".content[" + _index25 + "]",
+                expected: "IEvidenceSourceRange",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".content",
+                expected: "Array<IEvidenceSourceRange>",
+                value: input.content
+            }, _errorFactory));
+            const _ao5 = (input, _path, _exceptionable = true) => (("object" === typeof input.start && null !== input.start || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".start",
+                expected: "IEvidenceSourcePosition",
+                value: input.start
+            }, _errorFactory)) && _ao6(input.start, _path + ".start", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".start",
+                expected: "IEvidenceSourcePosition",
+                value: input.start
+            }, _errorFactory)) && (("object" === typeof input.end && null !== input.end || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".end",
+                expected: "IEvidenceSourcePosition",
+                value: input.end
+            }, _errorFactory)) && _ao6(input.end, _path + ".end", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".end",
+                expected: "IEvidenceSourcePosition",
+                value: input.end
+            }, _errorFactory));
+            const _ao6 = (input, _path, _exceptionable = true) => ("number" === typeof input.offset || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".offset",
+                expected: "number",
+                value: input.offset
+            }, _errorFactory)) && ("number" === typeof input.line || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".line",
+                expected: "number",
+                value: input.line
+            }, _errorFactory)) && ("number" === typeof input.column || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".column",
+                expected: "number",
+                value: input.column
+            }, _errorFactory));
+            const _ao7 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && (undefined === input.syntax || ("object" === typeof input.syntax && null !== input.syntax || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".syntax",
+                expected: "(IEvidenceCommentSyntax | undefined)",
+                value: input.syntax
+            }, _errorFactory)) && _ao8(input.syntax, _path + ".syntax", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".syntax",
+                expected: "(IEvidenceCommentSyntax | undefined)",
+                value: input.syntax
+            }, _errorFactory)) && (undefined === input.mapped || ("object" === typeof input.mapped && null !== input.mapped || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".mapped",
+                expected: "(IEvidenceDocumentation | undefined)",
+                value: input.mapped
+            }, _errorFactory)) && _ao9(input.mapped, _path + ".mapped", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".mapped",
+                expected: "(IEvidenceDocumentation | undefined)",
+                value: input.mapped
+            }, _errorFactory)) && ((Array.isArray(input.attachments) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".attachments",
+                expected: "Array<ISqlDocumentationAttachment>",
+                value: input.attachments
+            }, _errorFactory)) && input.attachments.every((elem, _index26) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".attachments[" + _index26 + "]",
+                expected: "ISqlDocumentationAttachment",
+                value: elem
+            }, _errorFactory)) && _ao10(elem, _path + ".attachments[" + _index26 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".attachments[" + _index26 + "]",
+                expected: "ISqlDocumentationAttachment",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".attachments",
+                expected: "Array<ISqlDocumentationAttachment>",
+                value: input.attachments
+            }, _errorFactory));
+            const _ao8 = (input, _path, _exceptionable = true) => ("string" === typeof input.opening || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".opening",
+                expected: "string",
+                value: input.opening
+            }, _errorFactory)) && ("string" === typeof input.closing || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".closing",
+                expected: "string",
+                value: input.closing
+            }, _errorFactory)) && (undefined === input.linePrefix || "string" === typeof input.linePrefix || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".linePrefix",
+                expected: "(string | undefined)",
+                value: input.linePrefix
+            }, _errorFactory)) && _ap4(input, _path, true && _exceptionable) && _ap5(input, _path, true && _exceptionable);
+            const _ao9 = (input, _path, _exceptionable = true) => ("string" === typeof input.hostId || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".hostId",
+                expected: "string",
+                value: input.hostId
+            }, _errorFactory)) && ("string" === typeof input.text || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".text",
+                expected: "string",
+                value: input.text
+            }, _errorFactory)) && ((Array.isArray(input.offsets) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".offsets",
+                expected: "Array<number>",
+                value: input.offsets
+            }, _errorFactory)) && input.offsets.every((elem, _index27) => "number" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".offsets[" + _index27 + "]",
+                expected: "number",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".offsets",
+                expected: "Array<number>",
+                value: input.offsets
+            }, _errorFactory)) && ((Array.isArray(input.ends) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".ends",
+                expected: "Array<number>",
+                value: input.ends
+            }, _errorFactory)) && input.ends.every((elem, _index28) => "number" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".ends[" + _index28 + "]",
+                expected: "number",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".ends",
+                expected: "Array<number>",
+                value: input.ends
+            }, _errorFactory)) && _ap4(input, _path, true && _exceptionable) && _ap5(input, _path, true && _exceptionable);
+            const _io0 = input => "object" === typeof input.source && null !== input.source && _io1(input.source) && (Array.isArray(input.declarations) && input.declarations.every(elem => "object" === typeof elem && null !== elem && _io3(elem))) && (Array.isArray(input.documentation) && input.documentation.every(elem => "object" === typeof elem && null !== elem && _io7(elem))) && (Array.isArray(input.diagnostics) && input.diagnostics.every(elem => "object" === typeof elem && null !== elem && _io11(elem))) && "boolean" === typeof input.complete && (undefined === input.references || Array.isArray(input.references) && input.references.every(elem => "object" === typeof elem && null !== elem && _io13(elem)));
+            const _io1 = input => _ip0(input) && "string" === typeof input.physicalPath && "string" === typeof input.content && "string" === typeof input.digest && (Array.isArray(input.addresses) && input.addresses.every(elem => "object" === typeof elem && null !== elem && _io2(elem)));
+            const _io10 = input => _ip6(input) && "string" === typeof input.siteId;
+            const _io11 = input => "string" === typeof input.code && ("error" === input.severity || "warning" === input.severity) && "string" === typeof input.message && "string" === typeof input.repair && (undefined === input.location || "object" === typeof input.location && null !== input.location && _io12(input.location)) && (undefined === input.claim || "number" === typeof input.claim) && (undefined === input.reference || "number" === typeof input.reference) && (undefined === input.hostId || "string" === typeof input.hostId) && (undefined === input.target || "string" === typeof input.target);
+            const _io12 = input => _ip2(input) && (undefined === input.range || "object" === typeof input.range && null !== input.range && _io5(input.range));
+            const _io13 = input => _ip6(input) && _ip1(input) && "boolean" === typeof input.comment;
+            const _io2 = input => "string" === typeof input.absolute && "string" === typeof input.relative && "string" === typeof input.display && (undefined === input.selected || "boolean" === typeof input.selected);
+            const _io3 = input => _ip0(input) && "string" === typeof input.name && ("column" === input.symbol || "model" === input.symbol || "relation" === input.symbol) && _ip1(input) && (Array.isArray(input.address) && input.address.every(elem => "string" === typeof elem)) && (undefined === input.aliases || Array.isArray(input.aliases) && input.aliases.every(elem => Array.isArray(elem) && elem.every(elem => "string" === typeof elem))) && ("object" === typeof input.site && null !== input.site && _io4(input.site)) && "boolean" === typeof input["public"] && (undefined === input.ownerDeclarationId || "string" === typeof input.ownerDeclarationId) && (undefined === input.merge || "boolean" === typeof input.merge);
+            const _io4 = input => _ip0(input) && _ip2(input) && _ip3(input) && (Array.isArray(input.content) && input.content.every(elem => "object" === typeof elem && null !== elem && _io5(elem)));
+            const _io5 = input => "object" === typeof input.start && null !== input.start && _io6(input.start) && ("object" === typeof input.end && null !== input.end && _io6(input.end));
+            const _io6 = input => "number" === typeof input.offset && "number" === typeof input.line && "number" === typeof input.column;
+            const _io7 = input => _ip0(input) && _ip3(input) && (undefined === input.syntax || "object" === typeof input.syntax && null !== input.syntax && _io8(input.syntax)) && (undefined === input.mapped || "object" === typeof input.mapped && null !== input.mapped && _io9(input.mapped)) && (Array.isArray(input.attachments) && input.attachments.every(elem => "object" === typeof elem && null !== elem && _io10(elem)));
+            const _io8 = input => "string" === typeof input.opening && "string" === typeof input.closing && (undefined === input.linePrefix || "string" === typeof input.linePrefix) && _ip4(input) && _ip5(input);
+            const _io9 = input => "string" === typeof input.hostId && "string" === typeof input.text && (Array.isArray(input.offsets) && input.offsets.every(elem => "number" === typeof elem)) && (Array.isArray(input.ends) && input.ends.every(elem => "number" === typeof elem)) && _ip4(input) && _ip5(input);
+            const __is = input => Array.isArray(input) && input.every(elem => "object" === typeof elem && null !== elem && _io0(elem));
+            let _errorFactory;
+            return (input, errorFactory) => {
+                if (false === __is(input)) {
+                    _errorFactory = errorFactory;
+                    ((input, _path, _exceptionable = true) => (Array.isArray(input) || _assertGuard_1._assertGuard(true, {
+                        method: "typia.assert",
+                        path: _path + "",
+                        expected: "Array<IPostgresqlFileAnalysis>",
+                        value: input
+                    }, _errorFactory)) && input.every((elem, _index15) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(true, {
+                        method: "typia.assert",
+                        path: _path + "[" + _index15 + "]",
+                        expected: "IPostgresqlFileAnalysis",
+                        value: elem
+                    }, _errorFactory)) && _ao0(elem, _path + "[" + _index15 + "]", true) || _assertGuard_1._assertGuard(true, {
+                        method: "typia.assert",
+                        path: _path + "[" + _index15 + "]",
+                        expected: "IPostgresqlFileAnalysis",
+                        value: elem
+                    }, _errorFactory)) || _assertGuard_1._assertGuard(true, {
+                        method: "typia.assert",
+                        path: _path + "",
+                        expected: "Array<IPostgresqlFileAnalysis>",
+                        value: input
+                    }, _errorFactory))(input, "$input", true);
+                }
+                return input;
+            };
+        })()(input);
+        const declarations = analyses.flatMap((analysis) => analysis.declarations);
+        for (const analysis of analyses)
+            for (const reference of analysis.references ?? []) {
+                const declaration = analysis.declarations.find((candidate) => candidate.id === reference.declarationId);
+                if (declaration === undefined)
+                    continue;
+                const matches = declarations.filter((candidate) => candidate.merge !== true &&
+                    candidate.symbol === declaration.symbol &&
+                    JSON.stringify(candidate.identity) ===
+                        JSON.stringify(reference.identity));
+                const original = matches[0];
+                const comments = analyses
+                    .flatMap((candidate) => candidate.references ?? [])
+                    .filter((candidate) => candidate.comment &&
+                    JSON.stringify(candidate.identity) ===
+                        JSON.stringify(reference.identity));
+                if (matches.length !== 1 ||
+                    original === undefined ||
+                    (reference.comment && comments.length !== 1)) {
+                    analysis.complete = false;
+                    analysis.diagnostics.push({
+                        code: "postgresql-unresolved-owner",
+                        severity: "error",
+                        message: `PostgreSQL ${reference.comment ? "COMMENT" : "ALTER"} target '${reference.identity.join(".")}' needs exactly one selected declaration and at most one COMMENT assignment.`,
+                        repair: "Select the schema-qualified CREATE TABLE declaration and remove conflicting definitions.",
+                        location: {
+                            file: analysis.source.physicalPath,
+                            range: declaration.site.range,
+                        },
+                    });
+                    declaration.public = false;
+                    continue;
+                }
+                if (original.ownerDeclarationId !== undefined)
+                    declaration.ownerDeclarationId = original.ownerDeclarationId;
+            }
+        const unavailable = new Set(declarations
+            .filter((declaration) => !declaration.public)
+            .map((declaration) => declaration.id));
+        for (const declaration of declarations)
+            if (declaration.ownerDeclarationId !== undefined &&
+                unavailable.has(declaration.ownerDeclarationId))
+                declaration.public = false;
+    }
+    PostgresqlOwnership.resolve = resolve;
+})(PostgresqlOwnership || (exports.PostgresqlOwnership = PostgresqlOwnership = {}));