@shaclmate/shacl-ast 4.0.32 → 4.0.34

package/dist/generated.js

@@ -15,6 +15,93 @@ function $compactRecord(record) {
         return definedProperties;
     }, {});
 }
+function $convertToBoolean(_schema, value) {
+    return Either.of(value);
+}
+function $convertToIdentifier(_schema, value) {
+    switch (typeof value) {
+        case "object":
+            return Either.of(value);
+        case "string":
+            return Either.of(dataFactory.namedNode(value));
+        case "undefined":
+            return Either.of(dataFactory.blankNode());
+    }
+}
+function $convertToIdentifierProperty(identifier) {
+    switch (typeof identifier) {
+        case "function":
+            return Either.of(identifier);
+        case "object": {
+            const captureIdentifier = identifier;
+            return Either.of(() => captureIdentifier);
+        }
+        case "string": {
+            const captureIdentifier = dataFactory.namedNode(identifier);
+            return Either.of(() => captureIdentifier);
+        }
+        case "undefined": {
+            const captureIdentifier = dataFactory.blankNode();
+            return Either.of(() => captureIdentifier);
+        }
+    }
+}
+function $convertToIri(_schema, value) {
+    switch (typeof value) {
+        case "object":
+            return Either.of(value);
+        case "string":
+            return Either.of(dataFactory.namedNode(value));
+    }
+}
+function $convertToLiteral(_schema, value) {
+    if (typeof value === "object") {
+        if (value instanceof Date) {
+            return Either.of($literalFactory.date(value));
+        }
+        return Either.of(value);
+    }
+    return Either.of($literalFactory.primitive(value));
+}
+function $convertToMaybe(convertToItem) {
+    return (schema, value) => {
+        switch (typeof value) {
+            case "object": {
+                if (Maybe.isMaybe(value)) {
+                    return Either.of(value);
+                }
+                break;
+            }
+            case "undefined":
+                return Either.of(Maybe.empty());
+        }
+        return convertToItem(schema.item(), value).map(Maybe.of);
+    };
+}
+function $convertToNumeric(_schema, value) {
+    return Either.of(value);
+}
+function $convertToObject(_schema, value) {
+    return Either.of(value);
+}
+function $convertToReadonlyArray(convertToItem) {
+    return (schema, value) => {
+        return (typeof value === "undefined"
+            ? Either.of([])
+            : Either.sequence(value.map((item) => convertToItem(schema.item(), item)))).chain((array) => {
+            if (schema.minCount !== undefined && array.length < schema.minCount) {
+                return Left(new Error(`array has length (${array.length}) less than minCount (${schema.minCount})`));
+            }
+            return Either.of(array);
+        });
+    };
+}
+function $convertToString(_schema, value) {
+    return Either.of(value);
+}
+function $convertToTerm(_schema, value) {
+    return Either.of(value);
+}
 function $filterArray(filterItem) {
     return (filter, values) => {
         for (const value of values) {
@@ -172,21 +259,6 @@ class $IdentifierSet {
         }
     }
 }
-function $isReadonlyBigIntArray(x) {
-    return Array.isArray(x) && x.every((z) => typeof z === "bigint");
-}
-function $isReadonlyBooleanArray(x) {
-    return Array.isArray(x) && x.every((z) => typeof z === "boolean");
-}
-function $isReadonlyNumberArray(x) {
-    return Array.isArray(x) && x.every((z) => typeof z === "number");
-}
-function $isReadonlyObjectArray(x) {
-    return Array.isArray(x) && x.every((z) => typeof z === "object");
-}
-function $isReadonlyStringArray(x) {
-    return Array.isArray(x) && x.every((z) => typeof z === "string");
-}
 const $literalFactory = new LiteralFactory({ dataFactory: dataFactory });
 const $parseIdentifier = NTriplesIdentifier.parser(dataFactory);
 export var $PropertyPath;
@@ -293,595 +365,53 @@ 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 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 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 uniqueLang;
-        if (Maybe.isMaybe(parameters.uniqueLang)) {
-            uniqueLang = parameters.uniqueLang;
-        }
-        else if (typeof parameters.uniqueLang === "boolean") {
-            uniqueLang = Maybe.of(parameters.uniqueLang);
-        }
-        else if (parameters.uniqueLang === undefined) {
-            uniqueLang = Maybe.empty();
-        }
-        else {
-            uniqueLang = parameters.uniqueLang;
-        }
-        let xone;
-        if (Maybe.isMaybe(parameters.xone)) {
-            xone = parameters.xone;
-        }
-        else if ($isReadonlyObjectArray(parameters.xone)) {
-            xone = Maybe.of(parameters.xone);
-        }
-        else if ($isReadonlyStringArray(parameters.xone)) {
-            xone = Maybe.of(parameters.xone.map((item) => dataFactory.namedNode(item)));
-        }
-        else if (parameters.xone === undefined) {
-            xone = Maybe.empty();
-        }
-        else {
-            xone = parameters.xone;
-        }
-        return {
-            $identifier,
-            $type,
-            and,
-            classes,
-            comment,
-            datatype,
-            deactivated,
-            defaultValue,
-            description,
-            flags,
-            groups,
-            hasValues,
-            in_,
-            isDefinedBy,
-            label,
-            languageIn,
-            maxCount,
-            maxExclusive,
-            maxInclusive,
-            maxLength,
-            minCount,
-            minExclusive,
-            minInclusive,
-            minLength,
-            name,
-            node,
-            nodeKind,
-            not,
-            or,
-            order,
-            path,
-            patterns,
-            uniqueLang,
-            xone,
-        };
+        return $sequenceRecord({
+            $identifier: $convertToIdentifierProperty(parameters.$identifier),
+            and: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(PropertyShape.schema.properties.and.type(), parameters.and),
+            classes: $convertToReadonlyArray(($convertToIri))(PropertyShape.schema.properties.classes.type(), parameters.classes),
+            comment: $convertToMaybe(($convertToString))(PropertyShape.schema.properties.comment.type(), parameters.comment),
+            datatype: $convertToMaybe(($convertToIri))(PropertyShape.schema.properties.datatype.type(), parameters.datatype),
+            deactivated: $convertToMaybe(($convertToBoolean))(PropertyShape.schema.properties.deactivated.type(), parameters.deactivated),
+            defaultValue: $convertToMaybe(($convertToTerm))(PropertyShape.schema.properties.defaultValue.type(), parameters.defaultValue),
+            description: $convertToMaybe(($convertToString))(PropertyShape.schema.properties.description.type(), parameters.description),
+            flags: $convertToReadonlyArray(($convertToString))(PropertyShape.schema.properties.flags.type(), parameters.flags),
+            groups: $convertToReadonlyArray($convertToIdentifier)(PropertyShape.schema.properties.groups.type(), parameters.groups),
+            hasValues: $convertToReadonlyArray(($convertToTerm))(PropertyShape.schema.properties.hasValues.type(), parameters.hasValues),
+            in_: $convertToMaybe($convertToReadonlyArray(($convertToTerm)))(PropertyShape.schema.properties.in_.type(), parameters.in_),
+            isDefinedBy: $convertToMaybe($convertToIdentifier)(PropertyShape.schema.properties.isDefinedBy.type(), parameters.isDefinedBy),
+            label: $convertToMaybe(($convertToString))(PropertyShape.schema.properties.label.type(), parameters.label),
+            languageIn: $convertToMaybe($convertToReadonlyArray(($convertToString)))(PropertyShape.schema.properties.languageIn.type(), parameters.languageIn),
+            maxCount: $convertToMaybe(($convertToNumeric))(PropertyShape.schema.properties.maxCount.type(), parameters.maxCount),
+            maxExclusive: $convertToMaybe($convertToLiteral)(PropertyShape.schema.properties.maxExclusive.type(), parameters.maxExclusive),
+            maxInclusive: $convertToMaybe($convertToLiteral)(PropertyShape.schema.properties.maxInclusive.type(), parameters.maxInclusive),
+            maxLength: $convertToMaybe(($convertToNumeric))(PropertyShape.schema.properties.maxLength.type(), parameters.maxLength),
+            minCount: $convertToMaybe(($convertToNumeric))(PropertyShape.schema.properties.minCount.type(), parameters.minCount),
+            minExclusive: $convertToMaybe($convertToLiteral)(PropertyShape.schema.properties.minExclusive.type(), parameters.minExclusive),
+            minInclusive: $convertToMaybe($convertToLiteral)(PropertyShape.schema.properties.minInclusive.type(), parameters.minInclusive),
+            minLength: $convertToMaybe(($convertToNumeric))(PropertyShape.schema.properties.minLength.type(), parameters.minLength),
+            name: $convertToMaybe(($convertToString))(PropertyShape.schema.properties.name.type(), parameters.name),
+            node: $convertToMaybe($convertToIdentifier)(PropertyShape.schema.properties.node.type(), parameters.node),
+            nodeKind: $convertToMaybe(($convertToIri))(PropertyShape.schema.properties.nodeKind.type(), parameters.nodeKind),
+            not: $convertToReadonlyArray($convertToIdentifier)(PropertyShape.schema.properties.not.type(), parameters.not),
+            or: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(PropertyShape.schema.properties.or.type(), parameters.or),
+            order: $convertToMaybe(($convertToNumeric))(PropertyShape.schema.properties.order.type(), parameters.order),
+            path: $convertToObject(PropertyShape.schema.properties.path.type(), parameters.path),
+            patterns: $convertToReadonlyArray(($convertToString))(PropertyShape.schema.properties.patterns.type(), parameters.patterns),
+            uniqueLang: $convertToMaybe(($convertToBoolean))(PropertyShape.schema.properties.uniqueLang.type(), parameters.uniqueLang),
+            xone: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(PropertyShape.schema.properties.xone.type(), parameters.xone),
+        }).map((properties) => {
+            const finalObject = { ...properties, $type: "PropertyShape" };
+            if (!globalThis.Object.prototype.hasOwnProperty.call(finalObject, "toString")) {
+                finalObject.toString = $toString;
+            }
+            return finalObject;
+        });
     }
     PropertyShape.create = create;
+    function createUnsafe(parameters) {
+        return create(parameters).unsafeCoerce();
+    }
+    PropertyShape.createUnsafe = createUnsafe;
     let Identifier;
     (function (Identifier) {
         Identifier.parse = $parseIdentifier;
@@ -1581,7 +1111,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
@@ -2094,54 +1624,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;
-        }
-        return { $identifier, $type, comment, label };
+        return $sequenceRecord({
+            $identifier: $convertToIdentifierProperty(parameters?.$identifier),
+            comment: $convertToMaybe(($convertToString))(PropertyGroup.schema.properties.comment.type(), parameters?.comment),
+            label: $convertToMaybe(($convertToString))(PropertyGroup.schema.properties.label.type(), parameters?.label),
+        }).map((properties) => {
+            const finalObject = { ...properties, $type: "PropertyGroup" };
+            if (!globalThis.Object.prototype.hasOwnProperty.call(finalObject, "toString")) {
+                finalObject.toString = $toString;
+            }
+            return finalObject;
+        });
     }
     PropertyGroup.create = create;
+    function createUnsafe(parameters) {
+        return create(parameters).unsafeCoerce();
+    }
+    PropertyGroup.createUnsafe = createUnsafe;
     let Identifier;
     (function (Identifier) {
         Identifier.parse = $parseIdentifier;
@@ -2221,7 +1720,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
@@ -2296,54 +1795,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;
-        }
-        return { $identifier, $type, comment, label };
+        return $sequenceRecord({
+            $identifier: $convertToIdentifierProperty(parameters?.$identifier),
+            comment: $convertToMaybe(($convertToString))(Ontology.schema.properties.comment.type(), parameters?.comment),
+            label: $convertToMaybe(($convertToString))(Ontology.schema.properties.label.type(), parameters?.label),
+        }).map((properties) => {
+            const finalObject = { ...properties, $type: "Ontology" };
+            if (!globalThis.Object.prototype.hasOwnProperty.call(finalObject, "toString")) {
+                finalObject.toString = $toString;
+            }
+            return finalObject;
+        });
     }
     Ontology.create = create;
+    function createUnsafe(parameters) {
+        return create(parameters).unsafeCoerce();
+    }
+    Ontology.createUnsafe = createUnsafe;
     let Identifier;
     (function (Identifier) {
         Identifier.parse = $parseIdentifier;
@@ -2423,7 +1891,7 @@ export var Ontology;
                         value: Maybe.empty(),
                     })),
             }),
-        }).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
@@ -2498,566 +1966,51 @@ 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 flags;
-        if (parameters?.flags === undefined) {
-            flags = [];
-        }
-        else if (typeof parameters?.flags === "object") {
-            flags = parameters?.flags;
-        }
-        else {
-            flags = parameters?.flags;
-        }
-        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 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 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 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;
-        }
-        return {
-            $identifier,
-            $type,
-            and,
-            classes,
-            closed,
-            comment,
-            datatype,
-            deactivated,
-            flags,
-            hasValues,
-            ignoredProperties,
-            in_,
-            isDefinedBy,
-            label,
-            languageIn,
-            maxCount,
-            maxExclusive,
-            maxInclusive,
-            maxLength,
-            minCount,
-            minExclusive,
-            minInclusive,
-            minLength,
-            node,
-            nodeKind,
-            not,
-            or,
-            patterns,
-            properties,
-            subClassOf,
-            types,
-            xone,
-        };
+        return $sequenceRecord({
+            $identifier: $convertToIdentifierProperty(parameters?.$identifier),
+            and: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(NodeShape.schema.properties.and.type(), parameters?.and),
+            classes: $convertToReadonlyArray(($convertToIri))(NodeShape.schema.properties.classes.type(), parameters?.classes),
+            closed: $convertToMaybe(($convertToBoolean))(NodeShape.schema.properties.closed.type(), parameters?.closed),
+            comment: $convertToMaybe(($convertToString))(NodeShape.schema.properties.comment.type(), parameters?.comment),
+            datatype: $convertToMaybe(($convertToIri))(NodeShape.schema.properties.datatype.type(), parameters?.datatype),
+            deactivated: $convertToMaybe(($convertToBoolean))(NodeShape.schema.properties.deactivated.type(), parameters?.deactivated),
+            flags: $convertToReadonlyArray(($convertToString))(NodeShape.schema.properties.flags.type(), parameters?.flags),
+            hasValues: $convertToReadonlyArray(($convertToTerm))(NodeShape.schema.properties.hasValues.type(), parameters?.hasValues),
+            ignoredProperties: $convertToMaybe($convertToReadonlyArray(($convertToIri)))(NodeShape.schema.properties.ignoredProperties.type(), parameters?.ignoredProperties),
+            in_: $convertToMaybe($convertToReadonlyArray(($convertToTerm)))(NodeShape.schema.properties.in_.type(), parameters?.in_),
+            isDefinedBy: $convertToMaybe($convertToIdentifier)(NodeShape.schema.properties.isDefinedBy.type(), parameters?.isDefinedBy),
+            label: $convertToMaybe(($convertToString))(NodeShape.schema.properties.label.type(), parameters?.label),
+            languageIn: $convertToMaybe($convertToReadonlyArray(($convertToString)))(NodeShape.schema.properties.languageIn.type(), parameters?.languageIn),
+            maxCount: $convertToMaybe(($convertToNumeric))(NodeShape.schema.properties.maxCount.type(), parameters?.maxCount),
+            maxExclusive: $convertToMaybe($convertToLiteral)(NodeShape.schema.properties.maxExclusive.type(), parameters?.maxExclusive),
+            maxInclusive: $convertToMaybe($convertToLiteral)(NodeShape.schema.properties.maxInclusive.type(), parameters?.maxInclusive),
+            maxLength: $convertToMaybe(($convertToNumeric))(NodeShape.schema.properties.maxLength.type(), parameters?.maxLength),
+            minCount: $convertToMaybe(($convertToNumeric))(NodeShape.schema.properties.minCount.type(), parameters?.minCount),
+            minExclusive: $convertToMaybe($convertToLiteral)(NodeShape.schema.properties.minExclusive.type(), parameters?.minExclusive),
+            minInclusive: $convertToMaybe($convertToLiteral)(NodeShape.schema.properties.minInclusive.type(), parameters?.minInclusive),
+            minLength: $convertToMaybe(($convertToNumeric))(NodeShape.schema.properties.minLength.type(), parameters?.minLength),
+            node: $convertToMaybe($convertToIdentifier)(NodeShape.schema.properties.node.type(), parameters?.node),
+            nodeKind: $convertToMaybe(($convertToIri))(NodeShape.schema.properties.nodeKind.type(), parameters?.nodeKind),
+            not: $convertToReadonlyArray($convertToIdentifier)(NodeShape.schema.properties.not.type(), parameters?.not),
+            or: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(NodeShape.schema.properties.or.type(), parameters?.or),
+            patterns: $convertToReadonlyArray(($convertToString))(NodeShape.schema.properties.patterns.type(), parameters?.patterns),
+            properties: $convertToReadonlyArray($convertToIdentifier)(NodeShape.schema.properties.properties.type(), parameters?.properties),
+            subClassOf: $convertToReadonlyArray(($convertToIri))(NodeShape.schema.properties.subClassOf.type(), parameters?.subClassOf),
+            types: $convertToReadonlyArray(($convertToIri))(NodeShape.schema.properties.types.type(), parameters?.types),
+            xone: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(NodeShape.schema.properties.xone.type(), parameters?.xone),
+        }).map((properties) => {
+            const finalObject = { ...properties, $type: "NodeShape" };
+            if (!globalThis.Object.prototype.hasOwnProperty.call(finalObject, "toString")) {
+                finalObject.toString = $toString;
+            }
+            return finalObject;
+        });
     }
     NodeShape.create = create;
+    function createUnsafe(parameters) {
+        return create(parameters).unsafeCoerce();
+    }
+    NodeShape.createUnsafe = createUnsafe;
     let Identifier;
     (function (Identifier) {
         Identifier.parse = $parseIdentifier;
@@ -3710,7 +2663,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