@shaclmate/compiler 4.0.33 → 4.0.35

package/dist/input/generated.js

@@ -15,6 +15,79 @@ function $compactRecord(record) {
         return definedProperties;
     }, {});
 }
+function $convertToArray(convertToItem, _readonly) {
+    return (value) => (typeof value === "undefined"
+        ? Either.of([])
+        : Either.sequence(value.map(convertToItem)));
+}
+function $convertToIdentifier(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(value) {
+    switch (typeof value) {
+        case "object":
+            return Either.of(value);
+        case "string":
+            return Either.of(dataFactory.namedNode(value));
+    }
+}
+function $convertToLiteral(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 (value) => {
+        switch (typeof value) {
+            case "object": {
+                if (Maybe.isMaybe(value)) {
+                    return Either.of(value);
+                }
+                break;
+            }
+            case "undefined":
+                return Either.of(Maybe.empty());
+        }
+        return convertToItem(value).map(Maybe.of);
+    };
+}
+function $convertWithDefaultValue(convertToItem, defaultValue) {
+    return (value) => {
+        if (typeof value === "undefined") {
+            return convertToItem(defaultValue);
+        }
+        return convertToItem(value);
+    };
+}
 export var $EqualsResult;
 (function ($EqualsResult) {
     $EqualsResult.Equal = Right(true);
@@ -186,20 +259,11 @@ 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 $identityConversionFunction(value) {
+    return Either.of(value);
 }
-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");
+function $identityValidationFunction(_schema, value) {
+    return Either.of(value);
 }
 const $literalFactory = new LiteralFactory({ dataFactory: dataFactory });
 const $parseIdentifier = NTriplesIdentifier.parser(dataFactory);
@@ -275,6 +339,19 @@ function $shaclPropertyFromRdf({ graph, propertySchema, resource, typeFromRdf, }
 function $strictEquals(left, right) {
     return $EqualsResult.fromBooleanEqualsResult(left, right, left === right);
 }
+function $validateArray(validateItem, _readonly) {
+    return (schema, valueArray) => {
+        if (schema.minCount !== undefined && valueArray.length < schema.minCount) {
+            return Left(new Error(`value array has length (${valueArray.length}) less than minCount (${schema.minCount})`));
+        }
+        return Either.sequence(valueArray.map((value) => validateItem(schema.item(), value)));
+    };
+}
+function $validateMaybe(validateItem) {
+    return (schema, valueMaybe) => valueMaybe
+        .map((value) => validateItem(schema.item(), value).map(() => valueMaybe))
+        .orDefault(Either.of(valueMaybe));
+}
 function $wrap_FromRdfResourceFunction(_fromRdfResourceFunction) {
     return (resource, options) => {
         let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages, } = options ?? {};
@@ -313,655 +390,57 @@ 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();
-        }
-        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 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;
-        }
-        const $object = {
-            $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,
-        };
-        if (!globalThis.Object.prototype.hasOwnProperty.call($object, "toString")) {
-            $object.toString = $toString;
-        }
-        return $object;
+        return $sequenceRecord({
+            $identifier: $convertToIdentifierProperty(parameters.$identifier),
+            and: $convertToMaybe($convertToArray($convertToIdentifier, true))(parameters.and).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.and.type(), value)),
+            classes: $convertToArray(($convertToIri), true)(parameters.classes).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.classes.type(), value)),
+            comment: $convertToMaybe($identityConversionFunction)(parameters.comment).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.comment.type(), value)),
+            datatype: $convertToMaybe(($convertToIri))(parameters.datatype).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.datatype.type(), value)),
+            deactivated: $convertToMaybe($identityConversionFunction)(parameters.deactivated).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.deactivated.type(), value)),
+            defaultValue: $convertToMaybe($identityConversionFunction)(parameters.defaultValue).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.defaultValue.type(), value)),
+            description: $convertToMaybe($identityConversionFunction)(parameters.description).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.description.type(), value)),
+            display: $convertWithDefaultValue($identityConversionFunction, false)(parameters.display),
+            flags: $convertToArray($identityConversionFunction, true)(parameters.flags).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.flags.type(), value)),
+            groups: $convertToArray($convertToIdentifier, true)(parameters.groups).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.groups.type(), value)),
+            hasValues: $convertToArray($identityConversionFunction, true)(parameters.hasValues).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.hasValues.type(), value)),
+            in_: $convertToMaybe($convertToArray($identityConversionFunction, true))(parameters.in_).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.in_.type(), value)),
+            isDefinedBy: $convertToMaybe($convertToIdentifier)(parameters.isDefinedBy).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.isDefinedBy.type(), value)),
+            label: $convertToMaybe($identityConversionFunction)(parameters.label).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.label.type(), value)),
+            languageIn: $convertToMaybe($convertToArray($identityConversionFunction, true))(parameters.languageIn).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.languageIn.type(), value)),
+            maxCount: $convertToMaybe($identityConversionFunction)(parameters.maxCount).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxCount.type(), value)),
+            maxExclusive: $convertToMaybe($convertToLiteral)(parameters.maxExclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxExclusive.type(), value)),
+            maxInclusive: $convertToMaybe($convertToLiteral)(parameters.maxInclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxInclusive.type(), value)),
+            maxLength: $convertToMaybe($identityConversionFunction)(parameters.maxLength).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxLength.type(), value)),
+            minCount: $convertToMaybe($identityConversionFunction)(parameters.minCount).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minCount.type(), value)),
+            minExclusive: $convertToMaybe($convertToLiteral)(parameters.minExclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minExclusive.type(), value)),
+            minInclusive: $convertToMaybe($convertToLiteral)(parameters.minInclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minInclusive.type(), value)),
+            minLength: $convertToMaybe($identityConversionFunction)(parameters.minLength).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minLength.type(), value)),
+            mutable: $convertToMaybe($identityConversionFunction)(parameters.mutable).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.mutable.type(), value)),
+            name: $convertToMaybe($identityConversionFunction)(parameters.name).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.name.type(), value)),
+            node: $convertToMaybe($convertToIdentifier)(parameters.node).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.node.type(), value)),
+            nodeKind: $convertToMaybe(($convertToIri))(parameters.nodeKind).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.nodeKind.type(), value)),
+            not: $convertToArray($convertToIdentifier, true)(parameters.not).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.not.type(), value)),
+            or: $convertToMaybe($convertToArray($convertToIdentifier, true))(parameters.or).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.or.type(), value)),
+            order: $convertToMaybe($identityConversionFunction)(parameters.order).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.order.type(), value)),
+            path: Either.of(parameters.path),
+            patterns: $convertToArray($identityConversionFunction, true)(parameters.patterns).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.patterns.type(), value)),
+            resolve: $convertToMaybe($convertToIdentifier)(parameters.resolve).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.resolve.type(), value)),
+            shaclmateName: $convertToMaybe($identityConversionFunction)(parameters.shaclmateName).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.shaclmateName.type(), value)),
+            uniqueLang: $convertToMaybe($identityConversionFunction)(parameters.uniqueLang).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.uniqueLang.type(), value)),
+            xone: $convertToMaybe($convertToArray($convertToIdentifier, true))(parameters.xone).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.xone.type(), value)),
+        }).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;
@@ -1735,7 +1214,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
@@ -1828,7 +1307,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"),
             },
@@ -2298,58 +1777,23 @@ export var PropertyShape;
 export var PropertyGroup;
 (function (PropertyGroup) {
     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 = "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;
-        }
-        const $object = { $identifier, $type, comment, label };
-        if (!globalThis.Object.prototype.hasOwnProperty.call($object, "toString")) {
-            $object.toString = $toString;
-        }
-        return $object;
+        return $sequenceRecord({
+            $identifier: $convertToIdentifierProperty(parameters?.$identifier),
+            comment: $convertToMaybe($identityConversionFunction)(parameters?.comment).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.comment.type(), value)),
+            label: $convertToMaybe($identityConversionFunction)(parameters?.label).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.label.type(), value)),
+        }).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;
@@ -2429,7 +1873,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
@@ -2504,102 +1948,23 @@ export var 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;
-        }
-        const $object = {
-            $identifier,
-            $type,
-            comment,
-            label,
-            tsFeatureExcludes,
-            tsFeatureIncludes,
-            tsImports,
-        };
-        if (!globalThis.Object.prototype.hasOwnProperty.call($object, "toString")) {
-            $object.toString = $toString;
-        }
-        return $object;
+        return $sequenceRecord({
+            $identifier: $convertToIdentifierProperty(parameters?.$identifier),
+            comment: $convertToMaybe($identityConversionFunction)(parameters?.comment).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.comment.type(), value)),
+            label: $convertToMaybe($identityConversionFunction)(parameters?.label).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.label.type(), value)),
+        }).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;
@@ -2618,18 +1983,6 @@ export var Ontology;
             !$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;
@@ -2691,69 +2044,7 @@ export var Ontology;
                         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)));
+        }).chain((properties) => create(properties)));
     };
     Ontology.fromRdfResource = $wrap_FromRdfResourceFunction(Ontology._fromRdfResource);
     Ontology.fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
@@ -2798,58 +2089,6 @@ export var Ontology;
                 }),
                 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) => {
@@ -2862,11 +2101,6 @@ export var Ontology;
         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);
@@ -2885,713 +2119,59 @@ export var 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));
-        }
-        else {
-            types = parameters?.types;
-        }
-        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;
-        }
-        const $object = {
-            $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,
-        };
-        if (!globalThis.Object.prototype.hasOwnProperty.call($object, "toString")) {
-            $object.toString = $toString;
-        }
-        return $object;
+        return $sequenceRecord({
+            $identifier: $convertToIdentifierProperty(parameters?.$identifier),
+            and: $convertToMaybe($convertToArray($convertToIdentifier, true))(parameters?.and).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.and.type(), value)),
+            classes: $convertToArray(($convertToIri), true)(parameters?.classes).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.classes.type(), value)),
+            closed: $convertToMaybe($identityConversionFunction)(parameters?.closed).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.closed.type(), value)),
+            comment: $convertToMaybe($identityConversionFunction)(parameters?.comment).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.comment.type(), value)),
+            datatype: $convertToMaybe(($convertToIri))(parameters?.datatype).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.datatype.type(), value)),
+            deactivated: $convertToMaybe($identityConversionFunction)(parameters?.deactivated).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.deactivated.type(), value)),
+            discriminantValue: $convertToMaybe($identityConversionFunction)(parameters?.discriminantValue).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.discriminantValue.type(), value)),
+            extern: $convertToMaybe($identityConversionFunction)(parameters?.extern).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.extern.type(), value)),
+            flags: $convertToArray($identityConversionFunction, true)(parameters?.flags).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.flags.type(), value)),
+            fromRdfType: $convertToMaybe(($convertToIri))(parameters?.fromRdfType).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.fromRdfType.type(), value)),
+            hasValues: $convertToArray($identityConversionFunction, true)(parameters?.hasValues).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.hasValues.type(), value)),
+            ignoredProperties: $convertToMaybe($convertToArray(($convertToIri), true))(parameters?.ignoredProperties).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.ignoredProperties.type(), value)),
+            in_: $convertToMaybe($convertToArray($identityConversionFunction, true))(parameters?.in_).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.in_.type(), value)),
+            isDefinedBy: $convertToMaybe($convertToIdentifier)(parameters?.isDefinedBy).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.isDefinedBy.type(), value)),
+            label: $convertToMaybe($identityConversionFunction)(parameters?.label).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.label.type(), value)),
+            languageIn: $convertToMaybe($convertToArray($identityConversionFunction, true))(parameters?.languageIn).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.languageIn.type(), value)),
+            maxCount: $convertToMaybe($identityConversionFunction)(parameters?.maxCount).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxCount.type(), value)),
+            maxExclusive: $convertToMaybe($convertToLiteral)(parameters?.maxExclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxExclusive.type(), value)),
+            maxInclusive: $convertToMaybe($convertToLiteral)(parameters?.maxInclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxInclusive.type(), value)),
+            maxLength: $convertToMaybe($identityConversionFunction)(parameters?.maxLength).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxLength.type(), value)),
+            minCount: $convertToMaybe($identityConversionFunction)(parameters?.minCount).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minCount.type(), value)),
+            minExclusive: $convertToMaybe($convertToLiteral)(parameters?.minExclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minExclusive.type(), value)),
+            minInclusive: $convertToMaybe($convertToLiteral)(parameters?.minInclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minInclusive.type(), value)),
+            minLength: $convertToMaybe($identityConversionFunction)(parameters?.minLength).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minLength.type(), value)),
+            mutable: $convertToMaybe($identityConversionFunction)(parameters?.mutable).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.mutable.type(), value)),
+            node: $convertToMaybe($convertToIdentifier)(parameters?.node).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.node.type(), value)),
+            nodeKind: $convertToMaybe(($convertToIri))(parameters?.nodeKind).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.nodeKind.type(), value)),
+            not: $convertToArray($convertToIdentifier, true)(parameters?.not).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.not.type(), value)),
+            or: $convertToMaybe($convertToArray($convertToIdentifier, true))(parameters?.or).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.or.type(), value)),
+            patterns: $convertToArray($identityConversionFunction, true)(parameters?.patterns).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.patterns.type(), value)),
+            properties: $convertToArray($convertToIdentifier, true)(parameters?.properties).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.properties.type(), value)),
+            rdfType: $convertToMaybe(($convertToIri))(parameters?.rdfType).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.rdfType.type(), value)),
+            shaclmateName: $convertToMaybe($identityConversionFunction)(parameters?.shaclmateName).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.shaclmateName.type(), value)),
+            subClassOf: $convertToArray(($convertToIri), true)(parameters?.subClassOf).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.subClassOf.type(), value)),
+            toRdfTypes: $convertToArray(($convertToIri), true)(parameters?.toRdfTypes).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.toRdfTypes.type(), value)),
+            tsImports: $convertToArray($identityConversionFunction, true)(parameters?.tsImports).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.tsImports.type(), value)),
+            types: $convertToArray(($convertToIri), true)(parameters?.types).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.types.type(), value)),
+            xone: $convertToMaybe($convertToArray($convertToIdentifier, true))(parameters?.xone).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.xone.type(), value)),
+        }).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;
@@ -3742,14 +2322,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;
@@ -4350,54 +2922,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,
@@ -4408,7 +2932,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,
                 })),
             }),
@@ -4445,7 +2969,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
@@ -4779,50 +3303,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: () => ({
@@ -5038,8 +3518,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);