@shaclmate/compiler 4.0.32 → 4.0.34

package/dist/input/generated.js

@@ -15,6 +15,101 @@ function $compactRecord(record) {
         return definedProperties;
     }, {});
 }
+function $convertToBoolean(_schema, value) {
+    return Either.of(value);
+}
+function $convertToIdentifier(_schema, value) {
+    switch (typeof value) {
+        case "object":
+            return Either.of(value);
+        case "string":
+            return Either.of(dataFactory.namedNode(value));
+        case "undefined":
+            return Either.of(dataFactory.blankNode());
+    }
+}
+function $convertToIdentifierProperty(identifier) {
+    switch (typeof identifier) {
+        case "function":
+            return Either.of(identifier);
+        case "object": {
+            const captureIdentifier = identifier;
+            return Either.of(() => captureIdentifier);
+        }
+        case "string": {
+            const captureIdentifier = dataFactory.namedNode(identifier);
+            return Either.of(() => captureIdentifier);
+        }
+        case "undefined": {
+            const captureIdentifier = dataFactory.blankNode();
+            return Either.of(() => captureIdentifier);
+        }
+    }
+}
+function $convertToIri(_schema, value) {
+    switch (typeof value) {
+        case "object":
+            return Either.of(value);
+        case "string":
+            return Either.of(dataFactory.namedNode(value));
+    }
+}
+function $convertToLiteral(_schema, value) {
+    if (typeof value === "object") {
+        if (value instanceof Date) {
+            return Either.of($literalFactory.date(value));
+        }
+        return Either.of(value);
+    }
+    return Either.of($literalFactory.primitive(value));
+}
+function $convertToMaybe(convertToItem) {
+    return (schema, value) => {
+        switch (typeof value) {
+            case "object": {
+                if (Maybe.isMaybe(value)) {
+                    return Either.of(value);
+                }
+                break;
+            }
+            case "undefined":
+                return Either.of(Maybe.empty());
+        }
+        return convertToItem(schema.item(), value).map(Maybe.of);
+    };
+}
+function $convertToNumeric(_schema, value) {
+    return Either.of(value);
+}
+function $convertToObject(_schema, value) {
+    return Either.of(value);
+}
+function $convertToReadonlyArray(convertToItem) {
+    return (schema, value) => {
+        return (typeof value === "undefined"
+            ? Either.of([])
+            : Either.sequence(value.map((item) => convertToItem(schema.item(), item)))).chain((array) => {
+            if (schema.minCount !== undefined && array.length < schema.minCount) {
+                return Left(new Error(`array has length (${array.length}) less than minCount (${schema.minCount})`));
+            }
+            return Either.of(array);
+        });
+    };
+}
+function $convertToString(_schema, value) {
+    return Either.of(value);
+}
+function $convertToTerm(_schema, value) {
+    return Either.of(value);
+}
+function $convertWithDefaultValue(convertToItem) {
+    return (schema, value) => {
+        if (typeof value === "undefined") {
+            return convertToItem(schema.item(), schema.defaultValue);
+        }
+        return convertToItem(schema.item(), value);
+    };
+}
 export var $EqualsResult;
 (function ($EqualsResult) {
     $EqualsResult.Equal = Right(true);
@@ -186,21 +281,6 @@ class $IdentifierSet {
         }
     }
 }
-function $isReadonlyBigIntArray(x) {
-    return Array.isArray(x) && x.every((z) => typeof z === "bigint");
-}
-function $isReadonlyBooleanArray(x) {
-    return Array.isArray(x) && x.every((z) => typeof z === "boolean");
-}
-function $isReadonlyNumberArray(x) {
-    return Array.isArray(x) && x.every((z) => typeof z === "number");
-}
-function $isReadonlyObjectArray(x) {
-    return Array.isArray(x) && x.every((z) => typeof z === "object");
-}
-function $isReadonlyStringArray(x) {
-    return Array.isArray(x) && x.every((z) => typeof z === "string");
-}
 const $literalFactory = new LiteralFactory({ dataFactory: dataFactory });
 const $parseIdentifier = NTriplesIdentifier.parser(dataFactory);
 export var $PropertyPath;
@@ -313,804 +393,210 @@ function $wrap_ToRdfResourceFunction(_toRdfResourceFunction) {
 export var PropertyShape;
 (function (PropertyShape) {
     function create(parameters) {
-        const $identifierParameter = parameters.$identifier;
-        let $identifier;
-        if (typeof $identifierParameter === "function") {
-            $identifier = $identifierParameter;
-        }
-        else if (typeof $identifierParameter === "object") {
-            $identifier = () => $identifierParameter;
-        }
-        else if (typeof $identifierParameter === "string") {
-            $identifier = () => dataFactory.namedNode($identifierParameter);
-        }
-        else if ($identifierParameter === undefined) {
-            const $eagerIdentifier = dataFactory.blankNode();
-            $identifier = () => $eagerIdentifier;
-        }
-        else {
-            $identifier = $identifierParameter;
-        }
-        const $type = "PropertyShape";
-        let and;
-        if (Maybe.isMaybe(parameters.and)) {
-            and = parameters.and;
-        }
-        else if ($isReadonlyObjectArray(parameters.and)) {
-            and = Maybe.of(parameters.and);
-        }
-        else if ($isReadonlyStringArray(parameters.and)) {
-            and = Maybe.of(parameters.and.map((item) => dataFactory.namedNode(item)));
-        }
-        else if (parameters.and === undefined) {
-            and = Maybe.empty();
-        }
-        else {
-            and = parameters.and;
-        }
-        let classes;
-        if (parameters.classes === undefined) {
-            classes = [];
-        }
-        else if ($isReadonlyObjectArray(parameters.classes)) {
-            classes = parameters.classes;
-        }
-        else if ($isReadonlyStringArray(parameters.classes)) {
-            classes = parameters.classes.map((item) => dataFactory.namedNode(item));
-        }
-        else {
-            classes = parameters.classes;
-        }
-        let comment;
-        if (Maybe.isMaybe(parameters.comment)) {
-            comment = parameters.comment;
-        }
-        else if (typeof parameters.comment === "string") {
-            comment = Maybe.of(parameters.comment);
-        }
-        else if (parameters.comment === undefined) {
-            comment = Maybe.empty();
-        }
-        else {
-            comment = parameters.comment;
-        }
-        let datatype;
-        if (Maybe.isMaybe(parameters.datatype)) {
-            datatype = parameters.datatype;
-        }
-        else if (typeof parameters.datatype === "object") {
-            datatype = Maybe.of(parameters.datatype);
-        }
-        else if (typeof parameters.datatype === "string") {
-            datatype = Maybe.of(dataFactory.namedNode(parameters.datatype));
-        }
-        else if (parameters.datatype === undefined) {
-            datatype = Maybe.empty();
-        }
-        else {
-            datatype = parameters.datatype;
-        }
-        let deactivated;
-        if (Maybe.isMaybe(parameters.deactivated)) {
-            deactivated = parameters.deactivated;
-        }
-        else if (typeof parameters.deactivated === "boolean") {
-            deactivated = Maybe.of(parameters.deactivated);
-        }
-        else if (parameters.deactivated === undefined) {
-            deactivated = Maybe.empty();
-        }
-        else {
-            deactivated = parameters.deactivated;
-        }
-        let defaultValue;
-        if (Maybe.isMaybe(parameters.defaultValue)) {
-            defaultValue = parameters.defaultValue;
-        }
-        else if (typeof parameters.defaultValue === "bigint") {
-            defaultValue = Maybe.of($literalFactory.bigint(parameters.defaultValue));
-        }
-        else if (typeof parameters.defaultValue === "boolean") {
-            defaultValue = Maybe.of($literalFactory.boolean(parameters.defaultValue));
-        }
-        else if (typeof parameters.defaultValue === "object" &&
-            parameters.defaultValue instanceof Date) {
-            defaultValue = Maybe.of($literalFactory.date(parameters.defaultValue));
-        }
-        else if (typeof parameters.defaultValue === "number") {
-            defaultValue = Maybe.of($literalFactory.number(parameters.defaultValue));
-        }
-        else if (typeof parameters.defaultValue === "string") {
-            defaultValue = Maybe.of($literalFactory.string(parameters.defaultValue));
-        }
-        else if (typeof parameters.defaultValue === "object") {
-            defaultValue = Maybe.of(parameters.defaultValue);
-        }
-        else if (parameters.defaultValue === undefined) {
-            defaultValue = Maybe.empty();
-        }
-        else {
-            defaultValue = parameters.defaultValue;
-        }
-        let description;
-        if (Maybe.isMaybe(parameters.description)) {
-            description = parameters.description;
-        }
-        else if (typeof parameters.description === "string") {
-            description = Maybe.of(parameters.description);
-        }
-        else if (parameters.description === undefined) {
-            description = Maybe.empty();
-        }
-        else {
-            description = parameters.description;
-        }
-        let display;
-        if (typeof parameters.display === "boolean") {
-            display = parameters.display;
-        }
-        else if (parameters.display === undefined) {
-            display = false;
-        }
-        else {
-            display = parameters.display;
-        }
-        let flags;
-        if (parameters.flags === undefined) {
-            flags = [];
-        }
-        else if (typeof parameters.flags === "object") {
-            flags = parameters.flags;
-        }
-        else {
-            flags = parameters.flags;
-        }
-        let groups;
-        if (parameters.groups === undefined) {
-            groups = [];
-        }
-        else if ($isReadonlyObjectArray(parameters.groups)) {
-            groups = parameters.groups;
-        }
-        else if ($isReadonlyStringArray(parameters.groups)) {
-            groups = parameters.groups.map((item) => dataFactory.namedNode(item));
-        }
-        else {
-            groups = parameters.groups;
-        }
-        let hasValues;
-        if (parameters.hasValues === undefined) {
-            hasValues = [];
-        }
-        else if ($isReadonlyObjectArray(parameters.hasValues)) {
-            hasValues = parameters.hasValues;
-        }
-        else if ($isReadonlyBigIntArray(parameters.hasValues)) {
-            hasValues = parameters.hasValues.map((item) => $literalFactory.bigint(item));
-        }
-        else if ($isReadonlyBooleanArray(parameters.hasValues)) {
-            hasValues = parameters.hasValues.map((item) => $literalFactory.boolean(item));
-        }
-        else if ($isReadonlyNumberArray(parameters.hasValues)) {
-            hasValues = parameters.hasValues.map((item) => $literalFactory.number(item));
-        }
-        else if ($isReadonlyStringArray(parameters.hasValues)) {
-            hasValues = parameters.hasValues.map((item) => $literalFactory.string(item));
-        }
-        else {
-            hasValues = parameters.hasValues;
-        }
-        let in_;
-        if (Maybe.isMaybe(parameters.in_)) {
-            in_ = parameters.in_;
-        }
-        else if ($isReadonlyObjectArray(parameters.in_)) {
-            in_ = Maybe.of(parameters.in_);
-        }
-        else if ($isReadonlyBigIntArray(parameters.in_)) {
-            in_ = Maybe.of(parameters.in_.map((item) => $literalFactory.bigint(item)));
-        }
-        else if ($isReadonlyBooleanArray(parameters.in_)) {
-            in_ = Maybe.of(parameters.in_.map((item) => $literalFactory.boolean(item)));
-        }
-        else if ($isReadonlyNumberArray(parameters.in_)) {
-            in_ = Maybe.of(parameters.in_.map((item) => $literalFactory.number(item)));
-        }
-        else if ($isReadonlyStringArray(parameters.in_)) {
-            in_ = Maybe.of(parameters.in_.map((item) => $literalFactory.string(item)));
-        }
-        else if (parameters.in_ === undefined) {
-            in_ = Maybe.empty();
-        }
-        else {
-            in_ = parameters.in_;
-        }
-        let isDefinedBy;
-        if (Maybe.isMaybe(parameters.isDefinedBy)) {
-            isDefinedBy = parameters.isDefinedBy;
-        }
-        else if (typeof parameters.isDefinedBy === "object") {
-            isDefinedBy = Maybe.of(parameters.isDefinedBy);
-        }
-        else if (typeof parameters.isDefinedBy === "string") {
-            isDefinedBy = Maybe.of(dataFactory.namedNode(parameters.isDefinedBy));
-        }
-        else if (parameters.isDefinedBy === undefined) {
-            isDefinedBy = Maybe.empty();
-        }
-        else {
-            isDefinedBy = parameters.isDefinedBy;
-        }
-        let label;
-        if (Maybe.isMaybe(parameters.label)) {
-            label = parameters.label;
-        }
-        else if (typeof parameters.label === "string") {
-            label = Maybe.of(parameters.label);
-        }
-        else if (parameters.label === undefined) {
-            label = Maybe.empty();
-        }
-        else {
-            label = parameters.label;
-        }
-        let languageIn;
-        if (Maybe.isMaybe(parameters.languageIn)) {
-            languageIn = parameters.languageIn;
-        }
-        else if (typeof parameters.languageIn === "object") {
-            languageIn = Maybe.of(parameters.languageIn);
-        }
-        else if (parameters.languageIn === undefined) {
-            languageIn = Maybe.empty();
-        }
-        else {
-            languageIn = parameters.languageIn;
-        }
-        let maxCount;
-        if (Maybe.isMaybe(parameters.maxCount)) {
-            maxCount = parameters.maxCount;
-        }
-        else if (typeof parameters.maxCount === "bigint") {
-            maxCount = Maybe.of(parameters.maxCount);
-        }
-        else if (typeof parameters.maxCount === "number") {
-            maxCount = Maybe.of(BigInt(parameters.maxCount));
-        }
-        else if (parameters.maxCount === undefined) {
-            maxCount = Maybe.empty();
+        return $sequenceRecord({
+            $identifier: $convertToIdentifierProperty(parameters.$identifier),
+            and: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(PropertyShape.schema.properties.and.type(), parameters.and),
+            classes: $convertToReadonlyArray(($convertToIri))(PropertyShape.schema.properties.classes.type(), parameters.classes),
+            comment: $convertToMaybe(($convertToString))(PropertyShape.schema.properties.comment.type(), parameters.comment),
+            datatype: $convertToMaybe(($convertToIri))(PropertyShape.schema.properties.datatype.type(), parameters.datatype),
+            deactivated: $convertToMaybe(($convertToBoolean))(PropertyShape.schema.properties.deactivated.type(), parameters.deactivated),
+            defaultValue: $convertToMaybe(($convertToTerm))(PropertyShape.schema.properties.defaultValue.type(), parameters.defaultValue),
+            description: $convertToMaybe(($convertToString))(PropertyShape.schema.properties.description.type(), parameters.description),
+            display: $convertWithDefaultValue(($convertToBoolean))(PropertyShape.schema.properties.display.type(), parameters.display),
+            flags: $convertToReadonlyArray(($convertToString))(PropertyShape.schema.properties.flags.type(), parameters.flags),
+            groups: $convertToReadonlyArray($convertToIdentifier)(PropertyShape.schema.properties.groups.type(), parameters.groups),
+            hasValues: $convertToReadonlyArray(($convertToTerm))(PropertyShape.schema.properties.hasValues.type(), parameters.hasValues),
+            in_: $convertToMaybe($convertToReadonlyArray(($convertToTerm)))(PropertyShape.schema.properties.in_.type(), parameters.in_),
+            isDefinedBy: $convertToMaybe($convertToIdentifier)(PropertyShape.schema.properties.isDefinedBy.type(), parameters.isDefinedBy),
+            label: $convertToMaybe(($convertToString))(PropertyShape.schema.properties.label.type(), parameters.label),
+            languageIn: $convertToMaybe($convertToReadonlyArray(($convertToString)))(PropertyShape.schema.properties.languageIn.type(), parameters.languageIn),
+            maxCount: $convertToMaybe(($convertToNumeric))(PropertyShape.schema.properties.maxCount.type(), parameters.maxCount),
+            maxExclusive: $convertToMaybe($convertToLiteral)(PropertyShape.schema.properties.maxExclusive.type(), parameters.maxExclusive),
+            maxInclusive: $convertToMaybe($convertToLiteral)(PropertyShape.schema.properties.maxInclusive.type(), parameters.maxInclusive),
+            maxLength: $convertToMaybe(($convertToNumeric))(PropertyShape.schema.properties.maxLength.type(), parameters.maxLength),
+            minCount: $convertToMaybe(($convertToNumeric))(PropertyShape.schema.properties.minCount.type(), parameters.minCount),
+            minExclusive: $convertToMaybe($convertToLiteral)(PropertyShape.schema.properties.minExclusive.type(), parameters.minExclusive),
+            minInclusive: $convertToMaybe($convertToLiteral)(PropertyShape.schema.properties.minInclusive.type(), parameters.minInclusive),
+            minLength: $convertToMaybe(($convertToNumeric))(PropertyShape.schema.properties.minLength.type(), parameters.minLength),
+            mutable: $convertToMaybe(($convertToBoolean))(PropertyShape.schema.properties.mutable.type(), parameters.mutable),
+            name: $convertToMaybe(($convertToString))(PropertyShape.schema.properties.name.type(), parameters.name),
+            node: $convertToMaybe($convertToIdentifier)(PropertyShape.schema.properties.node.type(), parameters.node),
+            nodeKind: $convertToMaybe(($convertToIri))(PropertyShape.schema.properties.nodeKind.type(), parameters.nodeKind),
+            not: $convertToReadonlyArray($convertToIdentifier)(PropertyShape.schema.properties.not.type(), parameters.not),
+            or: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(PropertyShape.schema.properties.or.type(), parameters.or),
+            order: $convertToMaybe(($convertToNumeric))(PropertyShape.schema.properties.order.type(), parameters.order),
+            path: $convertToObject(PropertyShape.schema.properties.path.type(), parameters.path),
+            patterns: $convertToReadonlyArray(($convertToString))(PropertyShape.schema.properties.patterns.type(), parameters.patterns),
+            resolve: $convertToMaybe($convertToIdentifier)(PropertyShape.schema.properties.resolve.type(), parameters.resolve),
+            shaclmateName: $convertToMaybe(($convertToString))(PropertyShape.schema.properties.shaclmateName.type(), parameters.shaclmateName),
+            uniqueLang: $convertToMaybe(($convertToBoolean))(PropertyShape.schema.properties.uniqueLang.type(), parameters.uniqueLang),
+            xone: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(PropertyShape.schema.properties.xone.type(), parameters.xone),
+        }).map((properties) => {
+            const finalObject = { ...properties, $type: "PropertyShape" };
+            if (!globalThis.Object.prototype.hasOwnProperty.call(finalObject, "toString")) {
+                finalObject.toString = $toString;
+            }
+            return finalObject;
+        });
+    }
+    PropertyShape.create = create;
+    function createUnsafe(parameters) {
+        return create(parameters).unsafeCoerce();
+    }
+    PropertyShape.createUnsafe = createUnsafe;
+    let Identifier;
+    (function (Identifier) {
+        Identifier.parse = $parseIdentifier;
+        Identifier.stringify = NTriplesTerm.stringify;
+    })(Identifier = PropertyShape.Identifier || (PropertyShape.Identifier = {}));
+    function filter(filter, value) {
+        if (filter.$identifier !== undefined &&
+            !$filterIdentifier(filter.$identifier, value.$identifier())) {
+            return false;
         }
-        else {
-            maxCount = parameters.maxCount;
+        if (filter.and !== undefined &&
+            !$filterMaybe($filterArray($filterIdentifier))(filter.and, value.and)) {
+            return false;
         }
-        let maxExclusive;
-        if (Maybe.isMaybe(parameters.maxExclusive)) {
-            maxExclusive = parameters.maxExclusive;
+        if (filter.classes !== undefined &&
+            !$filterArray($filterIri)(filter.classes, value.classes)) {
+            return false;
         }
-        else if (typeof parameters.maxExclusive === "bigint") {
-            maxExclusive = Maybe.of($literalFactory.bigint(parameters.maxExclusive));
+        if (filter.comment !== undefined &&
+            !$filterMaybe($filterString)(filter.comment, value.comment)) {
+            return false;
         }
-        else if (typeof parameters.maxExclusive === "boolean") {
-            maxExclusive = Maybe.of($literalFactory.boolean(parameters.maxExclusive));
+        if (filter.datatype !== undefined &&
+            !$filterMaybe($filterIri)(filter.datatype, value.datatype)) {
+            return false;
         }
-        else if (typeof parameters.maxExclusive === "object" &&
-            parameters.maxExclusive instanceof Date) {
-            maxExclusive = Maybe.of($literalFactory.date(parameters.maxExclusive));
+        if (filter.deactivated !== undefined &&
+            !$filterMaybe($filterBoolean)(filter.deactivated, value.deactivated)) {
+            return false;
         }
-        else if (typeof parameters.maxExclusive === "number") {
-            maxExclusive = Maybe.of($literalFactory.number(parameters.maxExclusive));
+        if (filter.defaultValue !== undefined &&
+            !$filterMaybe($filterTerm)(filter.defaultValue, value.defaultValue)) {
+            return false;
         }
-        else if (typeof parameters.maxExclusive === "string") {
-            maxExclusive = Maybe.of($literalFactory.string(parameters.maxExclusive));
+        if (filter.description !== undefined &&
+            !$filterMaybe($filterString)(filter.description, value.description)) {
+            return false;
         }
-        else if (typeof parameters.maxExclusive === "object") {
-            maxExclusive = Maybe.of(parameters.maxExclusive);
+        if (filter.display !== undefined &&
+            !$filterBoolean(filter.display, value.display)) {
+            return false;
         }
-        else if (parameters.maxExclusive === undefined) {
-            maxExclusive = Maybe.empty();
+        if (filter.flags !== undefined &&
+            !$filterArray($filterString)(filter.flags, value.flags)) {
+            return false;
         }
-        else {
-            maxExclusive = parameters.maxExclusive;
+        if (filter.groups !== undefined &&
+            !$filterArray($filterIdentifier)(filter.groups, value.groups)) {
+            return false;
         }
-        let maxInclusive;
-        if (Maybe.isMaybe(parameters.maxInclusive)) {
-            maxInclusive = parameters.maxInclusive;
+        if (filter.hasValues !== undefined &&
+            !$filterArray($filterTerm)(filter.hasValues, value.hasValues)) {
+            return false;
         }
-        else if (typeof parameters.maxInclusive === "bigint") {
-            maxInclusive = Maybe.of($literalFactory.bigint(parameters.maxInclusive));
+        if (filter.in_ !== undefined &&
+            !$filterMaybe($filterArray($filterTerm))(filter.in_, value.in_)) {
+            return false;
         }
-        else if (typeof parameters.maxInclusive === "boolean") {
-            maxInclusive = Maybe.of($literalFactory.boolean(parameters.maxInclusive));
+        if (filter.isDefinedBy !== undefined &&
+            !$filterMaybe($filterIdentifier)(filter.isDefinedBy, value.isDefinedBy)) {
+            return false;
         }
-        else if (typeof parameters.maxInclusive === "object" &&
-            parameters.maxInclusive instanceof Date) {
-            maxInclusive = Maybe.of($literalFactory.date(parameters.maxInclusive));
+        if (filter.label !== undefined &&
+            !$filterMaybe($filterString)(filter.label, value.label)) {
+            return false;
         }
-        else if (typeof parameters.maxInclusive === "number") {
-            maxInclusive = Maybe.of($literalFactory.number(parameters.maxInclusive));
+        if (filter.languageIn !== undefined &&
+            !$filterMaybe($filterArray($filterString))(filter.languageIn, value.languageIn)) {
+            return false;
         }
-        else if (typeof parameters.maxInclusive === "string") {
-            maxInclusive = Maybe.of($literalFactory.string(parameters.maxInclusive));
+        if (filter.maxCount !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.maxCount, value.maxCount)) {
+            return false;
         }
-        else if (typeof parameters.maxInclusive === "object") {
-            maxInclusive = Maybe.of(parameters.maxInclusive);
+        if (filter.maxExclusive !== undefined &&
+            !$filterMaybe($filterLiteral)(filter.maxExclusive, value.maxExclusive)) {
+            return false;
         }
-        else if (parameters.maxInclusive === undefined) {
-            maxInclusive = Maybe.empty();
+        if (filter.maxInclusive !== undefined &&
+            !$filterMaybe($filterLiteral)(filter.maxInclusive, value.maxInclusive)) {
+            return false;
         }
-        else {
-            maxInclusive = parameters.maxInclusive;
+        if (filter.maxLength !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.maxLength, value.maxLength)) {
+            return false;
         }
-        let maxLength;
-        if (Maybe.isMaybe(parameters.maxLength)) {
-            maxLength = parameters.maxLength;
+        if (filter.minCount !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.minCount, value.minCount)) {
+            return false;
         }
-        else if (typeof parameters.maxLength === "bigint") {
-            maxLength = Maybe.of(parameters.maxLength);
+        if (filter.minExclusive !== undefined &&
+            !$filterMaybe($filterLiteral)(filter.minExclusive, value.minExclusive)) {
+            return false;
         }
-        else if (typeof parameters.maxLength === "number") {
-            maxLength = Maybe.of(BigInt(parameters.maxLength));
+        if (filter.minInclusive !== undefined &&
+            !$filterMaybe($filterLiteral)(filter.minInclusive, value.minInclusive)) {
+            return false;
         }
-        else if (parameters.maxLength === undefined) {
-            maxLength = Maybe.empty();
+        if (filter.minLength !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.minLength, value.minLength)) {
+            return false;
         }
-        else {
-            maxLength = parameters.maxLength;
+        if (filter.mutable !== undefined &&
+            !$filterMaybe($filterBoolean)(filter.mutable, value.mutable)) {
+            return false;
         }
-        let minCount;
-        if (Maybe.isMaybe(parameters.minCount)) {
-            minCount = parameters.minCount;
+        if (filter.name !== undefined &&
+            !$filterMaybe($filterString)(filter.name, value.name)) {
+            return false;
         }
-        else if (typeof parameters.minCount === "bigint") {
-            minCount = Maybe.of(parameters.minCount);
+        if (filter.node !== undefined &&
+            !$filterMaybe($filterIdentifier)(filter.node, value.node)) {
+            return false;
         }
-        else if (typeof parameters.minCount === "number") {
-            minCount = Maybe.of(BigInt(parameters.minCount));
+        if (filter.nodeKind !== undefined &&
+            !$filterMaybe($filterIri)(filter.nodeKind, value.nodeKind)) {
+            return false;
         }
-        else if (parameters.minCount === undefined) {
-            minCount = Maybe.empty();
+        if (filter.not !== undefined &&
+            !$filterArray($filterIdentifier)(filter.not, value.not)) {
+            return false;
         }
-        else {
-            minCount = parameters.minCount;
+        if (filter.or !== undefined &&
+            !$filterMaybe($filterArray($filterIdentifier))(filter.or, value.or)) {
+            return false;
         }
-        let minExclusive;
-        if (Maybe.isMaybe(parameters.minExclusive)) {
-            minExclusive = parameters.minExclusive;
+        if (filter.order !== undefined &&
+            !$filterMaybe(($filterNumeric))(filter.order, value.order)) {
+            return false;
         }
-        else if (typeof parameters.minExclusive === "bigint") {
-            minExclusive = Maybe.of($literalFactory.bigint(parameters.minExclusive));
+        if (filter.path !== undefined &&
+            !$PropertyPath.filter(filter.path, value.path)) {
+            return false;
         }
-        else if (typeof parameters.minExclusive === "boolean") {
-            minExclusive = Maybe.of($literalFactory.boolean(parameters.minExclusive));
+        if (filter.patterns !== undefined &&
+            !$filterArray($filterString)(filter.patterns, value.patterns)) {
+            return false;
         }
-        else if (typeof parameters.minExclusive === "object" &&
-            parameters.minExclusive instanceof Date) {
-            minExclusive = Maybe.of($literalFactory.date(parameters.minExclusive));
+        if (filter.resolve !== undefined &&
+            !$filterMaybe($filterIdentifier)(filter.resolve, value.resolve)) {
+            return false;
         }
-        else if (typeof parameters.minExclusive === "number") {
-            minExclusive = Maybe.of($literalFactory.number(parameters.minExclusive));
+        if (filter.shaclmateName !== undefined &&
+            !$filterMaybe($filterString)(filter.shaclmateName, value.shaclmateName)) {
+            return false;
         }
-        else if (typeof parameters.minExclusive === "string") {
-            minExclusive = Maybe.of($literalFactory.string(parameters.minExclusive));
+        if (filter.uniqueLang !== undefined &&
+            !$filterMaybe($filterBoolean)(filter.uniqueLang, value.uniqueLang)) {
+            return false;
         }
-        else if (typeof parameters.minExclusive === "object") {
-            minExclusive = Maybe.of(parameters.minExclusive);
-        }
-        else if (parameters.minExclusive === undefined) {
-            minExclusive = Maybe.empty();
-        }
-        else {
-            minExclusive = parameters.minExclusive;
-        }
-        let minInclusive;
-        if (Maybe.isMaybe(parameters.minInclusive)) {
-            minInclusive = parameters.minInclusive;
-        }
-        else if (typeof parameters.minInclusive === "bigint") {
-            minInclusive = Maybe.of($literalFactory.bigint(parameters.minInclusive));
-        }
-        else if (typeof parameters.minInclusive === "boolean") {
-            minInclusive = Maybe.of($literalFactory.boolean(parameters.minInclusive));
-        }
-        else if (typeof parameters.minInclusive === "object" &&
-            parameters.minInclusive instanceof Date) {
-            minInclusive = Maybe.of($literalFactory.date(parameters.minInclusive));
-        }
-        else if (typeof parameters.minInclusive === "number") {
-            minInclusive = Maybe.of($literalFactory.number(parameters.minInclusive));
-        }
-        else if (typeof parameters.minInclusive === "string") {
-            minInclusive = Maybe.of($literalFactory.string(parameters.minInclusive));
-        }
-        else if (typeof parameters.minInclusive === "object") {
-            minInclusive = Maybe.of(parameters.minInclusive);
-        }
-        else if (parameters.minInclusive === undefined) {
-            minInclusive = Maybe.empty();
-        }
-        else {
-            minInclusive = parameters.minInclusive;
-        }
-        let minLength;
-        if (Maybe.isMaybe(parameters.minLength)) {
-            minLength = parameters.minLength;
-        }
-        else if (typeof parameters.minLength === "bigint") {
-            minLength = Maybe.of(parameters.minLength);
-        }
-        else if (typeof parameters.minLength === "number") {
-            minLength = Maybe.of(BigInt(parameters.minLength));
-        }
-        else if (parameters.minLength === undefined) {
-            minLength = Maybe.empty();
-        }
-        else {
-            minLength = parameters.minLength;
-        }
-        let mutable;
-        if (Maybe.isMaybe(parameters.mutable)) {
-            mutable = parameters.mutable;
-        }
-        else if (typeof parameters.mutable === "boolean") {
-            mutable = Maybe.of(parameters.mutable);
-        }
-        else if (parameters.mutable === undefined) {
-            mutable = Maybe.empty();
-        }
-        else {
-            mutable = parameters.mutable;
-        }
-        let name;
-        if (Maybe.isMaybe(parameters.name)) {
-            name = parameters.name;
-        }
-        else if (typeof parameters.name === "string") {
-            name = Maybe.of(parameters.name);
-        }
-        else if (parameters.name === undefined) {
-            name = Maybe.empty();
-        }
-        else {
-            name = parameters.name;
-        }
-        let node;
-        if (Maybe.isMaybe(parameters.node)) {
-            node = parameters.node;
-        }
-        else if (typeof parameters.node === "object") {
-            node = Maybe.of(parameters.node);
-        }
-        else if (typeof parameters.node === "string") {
-            node = Maybe.of(dataFactory.namedNode(parameters.node));
-        }
-        else if (parameters.node === undefined) {
-            node = Maybe.empty();
-        }
-        else {
-            node = parameters.node;
-        }
-        let nodeKind;
-        if (Maybe.isMaybe(parameters.nodeKind)) {
-            nodeKind = parameters.nodeKind;
-        }
-        else if (typeof parameters.nodeKind === "object") {
-            nodeKind = Maybe.of(parameters.nodeKind);
-        }
-        else if (typeof parameters.nodeKind === "string") {
-            nodeKind = Maybe.of(dataFactory.namedNode(parameters.nodeKind));
-        }
-        else if (parameters.nodeKind === undefined) {
-            nodeKind = Maybe.empty();
-        }
-        else {
-            nodeKind = parameters.nodeKind;
-        }
-        let not;
-        if (parameters.not === undefined) {
-            not = [];
-        }
-        else if ($isReadonlyObjectArray(parameters.not)) {
-            not = parameters.not;
-        }
-        else if ($isReadonlyStringArray(parameters.not)) {
-            not = parameters.not.map((item) => dataFactory.namedNode(item));
-        }
-        else {
-            not = parameters.not;
-        }
-        let or;
-        if (Maybe.isMaybe(parameters.or)) {
-            or = parameters.or;
-        }
-        else if ($isReadonlyObjectArray(parameters.or)) {
-            or = Maybe.of(parameters.or);
-        }
-        else if ($isReadonlyStringArray(parameters.or)) {
-            or = Maybe.of(parameters.or.map((item) => dataFactory.namedNode(item)));
-        }
-        else if (parameters.or === undefined) {
-            or = Maybe.empty();
-        }
-        else {
-            or = parameters.or;
-        }
-        let order;
-        if (Maybe.isMaybe(parameters.order)) {
-            order = parameters.order;
-        }
-        else if (typeof parameters.order === "number") {
-            order = Maybe.of(parameters.order);
-        }
-        else if (parameters.order === undefined) {
-            order = Maybe.empty();
-        }
-        else {
-            order = parameters.order;
-        }
-        const path = parameters.path;
-        let patterns;
-        if (parameters.patterns === undefined) {
-            patterns = [];
-        }
-        else if (typeof parameters.patterns === "object") {
-            patterns = parameters.patterns;
-        }
-        else {
-            patterns = parameters.patterns;
-        }
-        let resolve;
-        if (Maybe.isMaybe(parameters.resolve)) {
-            resolve = parameters.resolve;
-        }
-        else if (typeof parameters.resolve === "object") {
-            resolve = Maybe.of(parameters.resolve);
-        }
-        else if (typeof parameters.resolve === "string") {
-            resolve = Maybe.of(dataFactory.namedNode(parameters.resolve));
-        }
-        else if (parameters.resolve === undefined) {
-            resolve = Maybe.empty();
-        }
-        else {
-            resolve = parameters.resolve;
-        }
-        let shaclmateName;
-        if (Maybe.isMaybe(parameters.shaclmateName)) {
-            shaclmateName = parameters.shaclmateName;
-        }
-        else if (typeof parameters.shaclmateName === "string") {
-            shaclmateName = Maybe.of(parameters.shaclmateName);
-        }
-        else if (parameters.shaclmateName === undefined) {
-            shaclmateName = Maybe.empty();
-        }
-        else {
-            shaclmateName = parameters.shaclmateName;
-        }
-        let uniqueLang;
-        if (Maybe.isMaybe(parameters.uniqueLang)) {
-            uniqueLang = parameters.uniqueLang;
-        }
-        else if (typeof parameters.uniqueLang === "boolean") {
-            uniqueLang = Maybe.of(parameters.uniqueLang);
-        }
-        else if (parameters.uniqueLang === undefined) {
-            uniqueLang = Maybe.empty();
-        }
-        else {
-            uniqueLang = parameters.uniqueLang;
-        }
-        let xone;
-        if (Maybe.isMaybe(parameters.xone)) {
-            xone = parameters.xone;
-        }
-        else if ($isReadonlyObjectArray(parameters.xone)) {
-            xone = Maybe.of(parameters.xone);
-        }
-        else if ($isReadonlyStringArray(parameters.xone)) {
-            xone = Maybe.of(parameters.xone.map((item) => dataFactory.namedNode(item)));
-        }
-        else if (parameters.xone === undefined) {
-            xone = Maybe.empty();
-        }
-        else {
-            xone = parameters.xone;
-        }
-        return {
-            $identifier,
-            $type,
-            and,
-            classes,
-            comment,
-            datatype,
-            deactivated,
-            defaultValue,
-            description,
-            display,
-            flags,
-            groups,
-            hasValues,
-            in_,
-            isDefinedBy,
-            label,
-            languageIn,
-            maxCount,
-            maxExclusive,
-            maxInclusive,
-            maxLength,
-            minCount,
-            minExclusive,
-            minInclusive,
-            minLength,
-            mutable,
-            name,
-            node,
-            nodeKind,
-            not,
-            or,
-            order,
-            path,
-            patterns,
-            resolve,
-            shaclmateName,
-            uniqueLang,
-            xone,
-        };
-    }
-    PropertyShape.create = create;
-    let Identifier;
-    (function (Identifier) {
-        Identifier.parse = $parseIdentifier;
-        Identifier.stringify = NTriplesTerm.stringify;
-    })(Identifier = PropertyShape.Identifier || (PropertyShape.Identifier = {}));
-    function filter(filter, value) {
-        if (filter.$identifier !== undefined &&
-            !$filterIdentifier(filter.$identifier, value.$identifier())) {
-            return false;
-        }
-        if (filter.and !== undefined &&
-            !$filterMaybe($filterArray($filterIdentifier))(filter.and, value.and)) {
-            return false;
-        }
-        if (filter.classes !== undefined &&
-            !$filterArray($filterIri)(filter.classes, value.classes)) {
-            return false;
-        }
-        if (filter.comment !== undefined &&
-            !$filterMaybe($filterString)(filter.comment, value.comment)) {
-            return false;
-        }
-        if (filter.datatype !== undefined &&
-            !$filterMaybe($filterIri)(filter.datatype, value.datatype)) {
-            return false;
-        }
-        if (filter.deactivated !== undefined &&
-            !$filterMaybe($filterBoolean)(filter.deactivated, value.deactivated)) {
-            return false;
-        }
-        if (filter.defaultValue !== undefined &&
-            !$filterMaybe($filterTerm)(filter.defaultValue, value.defaultValue)) {
-            return false;
-        }
-        if (filter.description !== undefined &&
-            !$filterMaybe($filterString)(filter.description, value.description)) {
-            return false;
-        }
-        if (filter.display !== undefined &&
-            !$filterBoolean(filter.display, value.display)) {
-            return false;
-        }
-        if (filter.flags !== undefined &&
-            !$filterArray($filterString)(filter.flags, value.flags)) {
-            return false;
-        }
-        if (filter.groups !== undefined &&
-            !$filterArray($filterIdentifier)(filter.groups, value.groups)) {
-            return false;
-        }
-        if (filter.hasValues !== undefined &&
-            !$filterArray($filterTerm)(filter.hasValues, value.hasValues)) {
-            return false;
-        }
-        if (filter.in_ !== undefined &&
-            !$filterMaybe($filterArray($filterTerm))(filter.in_, value.in_)) {
-            return false;
-        }
-        if (filter.isDefinedBy !== undefined &&
-            !$filterMaybe($filterIdentifier)(filter.isDefinedBy, value.isDefinedBy)) {
-            return false;
-        }
-        if (filter.label !== undefined &&
-            !$filterMaybe($filterString)(filter.label, value.label)) {
-            return false;
-        }
-        if (filter.languageIn !== undefined &&
-            !$filterMaybe($filterArray($filterString))(filter.languageIn, value.languageIn)) {
-            return false;
-        }
-        if (filter.maxCount !== undefined &&
-            !$filterMaybe(($filterNumeric))(filter.maxCount, value.maxCount)) {
-            return false;
-        }
-        if (filter.maxExclusive !== undefined &&
-            !$filterMaybe($filterLiteral)(filter.maxExclusive, value.maxExclusive)) {
-            return false;
-        }
-        if (filter.maxInclusive !== undefined &&
-            !$filterMaybe($filterLiteral)(filter.maxInclusive, value.maxInclusive)) {
-            return false;
-        }
-        if (filter.maxLength !== undefined &&
-            !$filterMaybe(($filterNumeric))(filter.maxLength, value.maxLength)) {
-            return false;
-        }
-        if (filter.minCount !== undefined &&
-            !$filterMaybe(($filterNumeric))(filter.minCount, value.minCount)) {
-            return false;
-        }
-        if (filter.minExclusive !== undefined &&
-            !$filterMaybe($filterLiteral)(filter.minExclusive, value.minExclusive)) {
-            return false;
-        }
-        if (filter.minInclusive !== undefined &&
-            !$filterMaybe($filterLiteral)(filter.minInclusive, value.minInclusive)) {
-            return false;
-        }
-        if (filter.minLength !== undefined &&
-            !$filterMaybe(($filterNumeric))(filter.minLength, value.minLength)) {
-            return false;
-        }
-        if (filter.mutable !== undefined &&
-            !$filterMaybe($filterBoolean)(filter.mutable, value.mutable)) {
-            return false;
-        }
-        if (filter.name !== undefined &&
-            !$filterMaybe($filterString)(filter.name, value.name)) {
-            return false;
-        }
-        if (filter.node !== undefined &&
-            !$filterMaybe($filterIdentifier)(filter.node, value.node)) {
-            return false;
-        }
-        if (filter.nodeKind !== undefined &&
-            !$filterMaybe($filterIri)(filter.nodeKind, value.nodeKind)) {
-            return false;
-        }
-        if (filter.not !== undefined &&
-            !$filterArray($filterIdentifier)(filter.not, value.not)) {
-            return false;
-        }
-        if (filter.or !== undefined &&
-            !$filterMaybe($filterArray($filterIdentifier))(filter.or, value.or)) {
-            return false;
-        }
-        if (filter.order !== undefined &&
-            !$filterMaybe(($filterNumeric))(filter.order, value.order)) {
-            return false;
-        }
-        if (filter.path !== undefined &&
-            !$PropertyPath.filter(filter.path, value.path)) {
-            return false;
-        }
-        if (filter.patterns !== undefined &&
-            !$filterArray($filterString)(filter.patterns, value.patterns)) {
-            return false;
-        }
-        if (filter.resolve !== undefined &&
-            !$filterMaybe($filterIdentifier)(filter.resolve, value.resolve)) {
-            return false;
-        }
-        if (filter.shaclmateName !== undefined &&
-            !$filterMaybe($filterString)(filter.shaclmateName, value.shaclmateName)) {
-            return false;
-        }
-        if (filter.uniqueLang !== undefined &&
-            !$filterMaybe($filterBoolean)(filter.uniqueLang, value.uniqueLang)) {
-            return false;
-        }
-        if (filter.xone !== undefined &&
-            !$filterMaybe($filterArray($filterIdentifier))(filter.xone, value.xone)) {
-            return false;
+        if (filter.xone !== undefined &&
+            !$filterMaybe($filterArray($filterIdentifier))(filter.xone, value.xone)) {
+            return false;
         }
         return true;
     }
@@ -1731,7 +1217,7 @@ export var PropertyShape;
                         value: Maybe.empty(),
                     })),
             }),
-        }).map((properties) => create(properties)));
+        }).chain((properties) => create(properties)));
     };
     PropertyShape.fromRdfResource = $wrap_FromRdfResourceFunction(PropertyShape._fromRdfResource);
     PropertyShape.fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
@@ -1824,7 +1310,7 @@ export var PropertyShape;
                 type: () => ({
                     kind: "DefaultValue",
                     item: () => ({ kind: "Boolean" }),
-                    defaultValue: dataFactory.literal("false", $RdfVocabularies.xsd.boolean),
+                    defaultValue: false,
                 }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#display"),
             },
@@ -2294,67 +1780,36 @@ export var PropertyShape;
 export var PropertyGroup;
 (function (PropertyGroup) {
     function create(parameters) {
-        const $identifierParameter = parameters?.$identifier;
-        let $identifier;
-        if (typeof $identifierParameter === "function") {
-            $identifier = $identifierParameter;
+        return $sequenceRecord({
+            $identifier: $convertToIdentifierProperty(parameters?.$identifier),
+            comment: $convertToMaybe(($convertToString))(PropertyGroup.schema.properties.comment.type(), parameters?.comment),
+            label: $convertToMaybe(($convertToString))(PropertyGroup.schema.properties.label.type(), parameters?.label),
+        }).map((properties) => {
+            const finalObject = { ...properties, $type: "PropertyGroup" };
+            if (!globalThis.Object.prototype.hasOwnProperty.call(finalObject, "toString")) {
+                finalObject.toString = $toString;
+            }
+            return finalObject;
+        });
+    }
+    PropertyGroup.create = create;
+    function createUnsafe(parameters) {
+        return create(parameters).unsafeCoerce();
+    }
+    PropertyGroup.createUnsafe = createUnsafe;
+    let Identifier;
+    (function (Identifier) {
+        Identifier.parse = $parseIdentifier;
+        Identifier.stringify = NTriplesTerm.stringify;
+    })(Identifier = PropertyGroup.Identifier || (PropertyGroup.Identifier = {}));
+    function filter(filter, value) {
+        if (filter.$identifier !== undefined &&
+            !$filterIdentifier(filter.$identifier, value.$identifier())) {
+            return false;
         }
-        else if (typeof $identifierParameter === "object") {
-            $identifier = () => $identifierParameter;
-        }
-        else if (typeof $identifierParameter === "string") {
-            $identifier = () => dataFactory.namedNode($identifierParameter);
-        }
-        else if ($identifierParameter === undefined) {
-            const $eagerIdentifier = dataFactory.blankNode();
-            $identifier = () => $eagerIdentifier;
-        }
-        else {
-            $identifier = $identifierParameter;
-        }
-        const $type = "PropertyGroup";
-        let comment;
-        if (Maybe.isMaybe(parameters?.comment)) {
-            comment = parameters?.comment;
-        }
-        else if (typeof parameters?.comment === "string") {
-            comment = Maybe.of(parameters?.comment);
-        }
-        else if (parameters?.comment === undefined) {
-            comment = Maybe.empty();
-        }
-        else {
-            comment = parameters?.comment;
-        }
-        let label;
-        if (Maybe.isMaybe(parameters?.label)) {
-            label = parameters?.label;
-        }
-        else if (typeof parameters?.label === "string") {
-            label = Maybe.of(parameters?.label);
-        }
-        else if (parameters?.label === undefined) {
-            label = Maybe.empty();
-        }
-        else {
-            label = parameters?.label;
-        }
-        return { $identifier, $type, comment, label };
-    }
-    PropertyGroup.create = create;
-    let Identifier;
-    (function (Identifier) {
-        Identifier.parse = $parseIdentifier;
-        Identifier.stringify = NTriplesTerm.stringify;
-    })(Identifier = PropertyGroup.Identifier || (PropertyGroup.Identifier = {}));
-    function filter(filter, value) {
-        if (filter.$identifier !== undefined &&
-            !$filterIdentifier(filter.$identifier, value.$identifier())) {
-            return false;
-        }
-        if (filter.comment !== undefined &&
-            !$filterMaybe($filterString)(filter.comment, value.comment)) {
-            return false;
+        if (filter.comment !== undefined &&
+            !$filterMaybe($filterString)(filter.comment, value.comment)) {
+            return false;
         }
         if (filter.label !== undefined &&
             !$filterMaybe($filterString)(filter.label, value.label)) {
@@ -2421,7 +1876,7 @@ export var PropertyGroup;
                         value: Maybe.empty(),
                     })),
             }),
-        }).map((properties) => create(properties)));
+        }).chain((properties) => create(properties)));
     };
     PropertyGroup.fromRdfResource = $wrap_FromRdfResourceFunction(PropertyGroup._fromRdfResource);
     PropertyGroup.fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
@@ -2444,1138 +1899,282 @@ export var PropertyGroup;
                 type: () => ({ kind: "Identifier" }),
             },
             $type: {
-                kind: "Discriminant",
-                type: () => ({
-                    kind: "TypeDiscriminant",
-                    ownValues: ["PropertyGroup"],
-                }),
-            },
-            comment: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
-            },
-            label: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
-            },
-        },
-    };
-    PropertyGroup._toRdfResource = (parameters) => {
-        if (!parameters.ignoreRdfType) {
-            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"), parameters.graph);
-        }
-        parameters.resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), parameters.object.comment
-            .toList()
-            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), parameters.object.label
-            .toList()
-            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        return parameters.resource;
-    };
-    PropertyGroup.toRdfResource = $wrap_ToRdfResourceFunction(PropertyGroup._toRdfResource);
-    function _propertiesToStrings(_propertyGroup) {
-        return $compactRecord({
-            $identifier: _propertyGroup.$identifier().toString(),
-            label: _propertyGroup.label.map((item) => item.toString()).extract(),
-        });
-    }
-    PropertyGroup._propertiesToStrings = _propertiesToStrings;
-    function $toString(_propertyGroup) {
-        return `PropertyGroup(${JSON.stringify(_propertiesToStrings((_propertyGroup ?? this)))})`;
-    }
-    PropertyGroup.$toString = $toString;
-})(PropertyGroup || (PropertyGroup = {}));
-export var Ontology;
-(function (Ontology) {
-    function create(parameters) {
-        const $identifierParameter = parameters?.$identifier;
-        let $identifier;
-        if (typeof $identifierParameter === "function") {
-            $identifier = $identifierParameter;
-        }
-        else if (typeof $identifierParameter === "object") {
-            $identifier = () => $identifierParameter;
-        }
-        else if (typeof $identifierParameter === "string") {
-            $identifier = () => dataFactory.namedNode($identifierParameter);
-        }
-        else if ($identifierParameter === undefined) {
-            const $eagerIdentifier = dataFactory.blankNode();
-            $identifier = () => $eagerIdentifier;
-        }
-        else {
-            $identifier = $identifierParameter;
-        }
-        const $type = "Ontology";
-        let comment;
-        if (Maybe.isMaybe(parameters?.comment)) {
-            comment = parameters?.comment;
-        }
-        else if (typeof parameters?.comment === "string") {
-            comment = Maybe.of(parameters?.comment);
-        }
-        else if (parameters?.comment === undefined) {
-            comment = Maybe.empty();
-        }
-        else {
-            comment = parameters?.comment;
-        }
-        let label;
-        if (Maybe.isMaybe(parameters?.label)) {
-            label = parameters?.label;
-        }
-        else if (typeof parameters?.label === "string") {
-            label = Maybe.of(parameters?.label);
-        }
-        else if (parameters?.label === undefined) {
-            label = Maybe.empty();
-        }
-        else {
-            label = parameters?.label;
-        }
-        let tsFeatureExcludes;
-        if (parameters?.tsFeatureExcludes === undefined) {
-            tsFeatureExcludes = [];
-        }
-        else if ($isReadonlyObjectArray(parameters?.tsFeatureExcludes)) {
-            tsFeatureExcludes = parameters?.tsFeatureExcludes;
-        }
-        else if ($isReadonlyStringArray(parameters?.tsFeatureExcludes)) {
-            tsFeatureExcludes = parameters?.tsFeatureExcludes.map((item) => dataFactory.namedNode(item));
-        }
-        else {
-            tsFeatureExcludes = parameters?.tsFeatureExcludes;
-        }
-        let tsFeatureIncludes;
-        if (parameters?.tsFeatureIncludes === undefined) {
-            tsFeatureIncludes = [];
-        }
-        else if ($isReadonlyObjectArray(parameters?.tsFeatureIncludes)) {
-            tsFeatureIncludes = parameters?.tsFeatureIncludes;
-        }
-        else if ($isReadonlyStringArray(parameters?.tsFeatureIncludes)) {
-            tsFeatureIncludes = parameters?.tsFeatureIncludes.map((item) => dataFactory.namedNode(item));
-        }
-        else {
-            tsFeatureIncludes = parameters?.tsFeatureIncludes;
-        }
-        let tsImports;
-        if (parameters?.tsImports === undefined) {
-            tsImports = [];
-        }
-        else if (typeof parameters?.tsImports === "object") {
-            tsImports = parameters?.tsImports;
-        }
-        else {
-            tsImports = parameters?.tsImports;
-        }
-        return {
-            $identifier,
-            $type,
-            comment,
-            label,
-            tsFeatureExcludes,
-            tsFeatureIncludes,
-            tsImports,
-        };
-    }
-    Ontology.create = create;
-    let Identifier;
-    (function (Identifier) {
-        Identifier.parse = $parseIdentifier;
-        Identifier.stringify = NTriplesTerm.stringify;
-    })(Identifier = Ontology.Identifier || (Ontology.Identifier = {}));
-    function filter(filter, value) {
-        if (filter.$identifier !== undefined &&
-            !$filterIdentifier(filter.$identifier, value.$identifier())) {
-            return false;
-        }
-        if (filter.comment !== undefined &&
-            !$filterMaybe($filterString)(filter.comment, value.comment)) {
-            return false;
-        }
-        if (filter.label !== undefined &&
-            !$filterMaybe($filterString)(filter.label, value.label)) {
-            return false;
-        }
-        if (filter.tsFeatureExcludes !== undefined &&
-            !$filterArray($filterIri)(filter.tsFeatureExcludes, value.tsFeatureExcludes)) {
-            return false;
-        }
-        if (filter.tsFeatureIncludes !== undefined &&
-            !$filterArray($filterIri)(filter.tsFeatureIncludes, value.tsFeatureIncludes)) {
-            return false;
-        }
-        if (filter.tsImports !== undefined &&
-            !$filterArray($filterString)(filter.tsImports, value.tsImports)) {
-            return false;
-        }
-        return true;
-    }
-    Ontology.filter = filter;
-    Ontology._fromRdfResource = ($resource, _$options) => {
-        return (!_$options.ignoreRdfType
-            ? $resource
-                .value($RdfVocabularies.rdf.type, { graph: _$options.graph })
-                .chain((actualRdfType) => actualRdfType.toIri())
-                .chain((actualRdfType) => {
-                // Check the expected type and its known subtypes
-                switch (actualRdfType.value) {
-                    case "http://www.w3.org/2002/07/owl#Ontology":
-                        return Right(true);
-                }
-                // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($resource.isInstanceOf(Ontology.fromRdfType, {
-                    graph: _$options.graph,
-                })) {
-                    return Right(true);
-                }
-                return Left(new Error(`${$resource.identifier} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/2002/07/owl#Ontology)`));
-            })
-            : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
-            $identifier: Right(new Resource.Value({
-                dataFactory: dataFactory,
-                focusResource: $resource,
-                propertyPath: $RdfVocabularies.rdf.subject,
-                term: $resource.identifier,
-            }).toValues())
-                .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                .chain((values) => values.head()),
-            comment: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: Ontology.schema.properties.comment,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.comment.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            label: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: Ontology.schema.properties.label,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.label.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            tsFeatureExcludes: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: Ontology.schema.properties.tsFeatureExcludes,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri([
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
-                ])))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: Ontology.schema.properties.tsFeatureExcludes.path,
-                    value: valuesArray,
-                })),
-            }),
-            tsFeatureIncludes: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: Ontology.schema.properties.tsFeatureIncludes,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri([
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
-                ])))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: Ontology.schema.properties.tsFeatureIncludes.path,
-                    value: valuesArray,
-                })),
-            }),
-            tsImports: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: Ontology.schema.properties.tsImports,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: Ontology.schema.properties.tsImports.path,
-                    value: valuesArray,
-                })),
-            }),
-        }).map((properties) => create(properties)));
-    };
-    Ontology.fromRdfResource = $wrap_FromRdfResourceFunction(Ontology._fromRdfResource);
-    Ontology.fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
-        .toResource()
-        .chain((resource) => Ontology.fromRdfResource(resource, options))));
-    Ontology.fromRdfType = dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology");
-    function isOntology(object) {
-        switch (object.$type) {
-            case "Ontology":
-                return true;
-            default:
-                return false;
-        }
-    }
-    Ontology.isOntology = isOntology;
-    Ontology.schema = {
-        properties: {
-            $identifier: {
-                kind: "Identifier",
-                type: () => ({ kind: "Identifier" }),
-            },
-            $type: {
-                kind: "Discriminant",
-                type: () => ({
-                    kind: "TypeDiscriminant",
-                    ownValues: ["Ontology"],
-                }),
-            },
-            comment: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
-            },
-            label: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
-            },
-            tsFeatureExcludes: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({
-                        kind: "Iri",
-                        in: [
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
-                        ],
-                    }),
-                }),
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureExclude"),
-            },
-            tsFeatureIncludes: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({
-                        kind: "Iri",
-                        in: [
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
-                        ],
-                    }),
-                }),
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureInclude"),
-            },
-            tsImports: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "String" }),
-                }),
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsImport"),
-            },
-        },
-    };
-    Ontology._toRdfResource = (parameters) => {
-        if (!parameters.ignoreRdfType) {
-            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"), parameters.graph);
-        }
-        parameters.resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), parameters.object.comment
-            .toList()
-            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), parameters.object.label
-            .toList()
-            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureExclude"), parameters.object.tsFeatureExcludes.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureInclude"), parameters.object.tsFeatureIncludes.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsImport"), parameters.object.tsImports.flatMap((item) => [
-            $literalFactory.string(item),
-        ]), parameters.graph);
-        return parameters.resource;
-    };
-    Ontology.toRdfResource = $wrap_ToRdfResourceFunction(Ontology._toRdfResource);
-    function _propertiesToStrings(_ontology) {
-        return $compactRecord({
-            $identifier: _ontology.$identifier().toString(),
-            label: _ontology.label.map((item) => item.toString()).extract(),
-        });
-    }
-    Ontology._propertiesToStrings = _propertiesToStrings;
-    function $toString(_ontology) {
-        return `Ontology(${JSON.stringify(_propertiesToStrings((_ontology ?? this)))})`;
-    }
-    Ontology.$toString = $toString;
-})(Ontology || (Ontology = {}));
-export var NodeShape;
-(function (NodeShape) {
-    function create(parameters) {
-        const $identifierParameter = parameters?.$identifier;
-        let $identifier;
-        if (typeof $identifierParameter === "function") {
-            $identifier = $identifierParameter;
-        }
-        else if (typeof $identifierParameter === "object") {
-            $identifier = () => $identifierParameter;
-        }
-        else if (typeof $identifierParameter === "string") {
-            $identifier = () => dataFactory.namedNode($identifierParameter);
-        }
-        else if ($identifierParameter === undefined) {
-            const $eagerIdentifier = dataFactory.blankNode();
-            $identifier = () => $eagerIdentifier;
-        }
-        else {
-            $identifier = $identifierParameter;
-        }
-        const $type = "NodeShape";
-        let and;
-        if (Maybe.isMaybe(parameters?.and)) {
-            and = parameters?.and;
-        }
-        else if ($isReadonlyObjectArray(parameters?.and)) {
-            and = Maybe.of(parameters?.and);
-        }
-        else if ($isReadonlyStringArray(parameters?.and)) {
-            and = Maybe.of(parameters?.and.map((item) => dataFactory.namedNode(item)));
-        }
-        else if (parameters?.and === undefined) {
-            and = Maybe.empty();
-        }
-        else {
-            and = parameters?.and;
-        }
-        let classes;
-        if (parameters?.classes === undefined) {
-            classes = [];
-        }
-        else if ($isReadonlyObjectArray(parameters?.classes)) {
-            classes = parameters?.classes;
-        }
-        else if ($isReadonlyStringArray(parameters?.classes)) {
-            classes = parameters?.classes.map((item) => dataFactory.namedNode(item));
-        }
-        else {
-            classes = parameters?.classes;
-        }
-        let closed;
-        if (Maybe.isMaybe(parameters?.closed)) {
-            closed = parameters?.closed;
-        }
-        else if (typeof parameters?.closed === "boolean") {
-            closed = Maybe.of(parameters?.closed);
-        }
-        else if (parameters?.closed === undefined) {
-            closed = Maybe.empty();
-        }
-        else {
-            closed = parameters?.closed;
-        }
-        let comment;
-        if (Maybe.isMaybe(parameters?.comment)) {
-            comment = parameters?.comment;
-        }
-        else if (typeof parameters?.comment === "string") {
-            comment = Maybe.of(parameters?.comment);
-        }
-        else if (parameters?.comment === undefined) {
-            comment = Maybe.empty();
-        }
-        else {
-            comment = parameters?.comment;
-        }
-        let datatype;
-        if (Maybe.isMaybe(parameters?.datatype)) {
-            datatype = parameters?.datatype;
-        }
-        else if (typeof parameters?.datatype === "object") {
-            datatype = Maybe.of(parameters?.datatype);
-        }
-        else if (typeof parameters?.datatype === "string") {
-            datatype = Maybe.of(dataFactory.namedNode(parameters?.datatype));
-        }
-        else if (parameters?.datatype === undefined) {
-            datatype = Maybe.empty();
-        }
-        else {
-            datatype = parameters?.datatype;
-        }
-        let deactivated;
-        if (Maybe.isMaybe(parameters?.deactivated)) {
-            deactivated = parameters?.deactivated;
-        }
-        else if (typeof parameters?.deactivated === "boolean") {
-            deactivated = Maybe.of(parameters?.deactivated);
-        }
-        else if (parameters?.deactivated === undefined) {
-            deactivated = Maybe.empty();
-        }
-        else {
-            deactivated = parameters?.deactivated;
-        }
-        let discriminantValue;
-        if (Maybe.isMaybe(parameters?.discriminantValue)) {
-            discriminantValue = parameters?.discriminantValue;
-        }
-        else if (typeof parameters?.discriminantValue === "string") {
-            discriminantValue = Maybe.of(parameters?.discriminantValue);
-        }
-        else if (parameters?.discriminantValue === undefined) {
-            discriminantValue = Maybe.empty();
-        }
-        else {
-            discriminantValue = parameters?.discriminantValue;
-        }
-        let extern;
-        if (Maybe.isMaybe(parameters?.extern)) {
-            extern = parameters?.extern;
-        }
-        else if (typeof parameters?.extern === "boolean") {
-            extern = Maybe.of(parameters?.extern);
-        }
-        else if (parameters?.extern === undefined) {
-            extern = Maybe.empty();
-        }
-        else {
-            extern = parameters?.extern;
-        }
-        let flags;
-        if (parameters?.flags === undefined) {
-            flags = [];
-        }
-        else if (typeof parameters?.flags === "object") {
-            flags = parameters?.flags;
-        }
-        else {
-            flags = parameters?.flags;
-        }
-        let fromRdfType;
-        if (Maybe.isMaybe(parameters?.fromRdfType)) {
-            fromRdfType = parameters?.fromRdfType;
-        }
-        else if (typeof parameters?.fromRdfType === "object") {
-            fromRdfType = Maybe.of(parameters?.fromRdfType);
-        }
-        else if (typeof parameters?.fromRdfType === "string") {
-            fromRdfType = Maybe.of(dataFactory.namedNode(parameters?.fromRdfType));
-        }
-        else if (parameters?.fromRdfType === undefined) {
-            fromRdfType = Maybe.empty();
-        }
-        else {
-            fromRdfType = parameters?.fromRdfType;
-        }
-        let hasValues;
-        if (parameters?.hasValues === undefined) {
-            hasValues = [];
-        }
-        else if ($isReadonlyObjectArray(parameters?.hasValues)) {
-            hasValues = parameters?.hasValues;
-        }
-        else if ($isReadonlyBigIntArray(parameters?.hasValues)) {
-            hasValues = parameters?.hasValues.map((item) => $literalFactory.bigint(item));
-        }
-        else if ($isReadonlyBooleanArray(parameters?.hasValues)) {
-            hasValues = parameters?.hasValues.map((item) => $literalFactory.boolean(item));
-        }
-        else if ($isReadonlyNumberArray(parameters?.hasValues)) {
-            hasValues = parameters?.hasValues.map((item) => $literalFactory.number(item));
-        }
-        else if ($isReadonlyStringArray(parameters?.hasValues)) {
-            hasValues = parameters?.hasValues.map((item) => $literalFactory.string(item));
-        }
-        else {
-            hasValues = parameters?.hasValues;
-        }
-        let ignoredProperties;
-        if (Maybe.isMaybe(parameters?.ignoredProperties)) {
-            ignoredProperties = parameters?.ignoredProperties;
-        }
-        else if ($isReadonlyObjectArray(parameters?.ignoredProperties)) {
-            ignoredProperties = Maybe.of(parameters?.ignoredProperties);
-        }
-        else if ($isReadonlyStringArray(parameters?.ignoredProperties)) {
-            ignoredProperties = Maybe.of(parameters?.ignoredProperties.map((item) => dataFactory.namedNode(item)));
-        }
-        else if (parameters?.ignoredProperties === undefined) {
-            ignoredProperties = Maybe.empty();
-        }
-        else {
-            ignoredProperties = parameters?.ignoredProperties;
-        }
-        let in_;
-        if (Maybe.isMaybe(parameters?.in_)) {
-            in_ = parameters?.in_;
-        }
-        else if ($isReadonlyObjectArray(parameters?.in_)) {
-            in_ = Maybe.of(parameters?.in_);
-        }
-        else if ($isReadonlyBigIntArray(parameters?.in_)) {
-            in_ = Maybe.of(parameters?.in_.map((item) => $literalFactory.bigint(item)));
-        }
-        else if ($isReadonlyBooleanArray(parameters?.in_)) {
-            in_ = Maybe.of(parameters?.in_.map((item) => $literalFactory.boolean(item)));
-        }
-        else if ($isReadonlyNumberArray(parameters?.in_)) {
-            in_ = Maybe.of(parameters?.in_.map((item) => $literalFactory.number(item)));
-        }
-        else if ($isReadonlyStringArray(parameters?.in_)) {
-            in_ = Maybe.of(parameters?.in_.map((item) => $literalFactory.string(item)));
-        }
-        else if (parameters?.in_ === undefined) {
-            in_ = Maybe.empty();
-        }
-        else {
-            in_ = parameters?.in_;
-        }
-        let isDefinedBy;
-        if (Maybe.isMaybe(parameters?.isDefinedBy)) {
-            isDefinedBy = parameters?.isDefinedBy;
-        }
-        else if (typeof parameters?.isDefinedBy === "object") {
-            isDefinedBy = Maybe.of(parameters?.isDefinedBy);
-        }
-        else if (typeof parameters?.isDefinedBy === "string") {
-            isDefinedBy = Maybe.of(dataFactory.namedNode(parameters?.isDefinedBy));
-        }
-        else if (parameters?.isDefinedBy === undefined) {
-            isDefinedBy = Maybe.empty();
-        }
-        else {
-            isDefinedBy = parameters?.isDefinedBy;
-        }
-        let label;
-        if (Maybe.isMaybe(parameters?.label)) {
-            label = parameters?.label;
-        }
-        else if (typeof parameters?.label === "string") {
-            label = Maybe.of(parameters?.label);
-        }
-        else if (parameters?.label === undefined) {
-            label = Maybe.empty();
-        }
-        else {
-            label = parameters?.label;
-        }
-        let languageIn;
-        if (Maybe.isMaybe(parameters?.languageIn)) {
-            languageIn = parameters?.languageIn;
-        }
-        else if (typeof parameters?.languageIn === "object") {
-            languageIn = Maybe.of(parameters?.languageIn);
-        }
-        else if (parameters?.languageIn === undefined) {
-            languageIn = Maybe.empty();
-        }
-        else {
-            languageIn = parameters?.languageIn;
-        }
-        let maxCount;
-        if (Maybe.isMaybe(parameters?.maxCount)) {
-            maxCount = parameters?.maxCount;
-        }
-        else if (typeof parameters?.maxCount === "bigint") {
-            maxCount = Maybe.of(parameters?.maxCount);
-        }
-        else if (typeof parameters?.maxCount === "number") {
-            maxCount = Maybe.of(BigInt(parameters?.maxCount));
-        }
-        else if (parameters?.maxCount === undefined) {
-            maxCount = Maybe.empty();
-        }
-        else {
-            maxCount = parameters?.maxCount;
-        }
-        let maxExclusive;
-        if (Maybe.isMaybe(parameters?.maxExclusive)) {
-            maxExclusive = parameters?.maxExclusive;
-        }
-        else if (typeof parameters?.maxExclusive === "bigint") {
-            maxExclusive = Maybe.of($literalFactory.bigint(parameters?.maxExclusive));
-        }
-        else if (typeof parameters?.maxExclusive === "boolean") {
-            maxExclusive = Maybe.of($literalFactory.boolean(parameters?.maxExclusive));
-        }
-        else if (typeof parameters?.maxExclusive === "object" &&
-            parameters?.maxExclusive instanceof Date) {
-            maxExclusive = Maybe.of($literalFactory.date(parameters?.maxExclusive));
-        }
-        else if (typeof parameters?.maxExclusive === "number") {
-            maxExclusive = Maybe.of($literalFactory.number(parameters?.maxExclusive));
-        }
-        else if (typeof parameters?.maxExclusive === "string") {
-            maxExclusive = Maybe.of($literalFactory.string(parameters?.maxExclusive));
-        }
-        else if (typeof parameters?.maxExclusive === "object") {
-            maxExclusive = Maybe.of(parameters?.maxExclusive);
-        }
-        else if (parameters?.maxExclusive === undefined) {
-            maxExclusive = Maybe.empty();
-        }
-        else {
-            maxExclusive = parameters?.maxExclusive;
-        }
-        let maxInclusive;
-        if (Maybe.isMaybe(parameters?.maxInclusive)) {
-            maxInclusive = parameters?.maxInclusive;
-        }
-        else if (typeof parameters?.maxInclusive === "bigint") {
-            maxInclusive = Maybe.of($literalFactory.bigint(parameters?.maxInclusive));
-        }
-        else if (typeof parameters?.maxInclusive === "boolean") {
-            maxInclusive = Maybe.of($literalFactory.boolean(parameters?.maxInclusive));
-        }
-        else if (typeof parameters?.maxInclusive === "object" &&
-            parameters?.maxInclusive instanceof Date) {
-            maxInclusive = Maybe.of($literalFactory.date(parameters?.maxInclusive));
-        }
-        else if (typeof parameters?.maxInclusive === "number") {
-            maxInclusive = Maybe.of($literalFactory.number(parameters?.maxInclusive));
-        }
-        else if (typeof parameters?.maxInclusive === "string") {
-            maxInclusive = Maybe.of($literalFactory.string(parameters?.maxInclusive));
-        }
-        else if (typeof parameters?.maxInclusive === "object") {
-            maxInclusive = Maybe.of(parameters?.maxInclusive);
-        }
-        else if (parameters?.maxInclusive === undefined) {
-            maxInclusive = Maybe.empty();
-        }
-        else {
-            maxInclusive = parameters?.maxInclusive;
-        }
-        let maxLength;
-        if (Maybe.isMaybe(parameters?.maxLength)) {
-            maxLength = parameters?.maxLength;
-        }
-        else if (typeof parameters?.maxLength === "bigint") {
-            maxLength = Maybe.of(parameters?.maxLength);
-        }
-        else if (typeof parameters?.maxLength === "number") {
-            maxLength = Maybe.of(BigInt(parameters?.maxLength));
-        }
-        else if (parameters?.maxLength === undefined) {
-            maxLength = Maybe.empty();
-        }
-        else {
-            maxLength = parameters?.maxLength;
-        }
-        let minCount;
-        if (Maybe.isMaybe(parameters?.minCount)) {
-            minCount = parameters?.minCount;
-        }
-        else if (typeof parameters?.minCount === "bigint") {
-            minCount = Maybe.of(parameters?.minCount);
-        }
-        else if (typeof parameters?.minCount === "number") {
-            minCount = Maybe.of(BigInt(parameters?.minCount));
-        }
-        else if (parameters?.minCount === undefined) {
-            minCount = Maybe.empty();
-        }
-        else {
-            minCount = parameters?.minCount;
-        }
-        let minExclusive;
-        if (Maybe.isMaybe(parameters?.minExclusive)) {
-            minExclusive = parameters?.minExclusive;
-        }
-        else if (typeof parameters?.minExclusive === "bigint") {
-            minExclusive = Maybe.of($literalFactory.bigint(parameters?.minExclusive));
-        }
-        else if (typeof parameters?.minExclusive === "boolean") {
-            minExclusive = Maybe.of($literalFactory.boolean(parameters?.minExclusive));
-        }
-        else if (typeof parameters?.minExclusive === "object" &&
-            parameters?.minExclusive instanceof Date) {
-            minExclusive = Maybe.of($literalFactory.date(parameters?.minExclusive));
-        }
-        else if (typeof parameters?.minExclusive === "number") {
-            minExclusive = Maybe.of($literalFactory.number(parameters?.minExclusive));
-        }
-        else if (typeof parameters?.minExclusive === "string") {
-            minExclusive = Maybe.of($literalFactory.string(parameters?.minExclusive));
-        }
-        else if (typeof parameters?.minExclusive === "object") {
-            minExclusive = Maybe.of(parameters?.minExclusive);
-        }
-        else if (parameters?.minExclusive === undefined) {
-            minExclusive = Maybe.empty();
-        }
-        else {
-            minExclusive = parameters?.minExclusive;
-        }
-        let minInclusive;
-        if (Maybe.isMaybe(parameters?.minInclusive)) {
-            minInclusive = parameters?.minInclusive;
-        }
-        else if (typeof parameters?.minInclusive === "bigint") {
-            minInclusive = Maybe.of($literalFactory.bigint(parameters?.minInclusive));
-        }
-        else if (typeof parameters?.minInclusive === "boolean") {
-            minInclusive = Maybe.of($literalFactory.boolean(parameters?.minInclusive));
-        }
-        else if (typeof parameters?.minInclusive === "object" &&
-            parameters?.minInclusive instanceof Date) {
-            minInclusive = Maybe.of($literalFactory.date(parameters?.minInclusive));
-        }
-        else if (typeof parameters?.minInclusive === "number") {
-            minInclusive = Maybe.of($literalFactory.number(parameters?.minInclusive));
-        }
-        else if (typeof parameters?.minInclusive === "string") {
-            minInclusive = Maybe.of($literalFactory.string(parameters?.minInclusive));
-        }
-        else if (typeof parameters?.minInclusive === "object") {
-            minInclusive = Maybe.of(parameters?.minInclusive);
-        }
-        else if (parameters?.minInclusive === undefined) {
-            minInclusive = Maybe.empty();
-        }
-        else {
-            minInclusive = parameters?.minInclusive;
-        }
-        let minLength;
-        if (Maybe.isMaybe(parameters?.minLength)) {
-            minLength = parameters?.minLength;
-        }
-        else if (typeof parameters?.minLength === "bigint") {
-            minLength = Maybe.of(parameters?.minLength);
-        }
-        else if (typeof parameters?.minLength === "number") {
-            minLength = Maybe.of(BigInt(parameters?.minLength));
-        }
-        else if (parameters?.minLength === undefined) {
-            minLength = Maybe.empty();
-        }
-        else {
-            minLength = parameters?.minLength;
-        }
-        let mutable;
-        if (Maybe.isMaybe(parameters?.mutable)) {
-            mutable = parameters?.mutable;
-        }
-        else if (typeof parameters?.mutable === "boolean") {
-            mutable = Maybe.of(parameters?.mutable);
-        }
-        else if (parameters?.mutable === undefined) {
-            mutable = Maybe.empty();
-        }
-        else {
-            mutable = parameters?.mutable;
-        }
-        let node;
-        if (Maybe.isMaybe(parameters?.node)) {
-            node = parameters?.node;
-        }
-        else if (typeof parameters?.node === "object") {
-            node = Maybe.of(parameters?.node);
-        }
-        else if (typeof parameters?.node === "string") {
-            node = Maybe.of(dataFactory.namedNode(parameters?.node));
-        }
-        else if (parameters?.node === undefined) {
-            node = Maybe.empty();
-        }
-        else {
-            node = parameters?.node;
-        }
-        let nodeKind;
-        if (Maybe.isMaybe(parameters?.nodeKind)) {
-            nodeKind = parameters?.nodeKind;
-        }
-        else if (typeof parameters?.nodeKind === "object") {
-            nodeKind = Maybe.of(parameters?.nodeKind);
-        }
-        else if (typeof parameters?.nodeKind === "string") {
-            nodeKind = Maybe.of(dataFactory.namedNode(parameters?.nodeKind));
-        }
-        else if (parameters?.nodeKind === undefined) {
-            nodeKind = Maybe.empty();
-        }
-        else {
-            nodeKind = parameters?.nodeKind;
-        }
-        let not;
-        if (parameters?.not === undefined) {
-            not = [];
-        }
-        else if ($isReadonlyObjectArray(parameters?.not)) {
-            not = parameters?.not;
-        }
-        else if ($isReadonlyStringArray(parameters?.not)) {
-            not = parameters?.not.map((item) => dataFactory.namedNode(item));
-        }
-        else {
-            not = parameters?.not;
-        }
-        let or;
-        if (Maybe.isMaybe(parameters?.or)) {
-            or = parameters?.or;
-        }
-        else if ($isReadonlyObjectArray(parameters?.or)) {
-            or = Maybe.of(parameters?.or);
-        }
-        else if ($isReadonlyStringArray(parameters?.or)) {
-            or = Maybe.of(parameters?.or.map((item) => dataFactory.namedNode(item)));
-        }
-        else if (parameters?.or === undefined) {
-            or = Maybe.empty();
-        }
-        else {
-            or = parameters?.or;
-        }
-        let patterns;
-        if (parameters?.patterns === undefined) {
-            patterns = [];
-        }
-        else if (typeof parameters?.patterns === "object") {
-            patterns = parameters?.patterns;
-        }
-        else {
-            patterns = parameters?.patterns;
-        }
-        let properties;
-        if (parameters?.properties === undefined) {
-            properties = [];
-        }
-        else if ($isReadonlyObjectArray(parameters?.properties)) {
-            properties = parameters?.properties;
-        }
-        else if ($isReadonlyStringArray(parameters?.properties)) {
-            properties = parameters?.properties.map((item) => dataFactory.namedNode(item));
-        }
-        else {
-            properties = parameters?.properties;
-        }
-        let rdfType;
-        if (Maybe.isMaybe(parameters?.rdfType)) {
-            rdfType = parameters?.rdfType;
-        }
-        else if (typeof parameters?.rdfType === "object") {
-            rdfType = Maybe.of(parameters?.rdfType);
-        }
-        else if (typeof parameters?.rdfType === "string") {
-            rdfType = Maybe.of(dataFactory.namedNode(parameters?.rdfType));
-        }
-        else if (parameters?.rdfType === undefined) {
-            rdfType = Maybe.empty();
-        }
-        else {
-            rdfType = parameters?.rdfType;
-        }
-        let shaclmateName;
-        if (Maybe.isMaybe(parameters?.shaclmateName)) {
-            shaclmateName = parameters?.shaclmateName;
-        }
-        else if (typeof parameters?.shaclmateName === "string") {
-            shaclmateName = Maybe.of(parameters?.shaclmateName);
-        }
-        else if (parameters?.shaclmateName === undefined) {
-            shaclmateName = Maybe.empty();
-        }
-        else {
-            shaclmateName = parameters?.shaclmateName;
-        }
-        let subClassOf;
-        if (parameters?.subClassOf === undefined) {
-            subClassOf = [];
-        }
-        else if ($isReadonlyObjectArray(parameters?.subClassOf)) {
-            subClassOf = parameters?.subClassOf;
-        }
-        else if ($isReadonlyStringArray(parameters?.subClassOf)) {
-            subClassOf = parameters?.subClassOf.map((item) => dataFactory.namedNode(item));
-        }
-        else {
-            subClassOf = parameters?.subClassOf;
-        }
-        let toRdfTypes;
-        if (parameters?.toRdfTypes === undefined) {
-            toRdfTypes = [];
-        }
-        else if ($isReadonlyObjectArray(parameters?.toRdfTypes)) {
-            toRdfTypes = parameters?.toRdfTypes;
-        }
-        else if ($isReadonlyStringArray(parameters?.toRdfTypes)) {
-            toRdfTypes = parameters?.toRdfTypes.map((item) => dataFactory.namedNode(item));
-        }
-        else {
-            toRdfTypes = parameters?.toRdfTypes;
-        }
-        let tsFeatureExcludes;
-        if (parameters?.tsFeatureExcludes === undefined) {
-            tsFeatureExcludes = [];
-        }
-        else if ($isReadonlyObjectArray(parameters?.tsFeatureExcludes)) {
-            tsFeatureExcludes = parameters?.tsFeatureExcludes;
-        }
-        else if ($isReadonlyStringArray(parameters?.tsFeatureExcludes)) {
-            tsFeatureExcludes = parameters?.tsFeatureExcludes.map((item) => dataFactory.namedNode(item));
-        }
-        else {
-            tsFeatureExcludes = parameters?.tsFeatureExcludes;
-        }
-        let tsFeatureIncludes;
-        if (parameters?.tsFeatureIncludes === undefined) {
-            tsFeatureIncludes = [];
-        }
-        else if ($isReadonlyObjectArray(parameters?.tsFeatureIncludes)) {
-            tsFeatureIncludes = parameters?.tsFeatureIncludes;
-        }
-        else if ($isReadonlyStringArray(parameters?.tsFeatureIncludes)) {
-            tsFeatureIncludes = parameters?.tsFeatureIncludes.map((item) => dataFactory.namedNode(item));
-        }
-        else {
-            tsFeatureIncludes = parameters?.tsFeatureIncludes;
-        }
-        let tsImports;
-        if (parameters?.tsImports === undefined) {
-            tsImports = [];
-        }
-        else if (typeof parameters?.tsImports === "object") {
-            tsImports = parameters?.tsImports;
-        }
-        else {
-            tsImports = parameters?.tsImports;
-        }
-        let types;
-        if (parameters?.types === undefined) {
-            types = [];
-        }
-        else if ($isReadonlyObjectArray(parameters?.types)) {
-            types = parameters?.types;
-        }
-        else if ($isReadonlyStringArray(parameters?.types)) {
-            types = parameters?.types.map((item) => dataFactory.namedNode(item));
+                kind: "Discriminant",
+                type: () => ({
+                    kind: "TypeDiscriminant",
+                    ownValues: ["PropertyGroup"],
+                }),
+            },
+            comment: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+            },
+            label: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+            },
+        },
+    };
+    PropertyGroup._toRdfResource = (parameters) => {
+        if (!parameters.ignoreRdfType) {
+            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"), parameters.graph);
         }
-        else {
-            types = parameters?.types;
+        parameters.resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), parameters.object.comment
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), parameters.object.label
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        return parameters.resource;
+    };
+    PropertyGroup.toRdfResource = $wrap_ToRdfResourceFunction(PropertyGroup._toRdfResource);
+    function _propertiesToStrings(_propertyGroup) {
+        return $compactRecord({
+            $identifier: _propertyGroup.$identifier().toString(),
+            label: _propertyGroup.label.map((item) => item.toString()).extract(),
+        });
+    }
+    PropertyGroup._propertiesToStrings = _propertiesToStrings;
+    function $toString(_propertyGroup) {
+        return `PropertyGroup(${JSON.stringify(_propertiesToStrings((_propertyGroup ?? this)))})`;
+    }
+    PropertyGroup.$toString = $toString;
+})(PropertyGroup || (PropertyGroup = {}));
+export var Ontology;
+(function (Ontology) {
+    function create(parameters) {
+        return $sequenceRecord({
+            $identifier: $convertToIdentifierProperty(parameters?.$identifier),
+            comment: $convertToMaybe(($convertToString))(Ontology.schema.properties.comment.type(), parameters?.comment),
+            label: $convertToMaybe(($convertToString))(Ontology.schema.properties.label.type(), parameters?.label),
+        }).map((properties) => {
+            const finalObject = { ...properties, $type: "Ontology" };
+            if (!globalThis.Object.prototype.hasOwnProperty.call(finalObject, "toString")) {
+                finalObject.toString = $toString;
+            }
+            return finalObject;
+        });
+    }
+    Ontology.create = create;
+    function createUnsafe(parameters) {
+        return create(parameters).unsafeCoerce();
+    }
+    Ontology.createUnsafe = createUnsafe;
+    let Identifier;
+    (function (Identifier) {
+        Identifier.parse = $parseIdentifier;
+        Identifier.stringify = NTriplesTerm.stringify;
+    })(Identifier = Ontology.Identifier || (Ontology.Identifier = {}));
+    function filter(filter, value) {
+        if (filter.$identifier !== undefined &&
+            !$filterIdentifier(filter.$identifier, value.$identifier())) {
+            return false;
         }
-        let xone;
-        if (Maybe.isMaybe(parameters?.xone)) {
-            xone = parameters?.xone;
+        if (filter.comment !== undefined &&
+            !$filterMaybe($filterString)(filter.comment, value.comment)) {
+            return false;
         }
-        else if ($isReadonlyObjectArray(parameters?.xone)) {
-            xone = Maybe.of(parameters?.xone);
+        if (filter.label !== undefined &&
+            !$filterMaybe($filterString)(filter.label, value.label)) {
+            return false;
         }
-        else if ($isReadonlyStringArray(parameters?.xone)) {
-            xone = Maybe.of(parameters?.xone.map((item) => dataFactory.namedNode(item)));
+        return true;
+    }
+    Ontology.filter = filter;
+    Ontology._fromRdfResource = ($resource, _$options) => {
+        return (!_$options.ignoreRdfType
+            ? $resource
+                .value($RdfVocabularies.rdf.type, { graph: _$options.graph })
+                .chain((actualRdfType) => actualRdfType.toIri())
+                .chain((actualRdfType) => {
+                // Check the expected type and its known subtypes
+                switch (actualRdfType.value) {
+                    case "http://www.w3.org/2002/07/owl#Ontology":
+                        return Right(true);
+                }
+                // Check arbitrary rdfs:subClassOf's of the expected type
+                if ($resource.isInstanceOf(Ontology.fromRdfType, {
+                    graph: _$options.graph,
+                })) {
+                    return Right(true);
+                }
+                return Left(new Error(`${$resource.identifier} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/2002/07/owl#Ontology)`));
+            })
+            : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+            $identifier: Right(new Resource.Value({
+                dataFactory: dataFactory,
+                focusResource: $resource,
+                propertyPath: $RdfVocabularies.rdf.subject,
+                term: $resource.identifier,
+            }).toValues())
+                .chain((values) => values.chainMap((value) => value.toIdentifier()))
+                .chain((values) => values.head()),
+            comment: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: Ontology.schema.properties.comment,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
+                    .chain((values) => values.chainMap((value) => value.toString()))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: PropertyShape.schema.properties.comment.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            label: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: Ontology.schema.properties.label,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
+                    .chain((values) => values.chainMap((value) => value.toString()))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: PropertyShape.schema.properties.label.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+        }).chain((properties) => create(properties)));
+    };
+    Ontology.fromRdfResource = $wrap_FromRdfResourceFunction(Ontology._fromRdfResource);
+    Ontology.fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => Ontology.fromRdfResource(resource, options))));
+    Ontology.fromRdfType = dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology");
+    function isOntology(object) {
+        switch (object.$type) {
+            case "Ontology":
+                return true;
+            default:
+                return false;
         }
-        else if (parameters?.xone === undefined) {
-            xone = Maybe.empty();
+    }
+    Ontology.isOntology = isOntology;
+    Ontology.schema = {
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: () => ({ kind: "Identifier" }),
+            },
+            $type: {
+                kind: "Discriminant",
+                type: () => ({
+                    kind: "TypeDiscriminant",
+                    ownValues: ["Ontology"],
+                }),
+            },
+            comment: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+            },
+            label: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "Maybe",
+                    item: () => ({ kind: "String" }),
+                }),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+            },
+        },
+    };
+    Ontology._toRdfResource = (parameters) => {
+        if (!parameters.ignoreRdfType) {
+            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"), parameters.graph);
         }
-        else {
-            xone = parameters?.xone;
-        }
-        return {
-            $identifier,
-            $type,
-            and,
-            classes,
-            closed,
-            comment,
-            datatype,
-            deactivated,
-            discriminantValue,
-            extern,
-            flags,
-            fromRdfType,
-            hasValues,
-            ignoredProperties,
-            in_,
-            isDefinedBy,
-            label,
-            languageIn,
-            maxCount,
-            maxExclusive,
-            maxInclusive,
-            maxLength,
-            minCount,
-            minExclusive,
-            minInclusive,
-            minLength,
-            mutable,
-            node,
-            nodeKind,
-            not,
-            or,
-            patterns,
-            properties,
-            rdfType,
-            shaclmateName,
-            subClassOf,
-            toRdfTypes,
-            tsFeatureExcludes,
-            tsFeatureIncludes,
-            tsImports,
-            types,
-            xone,
-        };
+        parameters.resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), parameters.object.comment
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), parameters.object.label
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        return parameters.resource;
+    };
+    Ontology.toRdfResource = $wrap_ToRdfResourceFunction(Ontology._toRdfResource);
+    function _propertiesToStrings(_ontology) {
+        return $compactRecord({
+            $identifier: _ontology.$identifier().toString(),
+            label: _ontology.label.map((item) => item.toString()).extract(),
+        });
+    }
+    Ontology._propertiesToStrings = _propertiesToStrings;
+    function $toString(_ontology) {
+        return `Ontology(${JSON.stringify(_propertiesToStrings((_ontology ?? this)))})`;
+    }
+    Ontology.$toString = $toString;
+})(Ontology || (Ontology = {}));
+export var NodeShape;
+(function (NodeShape) {
+    function create(parameters) {
+        return $sequenceRecord({
+            $identifier: $convertToIdentifierProperty(parameters?.$identifier),
+            and: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(NodeShape.schema.properties.and.type(), parameters?.and),
+            classes: $convertToReadonlyArray(($convertToIri))(NodeShape.schema.properties.classes.type(), parameters?.classes),
+            closed: $convertToMaybe(($convertToBoolean))(NodeShape.schema.properties.closed.type(), parameters?.closed),
+            comment: $convertToMaybe(($convertToString))(NodeShape.schema.properties.comment.type(), parameters?.comment),
+            datatype: $convertToMaybe(($convertToIri))(NodeShape.schema.properties.datatype.type(), parameters?.datatype),
+            deactivated: $convertToMaybe(($convertToBoolean))(NodeShape.schema.properties.deactivated.type(), parameters?.deactivated),
+            discriminantValue: $convertToMaybe(($convertToString))(NodeShape.schema.properties.discriminantValue.type(), parameters?.discriminantValue),
+            extern: $convertToMaybe(($convertToBoolean))(NodeShape.schema.properties.extern.type(), parameters?.extern),
+            flags: $convertToReadonlyArray(($convertToString))(NodeShape.schema.properties.flags.type(), parameters?.flags),
+            fromRdfType: $convertToMaybe(($convertToIri))(NodeShape.schema.properties.fromRdfType.type(), parameters?.fromRdfType),
+            hasValues: $convertToReadonlyArray(($convertToTerm))(NodeShape.schema.properties.hasValues.type(), parameters?.hasValues),
+            ignoredProperties: $convertToMaybe($convertToReadonlyArray(($convertToIri)))(NodeShape.schema.properties.ignoredProperties.type(), parameters?.ignoredProperties),
+            in_: $convertToMaybe($convertToReadonlyArray(($convertToTerm)))(NodeShape.schema.properties.in_.type(), parameters?.in_),
+            isDefinedBy: $convertToMaybe($convertToIdentifier)(NodeShape.schema.properties.isDefinedBy.type(), parameters?.isDefinedBy),
+            label: $convertToMaybe(($convertToString))(NodeShape.schema.properties.label.type(), parameters?.label),
+            languageIn: $convertToMaybe($convertToReadonlyArray(($convertToString)))(NodeShape.schema.properties.languageIn.type(), parameters?.languageIn),
+            maxCount: $convertToMaybe(($convertToNumeric))(NodeShape.schema.properties.maxCount.type(), parameters?.maxCount),
+            maxExclusive: $convertToMaybe($convertToLiteral)(NodeShape.schema.properties.maxExclusive.type(), parameters?.maxExclusive),
+            maxInclusive: $convertToMaybe($convertToLiteral)(NodeShape.schema.properties.maxInclusive.type(), parameters?.maxInclusive),
+            maxLength: $convertToMaybe(($convertToNumeric))(NodeShape.schema.properties.maxLength.type(), parameters?.maxLength),
+            minCount: $convertToMaybe(($convertToNumeric))(NodeShape.schema.properties.minCount.type(), parameters?.minCount),
+            minExclusive: $convertToMaybe($convertToLiteral)(NodeShape.schema.properties.minExclusive.type(), parameters?.minExclusive),
+            minInclusive: $convertToMaybe($convertToLiteral)(NodeShape.schema.properties.minInclusive.type(), parameters?.minInclusive),
+            minLength: $convertToMaybe(($convertToNumeric))(NodeShape.schema.properties.minLength.type(), parameters?.minLength),
+            mutable: $convertToMaybe(($convertToBoolean))(NodeShape.schema.properties.mutable.type(), parameters?.mutable),
+            node: $convertToMaybe($convertToIdentifier)(NodeShape.schema.properties.node.type(), parameters?.node),
+            nodeKind: $convertToMaybe(($convertToIri))(NodeShape.schema.properties.nodeKind.type(), parameters?.nodeKind),
+            not: $convertToReadonlyArray($convertToIdentifier)(NodeShape.schema.properties.not.type(), parameters?.not),
+            or: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(NodeShape.schema.properties.or.type(), parameters?.or),
+            patterns: $convertToReadonlyArray(($convertToString))(NodeShape.schema.properties.patterns.type(), parameters?.patterns),
+            properties: $convertToReadonlyArray($convertToIdentifier)(NodeShape.schema.properties.properties.type(), parameters?.properties),
+            rdfType: $convertToMaybe(($convertToIri))(NodeShape.schema.properties.rdfType.type(), parameters?.rdfType),
+            shaclmateName: $convertToMaybe(($convertToString))(NodeShape.schema.properties.shaclmateName.type(), parameters?.shaclmateName),
+            subClassOf: $convertToReadonlyArray(($convertToIri))(NodeShape.schema.properties.subClassOf.type(), parameters?.subClassOf),
+            toRdfTypes: $convertToReadonlyArray(($convertToIri))(NodeShape.schema.properties.toRdfTypes.type(), parameters?.toRdfTypes),
+            tsImports: $convertToReadonlyArray(($convertToString))(NodeShape.schema.properties.tsImports.type(), parameters?.tsImports),
+            types: $convertToReadonlyArray(($convertToIri))(NodeShape.schema.properties.types.type(), parameters?.types),
+            xone: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(NodeShape.schema.properties.xone.type(), parameters?.xone),
+        }).map((properties) => {
+            const finalObject = { ...properties, $type: "NodeShape" };
+            if (!globalThis.Object.prototype.hasOwnProperty.call(finalObject, "toString")) {
+                finalObject.toString = $toString;
+            }
+            return finalObject;
+        });
     }
     NodeShape.create = create;
+    function createUnsafe(parameters) {
+        return create(parameters).unsafeCoerce();
+    }
+    NodeShape.createUnsafe = createUnsafe;
     let Identifier;
     (function (Identifier) {
         Identifier.parse = $parseIdentifier;
@@ -3726,14 +2325,6 @@ export var NodeShape;
             !$filterArray($filterIri)(filter.toRdfTypes, value.toRdfTypes)) {
             return false;
         }
-        if (filter.tsFeatureExcludes !== undefined &&
-            !$filterArray($filterIri)(filter.tsFeatureExcludes, value.tsFeatureExcludes)) {
-            return false;
-        }
-        if (filter.tsFeatureIncludes !== undefined &&
-            !$filterArray($filterIri)(filter.tsFeatureIncludes, value.tsFeatureIncludes)) {
-            return false;
-        }
         if (filter.tsImports !== undefined &&
             !$filterArray($filterString)(filter.tsImports, value.tsImports)) {
             return false;
@@ -4334,54 +2925,6 @@ export var NodeShape;
                     value: valuesArray,
                 })),
             }),
-            tsFeatureExcludes: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.tsFeatureExcludes,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri([
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
-                ])))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: Ontology.schema.properties.tsFeatureExcludes.path,
-                    value: valuesArray,
-                })),
-            }),
-            tsFeatureIncludes: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.tsFeatureIncludes,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri([
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
-                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
-                ])))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: Ontology.schema.properties.tsFeatureIncludes.path,
-                    value: valuesArray,
-                })),
-            }),
             tsImports: $shaclPropertyFromRdf({
                 graph: _$options.graph,
                 resource: $resource,
@@ -4392,7 +2935,7 @@ export var NodeShape;
                     .map((values) => values.toArray())
                     .map((valuesArray) => Resource.Values.fromValue({
                     focusResource: $resource,
-                    propertyPath: Ontology.schema.properties.tsImports.path,
+                    propertyPath: NodeShape.schema.properties.tsImports.path,
                     value: valuesArray,
                 })),
             }),
@@ -4429,7 +2972,7 @@ export var NodeShape;
                         value: Maybe.empty(),
                     })),
             }),
-        }).map((properties) => create(properties)));
+        }).chain((properties) => create(properties)));
     };
     NodeShape.fromRdfResource = $wrap_FromRdfResourceFunction(NodeShape._fromRdfResource);
     NodeShape.fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
@@ -4763,50 +3306,6 @@ export var NodeShape;
                 }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#toRdfType"),
             },
-            tsFeatureExcludes: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({
-                        kind: "Iri",
-                        in: [
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
-                        ],
-                    }),
-                }),
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureExclude"),
-            },
-            tsFeatureIncludes: {
-                kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({
-                        kind: "Iri",
-                        in: [
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
-                            dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
-                        ],
-                    }),
-                }),
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureInclude"),
-            },
             tsImports: {
                 kind: "Shacl",
                 type: () => ({
@@ -5022,8 +3521,6 @@ export var NodeShape;
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
         parameters.resource.add($RdfVocabularies.rdfs.subClassOf, parameters.object.subClassOf.flatMap((item) => [item]), parameters.graph);
         parameters.resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#toRdfType"), parameters.object.toRdfTypes.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureExclude"), parameters.object.tsFeatureExcludes.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsFeatureInclude"), parameters.object.tsFeatureIncludes.flatMap((item) => [item]), parameters.graph);
         parameters.resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsImport"), parameters.object.tsImports.flatMap((item) => [
             $literalFactory.string(item),
         ]), parameters.graph);