@shaclmate/compiler 4.0.34 → 4.0.35

package/dist/input/generated.js

@@ -15,10 +15,12 @@ function $compactRecord(record) {
         return definedProperties;
     }, {});
 }
-function $convertToBoolean(_schema, value) {
-    return Either.of(value);
+function $convertToArray(convertToItem, _readonly) {
+    return (value) => (typeof value === "undefined"
+        ? Either.of([])
+        : Either.sequence(value.map(convertToItem)));
 }
-function $convertToIdentifier(_schema, value) {
+function $convertToIdentifier(value) {
     switch (typeof value) {
         case "object":
             return Either.of(value);
@@ -46,7 +48,7 @@ function $convertToIdentifierProperty(identifier) {
         }
     }
 }
-function $convertToIri(_schema, value) {
+function $convertToIri(value) {
     switch (typeof value) {
         case "object":
             return Either.of(value);
@@ -54,7 +56,7 @@ function $convertToIri(_schema, value) {
             return Either.of(dataFactory.namedNode(value));
     }
 }
-function $convertToLiteral(_schema, value) {
+function $convertToLiteral(value) {
     if (typeof value === "object") {
         if (value instanceof Date) {
             return Either.of($literalFactory.date(value));
@@ -64,7 +66,7 @@ function $convertToLiteral(_schema, value) {
     return Either.of($literalFactory.primitive(value));
 }
 function $convertToMaybe(convertToItem) {
-    return (schema, value) => {
+    return (value) => {
         switch (typeof value) {
             case "object": {
                 if (Maybe.isMaybe(value)) {
@@ -75,39 +77,15 @@ function $convertToMaybe(convertToItem) {
             case "undefined":
                 return Either.of(Maybe.empty());
         }
-        return convertToItem(schema.item(), value).map(Maybe.of);
+        return convertToItem(value).map(Maybe.of);
     };
 }
-function $convertToNumeric(_schema, value) {
-    return Either.of(value);
-}
-function $convertToObject(_schema, value) {
-    return Either.of(value);
-}
-function $convertToReadonlyArray(convertToItem) {
-    return (schema, value) => {
-        return (typeof value === "undefined"
-            ? Either.of([])
-            : Either.sequence(value.map((item) => convertToItem(schema.item(), item)))).chain((array) => {
-            if (schema.minCount !== undefined && array.length < schema.minCount) {
-                return Left(new Error(`array has length (${array.length}) less than minCount (${schema.minCount})`));
-            }
-            return Either.of(array);
-        });
-    };
-}
-function $convertToString(_schema, value) {
-    return Either.of(value);
-}
-function $convertToTerm(_schema, value) {
-    return Either.of(value);
-}
-function $convertWithDefaultValue(convertToItem) {
-    return (schema, value) => {
+function $convertWithDefaultValue(convertToItem, defaultValue) {
+    return (value) => {
         if (typeof value === "undefined") {
-            return convertToItem(schema.item(), schema.defaultValue);
+            return convertToItem(defaultValue);
         }
-        return convertToItem(schema.item(), value);
+        return convertToItem(value);
     };
 }
 export var $EqualsResult;
@@ -281,6 +259,12 @@ class $IdentifierSet {
         }
     }
 }
+function $identityConversionFunction(value) {
+    return Either.of(value);
+}
+function $identityValidationFunction(_schema, value) {
+    return Either.of(value);
+}
 const $literalFactory = new LiteralFactory({ dataFactory: dataFactory });
 const $parseIdentifier = NTriplesIdentifier.parser(dataFactory);
 export var $PropertyPath;
@@ -355,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 ?? {};
@@ -395,42 +392,42 @@ export var PropertyShape;
     function create(parameters) {
         return $sequenceRecord({
             $identifier: $convertToIdentifierProperty(parameters.$identifier),
-            and: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(PropertyShape.schema.properties.and.type(), parameters.and),
-            classes: $convertToReadonlyArray(($convertToIri))(PropertyShape.schema.properties.classes.type(), parameters.classes),
-            comment: $convertToMaybe(($convertToString))(PropertyShape.schema.properties.comment.type(), parameters.comment),
-            datatype: $convertToMaybe(($convertToIri))(PropertyShape.schema.properties.datatype.type(), parameters.datatype),
-            deactivated: $convertToMaybe(($convertToBoolean))(PropertyShape.schema.properties.deactivated.type(), parameters.deactivated),
-            defaultValue: $convertToMaybe(($convertToTerm))(PropertyShape.schema.properties.defaultValue.type(), parameters.defaultValue),
-            description: $convertToMaybe(($convertToString))(PropertyShape.schema.properties.description.type(), parameters.description),
-            display: $convertWithDefaultValue(($convertToBoolean))(PropertyShape.schema.properties.display.type(), parameters.display),
-            flags: $convertToReadonlyArray(($convertToString))(PropertyShape.schema.properties.flags.type(), parameters.flags),
-            groups: $convertToReadonlyArray($convertToIdentifier)(PropertyShape.schema.properties.groups.type(), parameters.groups),
-            hasValues: $convertToReadonlyArray(($convertToTerm))(PropertyShape.schema.properties.hasValues.type(), parameters.hasValues),
-            in_: $convertToMaybe($convertToReadonlyArray(($convertToTerm)))(PropertyShape.schema.properties.in_.type(), parameters.in_),
-            isDefinedBy: $convertToMaybe($convertToIdentifier)(PropertyShape.schema.properties.isDefinedBy.type(), parameters.isDefinedBy),
-            label: $convertToMaybe(($convertToString))(PropertyShape.schema.properties.label.type(), parameters.label),
-            languageIn: $convertToMaybe($convertToReadonlyArray(($convertToString)))(PropertyShape.schema.properties.languageIn.type(), parameters.languageIn),
-            maxCount: $convertToMaybe(($convertToNumeric))(PropertyShape.schema.properties.maxCount.type(), parameters.maxCount),
-            maxExclusive: $convertToMaybe($convertToLiteral)(PropertyShape.schema.properties.maxExclusive.type(), parameters.maxExclusive),
-            maxInclusive: $convertToMaybe($convertToLiteral)(PropertyShape.schema.properties.maxInclusive.type(), parameters.maxInclusive),
-            maxLength: $convertToMaybe(($convertToNumeric))(PropertyShape.schema.properties.maxLength.type(), parameters.maxLength),
-            minCount: $convertToMaybe(($convertToNumeric))(PropertyShape.schema.properties.minCount.type(), parameters.minCount),
-            minExclusive: $convertToMaybe($convertToLiteral)(PropertyShape.schema.properties.minExclusive.type(), parameters.minExclusive),
-            minInclusive: $convertToMaybe($convertToLiteral)(PropertyShape.schema.properties.minInclusive.type(), parameters.minInclusive),
-            minLength: $convertToMaybe(($convertToNumeric))(PropertyShape.schema.properties.minLength.type(), parameters.minLength),
-            mutable: $convertToMaybe(($convertToBoolean))(PropertyShape.schema.properties.mutable.type(), parameters.mutable),
-            name: $convertToMaybe(($convertToString))(PropertyShape.schema.properties.name.type(), parameters.name),
-            node: $convertToMaybe($convertToIdentifier)(PropertyShape.schema.properties.node.type(), parameters.node),
-            nodeKind: $convertToMaybe(($convertToIri))(PropertyShape.schema.properties.nodeKind.type(), parameters.nodeKind),
-            not: $convertToReadonlyArray($convertToIdentifier)(PropertyShape.schema.properties.not.type(), parameters.not),
-            or: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(PropertyShape.schema.properties.or.type(), parameters.or),
-            order: $convertToMaybe(($convertToNumeric))(PropertyShape.schema.properties.order.type(), parameters.order),
-            path: $convertToObject(PropertyShape.schema.properties.path.type(), parameters.path),
-            patterns: $convertToReadonlyArray(($convertToString))(PropertyShape.schema.properties.patterns.type(), parameters.patterns),
-            resolve: $convertToMaybe($convertToIdentifier)(PropertyShape.schema.properties.resolve.type(), parameters.resolve),
-            shaclmateName: $convertToMaybe(($convertToString))(PropertyShape.schema.properties.shaclmateName.type(), parameters.shaclmateName),
-            uniqueLang: $convertToMaybe(($convertToBoolean))(PropertyShape.schema.properties.uniqueLang.type(), parameters.uniqueLang),
-            xone: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(PropertyShape.schema.properties.xone.type(), parameters.xone),
+            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")) {
@@ -1782,8 +1779,8 @@ export var PropertyGroup;
     function create(parameters) {
         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),
+            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")) {
@@ -1953,8 +1950,8 @@ export var Ontology;
     function create(parameters) {
         return $sequenceRecord({
             $identifier: $convertToIdentifierProperty(parameters?.$identifier),
-            comment: $convertToMaybe(($convertToString))(Ontology.schema.properties.comment.type(), parameters?.comment),
-            label: $convertToMaybe(($convertToString))(Ontology.schema.properties.label.type(), parameters?.label),
+            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")) {
@@ -2124,44 +2121,44 @@ export var NodeShape;
     function create(parameters) {
         return $sequenceRecord({
             $identifier: $convertToIdentifierProperty(parameters?.$identifier),
-            and: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(NodeShape.schema.properties.and.type(), parameters?.and),
-            classes: $convertToReadonlyArray(($convertToIri))(NodeShape.schema.properties.classes.type(), parameters?.classes),
-            closed: $convertToMaybe(($convertToBoolean))(NodeShape.schema.properties.closed.type(), parameters?.closed),
-            comment: $convertToMaybe(($convertToString))(NodeShape.schema.properties.comment.type(), parameters?.comment),
-            datatype: $convertToMaybe(($convertToIri))(NodeShape.schema.properties.datatype.type(), parameters?.datatype),
-            deactivated: $convertToMaybe(($convertToBoolean))(NodeShape.schema.properties.deactivated.type(), parameters?.deactivated),
-            discriminantValue: $convertToMaybe(($convertToString))(NodeShape.schema.properties.discriminantValue.type(), parameters?.discriminantValue),
-            extern: $convertToMaybe(($convertToBoolean))(NodeShape.schema.properties.extern.type(), parameters?.extern),
-            flags: $convertToReadonlyArray(($convertToString))(NodeShape.schema.properties.flags.type(), parameters?.flags),
-            fromRdfType: $convertToMaybe(($convertToIri))(NodeShape.schema.properties.fromRdfType.type(), parameters?.fromRdfType),
-            hasValues: $convertToReadonlyArray(($convertToTerm))(NodeShape.schema.properties.hasValues.type(), parameters?.hasValues),
-            ignoredProperties: $convertToMaybe($convertToReadonlyArray(($convertToIri)))(NodeShape.schema.properties.ignoredProperties.type(), parameters?.ignoredProperties),
-            in_: $convertToMaybe($convertToReadonlyArray(($convertToTerm)))(NodeShape.schema.properties.in_.type(), parameters?.in_),
-            isDefinedBy: $convertToMaybe($convertToIdentifier)(NodeShape.schema.properties.isDefinedBy.type(), parameters?.isDefinedBy),
-            label: $convertToMaybe(($convertToString))(NodeShape.schema.properties.label.type(), parameters?.label),
-            languageIn: $convertToMaybe($convertToReadonlyArray(($convertToString)))(NodeShape.schema.properties.languageIn.type(), parameters?.languageIn),
-            maxCount: $convertToMaybe(($convertToNumeric))(NodeShape.schema.properties.maxCount.type(), parameters?.maxCount),
-            maxExclusive: $convertToMaybe($convertToLiteral)(NodeShape.schema.properties.maxExclusive.type(), parameters?.maxExclusive),
-            maxInclusive: $convertToMaybe($convertToLiteral)(NodeShape.schema.properties.maxInclusive.type(), parameters?.maxInclusive),
-            maxLength: $convertToMaybe(($convertToNumeric))(NodeShape.schema.properties.maxLength.type(), parameters?.maxLength),
-            minCount: $convertToMaybe(($convertToNumeric))(NodeShape.schema.properties.minCount.type(), parameters?.minCount),
-            minExclusive: $convertToMaybe($convertToLiteral)(NodeShape.schema.properties.minExclusive.type(), parameters?.minExclusive),
-            minInclusive: $convertToMaybe($convertToLiteral)(NodeShape.schema.properties.minInclusive.type(), parameters?.minInclusive),
-            minLength: $convertToMaybe(($convertToNumeric))(NodeShape.schema.properties.minLength.type(), parameters?.minLength),
-            mutable: $convertToMaybe(($convertToBoolean))(NodeShape.schema.properties.mutable.type(), parameters?.mutable),
-            node: $convertToMaybe($convertToIdentifier)(NodeShape.schema.properties.node.type(), parameters?.node),
-            nodeKind: $convertToMaybe(($convertToIri))(NodeShape.schema.properties.nodeKind.type(), parameters?.nodeKind),
-            not: $convertToReadonlyArray($convertToIdentifier)(NodeShape.schema.properties.not.type(), parameters?.not),
-            or: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(NodeShape.schema.properties.or.type(), parameters?.or),
-            patterns: $convertToReadonlyArray(($convertToString))(NodeShape.schema.properties.patterns.type(), parameters?.patterns),
-            properties: $convertToReadonlyArray($convertToIdentifier)(NodeShape.schema.properties.properties.type(), parameters?.properties),
-            rdfType: $convertToMaybe(($convertToIri))(NodeShape.schema.properties.rdfType.type(), parameters?.rdfType),
-            shaclmateName: $convertToMaybe(($convertToString))(NodeShape.schema.properties.shaclmateName.type(), parameters?.shaclmateName),
-            subClassOf: $convertToReadonlyArray(($convertToIri))(NodeShape.schema.properties.subClassOf.type(), parameters?.subClassOf),
-            toRdfTypes: $convertToReadonlyArray(($convertToIri))(NodeShape.schema.properties.toRdfTypes.type(), parameters?.toRdfTypes),
-            tsImports: $convertToReadonlyArray(($convertToString))(NodeShape.schema.properties.tsImports.type(), parameters?.tsImports),
-            types: $convertToReadonlyArray(($convertToIri))(NodeShape.schema.properties.types.type(), parameters?.types),
-            xone: $convertToMaybe($convertToReadonlyArray($convertToIdentifier))(NodeShape.schema.properties.xone.type(), parameters?.xone),
+            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")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.34",
+    "@shaclmate/shacl-ast": "4.0.35",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
     "@rdfjs/term-map": "~2.0.2",
@@ -68,5 +68,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.34"
+  "version": "4.0.35"
 }

package/dist/generators/ts/_snippets/snippets_convertToBigDecimal.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_convertToBigDecimal: SnippetFactory;
-//# sourceMappingURL=snippets_convertToBigDecimal.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToBigDecimal.js

@@ -1,6 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToBigDecimal = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToBigDecimal`, code `\
-function ${syntheticNamePrefix}convertToBigDecimal(_schema: ${snippets.NumericSchema}<${imports.BigDecimal}>, value: ${imports.BigDecimal}): ${imports.Either}<Error, ${imports.BigDecimal}> {
-  return ${imports.Either}.of(value);
-}`);
-//# sourceMappingURL=snippets_convertToBigDecimal.js.map

package/dist/generators/ts/_snippets/snippets_convertToBoolean.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_convertToBoolean: SnippetFactory;
-//# sourceMappingURL=snippets_convertToBoolean.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToBoolean.js

@@ -1,6 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToBoolean = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToBoolean`, code `\
-function ${syntheticNamePrefix}convertToBoolean<ValueT extends boolean>(_schema: ${snippets.BooleanSchema}, value: ValueT): ${imports.Either}<Error, ValueT> {
-  return ${imports.Either}.of(value);
-}`);
-//# sourceMappingURL=snippets_convertToBoolean.js.map

package/dist/generators/ts/_snippets/snippets_convertToDate.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_convertToDate: SnippetFactory;
-//# sourceMappingURL=snippets_convertToDate.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToDate.js

@@ -1,6 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToDate = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToDate`, code `\
-function ${syntheticNamePrefix}convertToDate(_schema: ${snippets.DateSchema}, value: Date): ${imports.Either}<Error, Date> {
-  return ${imports.Either}.of(value);
-}`);
-//# sourceMappingURL=snippets_convertToDate.js.map

package/dist/generators/ts/_snippets/snippets_convertToDateTime.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_convertToDateTime: SnippetFactory;
-//# sourceMappingURL=snippets_convertToDateTime.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToDateTime.js

@@ -1,6 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToDateTime = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToDateTime`, code `\
-function ${syntheticNamePrefix}convertToDateTime(_schema: ${snippets.DateSchema}, value: Date): ${imports.Either}<Error, Date> {
-  return ${imports.Either}.of(value);
-}`);
-//# sourceMappingURL=snippets_convertToDateTime.js.map

package/dist/generators/ts/_snippets/snippets_convertToMutableArray.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_convertToMutableArray: SnippetFactory;
-//# sourceMappingURL=snippets_convertToMutableArray.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToMutableArray.js

@@ -1,14 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToMutableArray = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToMutableArray`, code `\
-function ${syntheticNamePrefix}convertToMutableArray<ItemSchemaT, ItemSourceT, ItemTargetT>(convertToItem: (schema: ItemSchemaT, value: ItemSourceT) => ${imports.Either}<Error, ItemTargetT>) {
-  return (schema: ${snippets.CollectionSchema}<ItemSchemaT>, value: readonly ItemSourceT[] | undefined): ${imports.Either}<Error, ItemTargetT[]> => {
-    return (typeof value === "undefined" ? ${imports.Either}.of<Error, ItemTargetT[]>([]) : ${imports.Either}.sequence(value.map(item => convertToItem(schema.item(), item))))
-      .chain(array => {
-        if (schema.minCount !== undefined && array.length < schema.minCount) {
-          return ${imports.Left}(new Error(\`array has length (\${array.length}) less than minCount (\${schema.minCount})\`));
-        }
-        return ${imports.Either}.of(array);
-      });
-  }
-}`);
-//# sourceMappingURL=snippets_convertToMutableArray.js.map

package/dist/generators/ts/_snippets/snippets_convertToNumeric.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_convertToNumeric: SnippetFactory;
-//# sourceMappingURL=snippets_convertToNumeric.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToNumeric.js

@@ -1,6 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToNumeric = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToNumeric`, code `\
-function ${syntheticNamePrefix}convertToNumeric<ValueT extends bigint | number>(_schema: ${snippets.NumericSchema}<ValueT>, value: ValueT): ${imports.Either}<Error, ValueT> {
-  return ${imports.Either}.of(value);
-}`);
-//# sourceMappingURL=snippets_convertToNumeric.js.map

package/dist/generators/ts/_snippets/snippets_convertToObject.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_convertToObject: SnippetFactory;
-//# sourceMappingURL=snippets_convertToObject.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToObject.js

@@ -1,6 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToObject = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToObject`, code `\
-function ${syntheticNamePrefix}convertToObject<ValueT extends object>(_schema: unknown, value: ValueT): ${imports.Either}<Error, ValueT> {
-  return ${imports.Either}.of(value);
-}`);
-//# sourceMappingURL=snippets_convertToObject.js.map

package/dist/generators/ts/_snippets/snippets_convertToReadonlyArray.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_convertToReadonlyArray: SnippetFactory;
-//# sourceMappingURL=snippets_convertToReadonlyArray.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToReadonlyArray.js

@@ -1,14 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToReadonlyArray = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToReadonlyArray`, code `\
-function ${syntheticNamePrefix}convertToReadonlyArray<ItemSchemaT, ItemSourceT, ItemTargetT>(convertToItem: (schema: ItemSchemaT, value: ItemSourceT) => ${imports.Either}<Error, ItemTargetT>) {
-  return (schema: ${snippets.CollectionSchema}<ItemSchemaT>, value: readonly ItemSourceT[] | undefined): ${imports.Either}<Error, readonly ItemTargetT[]> => {
-    return (typeof value === "undefined" ? ${imports.Either}.of<Error, readonly ItemTargetT[]>([]) : ${imports.Either}.sequence(value.map(item => convertToItem(schema.item(), item))))
-      .chain(array => {
-        if (schema.minCount !== undefined && array.length < schema.minCount) {
-          return ${imports.Left}(new Error(\`array has length (\${array.length}) less than minCount (\${schema.minCount})\`));
-        }
-        return ${imports.Either}.of(array);
-      });
-  }
-}`);
-//# sourceMappingURL=snippets_convertToReadonlyArray.js.map

package/dist/generators/ts/_snippets/snippets_convertToString.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_convertToString: SnippetFactory;
-//# sourceMappingURL=snippets_convertToString.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToString.js

@@ -1,6 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToString`, code `\
-function ${syntheticNamePrefix}convertToString<ValueT extends string>(_schema: ${snippets.StringSchema}, value: ValueT): ${imports.Either}<Error, ValueT> {
-  return ${imports.Either}.of(value);
-}`);
-//# sourceMappingURL=snippets_convertToString.js.map

package/dist/generators/ts/_snippets/snippets_convertToTerm.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_convertToTerm: SnippetFactory;
-//# sourceMappingURL=snippets_convertToTerm.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToTerm.js

@@ -1,6 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToTerm = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToTerm`, code `\
-function ${syntheticNamePrefix}convertToTerm<ValueT extends ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>(_schema: ${snippets.TermSchema}, value: ValueT): ${imports.Either}<Error, ValueT> {
-  return ${imports.Either}.of(value);
-}`);
-//# sourceMappingURL=snippets_convertToTerm.js.map

package/dist/generators/ts/_snippets/snippets_convertToUnion.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_convertToUnion: SnippetFactory;
-//# sourceMappingURL=snippets_convertToUnion.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToUnion.js

@@ -1,6 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToUnion = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToUnion`, code `\
-function ${syntheticNamePrefix}convertToUnion<ValueT>(_schema: unknown, value: ValueT): ${imports.Either}<Error, ValueT> {
-  return ${imports.Either}.of(value);
-}`);
-//# sourceMappingURL=snippets_convertToUnion.js.map