npm - @shaclmate/compiler - Versions diffs - 4.0.37 → 4.0.39 - Mend

@shaclmate/compiler 4.0.37 → 4.0.39

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (162) hide show

package/dist/input/generated.js CHANGED Viewed

@@ -88,6 +88,20 @@ function $convertWithDefaultValue(convertToItem, defaultValue) {
         return convertToItem(value);
     };
 }
+function $ensureRdfResourceType(resource, types, options) {
+    return resource
+        .value($RdfVocabularies.rdf.type, options)
+        .chain((actualRdfTypeValue) => actualRdfTypeValue.toIri())
+        .chain((actualRdfType) => {
+        // Check the expected type and its known subtypes
+        for (const type of types) {
+            if (resource.isInstanceOf(type, options)) {
+                return Right(undefined);
+            }
+        }
+        return Left(new Error(`${resource.identifier} has unexpected RDF type (actual: ${actualRdfType}, expected one of ${types})`));
+    });
+}
 export var $EqualsResult;
 (function ($EqualsResult) {
     $EqualsResult.Equal = Right(true);
@@ -133,14 +147,16 @@ function $identityValidationFunction(_schema, value) {
 const $literalFactory = new LiteralFactory({ dataFactory: dataFactory });
 function $monkeyPatchObject(obj, methods) {
     if (methods.toJson &&
-        !globalThis.Object.prototype.hasOwnProperty.call(obj, "toJSON")) {
+        (!globalThis.Object.prototype.hasOwnProperty.call(obj, "toJSON") ||
+            typeof obj.toJSON === "function")) {
         const toJsonMethod = methods.toJson;
         obj.toJSON = function (_key) {
             return toJsonMethod(this);
         };
     }
     if (methods.$toString &&
-        !globalThis.Object.prototype.hasOwnProperty.call(obj, "toString")) {
+        (!globalThis.Object.prototype.hasOwnProperty.call(obj, "toString") ||
+            typeof obj.toJSON === "function")) {
         const toStringMethod = methods.$toString;
         obj.toString = function () {
             return toStringMethod(this);
@@ -222,12 +238,12 @@ function $validateArray(validateItem, _readonly) {
         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)));
+        return Either.sequence(valueArray.map((value) => validateItem(schema.itemType, value)));
     };
 }
 function $validateMaybe(validateItem) {
     return (schema, valueMaybe) => valueMaybe
-        .map((value) => validateItem(schema.item(), value).map(() => valueMaybe))
+        .map((value) => validateItem(schema.itemType, value).map(() => valueMaybe))
         .orDefault(Either.of(valueMaybe));
 }
 function $wrap_FromRdfResourceFunction(_fromRdfResourceFunction) {
@@ -266,42 +282,42 @@ export var PropertyShape;
     function create(parameters) {
         return $sequenceRecord({
             $identifier: $convertToIdentifierProperty(parameters.$identifier),
-            and: $convertToMaybe($convertToArray($convertToIdentifier, true))(parameters.and).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.and.type(), value)),
-            classes: $convertToArray(($convertToIri), true)(parameters.classes).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.classes.type(), value)),
-            comment: $convertToMaybe($identityConversionFunction)(parameters.comment).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.comment.type(), value)),
-            datatype: $convertToMaybe(($convertToIri))(parameters.datatype).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.datatype.type(), value)),
-            deactivated: $convertToMaybe($identityConversionFunction)(parameters.deactivated).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.deactivated.type(), value)),
-            defaultValue: $convertToMaybe($identityConversionFunction)(parameters.defaultValue).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.defaultValue.type(), value)),
-            description: $convertToMaybe($identityConversionFunction)(parameters.description).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.description.type(), value)),
+            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)),
+            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)),
+            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) => $monkeyPatchObject({ ...properties, $type: "PropertyShape" }, { $toString }));
     }
     PropertyShape.create = create;
@@ -316,22 +332,8 @@ export var PropertyShape;
     })(Identifier = PropertyShape.Identifier || (PropertyShape.Identifier = {}));
     PropertyShape._fromRdfResource = ($resource, _$options) => {
         return (!_$options.ignoreRdfType
-            ? $resource
-                .value($RdfVocabularies.rdf.type, { graph: _$options.graph })
-                .chain((actualRdfType) => actualRdfType.toIri())
-                .chain((actualRdfType) => {
-                // Check the expected type and its known subtypes
-                switch (actualRdfType.value) {
-                    case "http://www.w3.org/ns/shacl#PropertyShape":
-                        return Right(true);
-                }
-                // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($resource.isInstanceOf(PropertyShape.fromRdfType, {
-                    graph: _$options.graph,
-                })) {
-                    return Right(true);
-                }
-                return Left(new Error(`${$resource.identifier} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#PropertyShape)`));
+            ? $ensureRdfResourceType($resource, [PropertyShape.fromRdfType], {
+                graph: _$options.graph,
             })
             : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
             $identifier: Right(new Resource.Value({
@@ -949,238 +951,217 @@ export var PropertyShape;
         properties: {
             $identifier: {
                 kind: "Identifier",
-                type: () => ({ kind: "Identifier" }),
-            },
-            $type: {
-                kind: "Discriminant",
-                type: () => ({
-                    kind: "TypeDiscriminant",
-                    ownValues: ["PropertyShape"],
-                }),
+                type: { kind: "Identifier" },
             },
             and: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "List",
-                        item: () => ({ kind: "Identifier" }),
-                    }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#and"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
             },
             classes: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Iri" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#class"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
             },
             comment: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
             datatype: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Iri" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"),
+                type: { kind: "Option", itemType: { kind: "Iri" } },
             },
             deactivated: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Boolean" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
             },
             defaultValue: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Term" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#defaultValue"),
+                type: { kind: "Option", itemType: { kind: "Term" } },
             },
             description: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#description"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
             display: {
                 kind: "Shacl",
-                type: () => ({
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#display"),
+                type: {
                     kind: "DefaultValue",
-                    item: () => ({ kind: "Boolean" }),
+                    itemType: { kind: "Boolean" },
                     defaultValue: false,
-                }),
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#display"),
+                },
             },
             flags: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
+                type: { kind: "Set", itemType: { kind: "String" } },
             },
             groups: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Identifier" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#group"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Identifier" },
+                },
             },
             hasValues: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Term" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"),
+                type: { kind: "Set", itemType: { kind: "Term" } },
             },
             in_: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "List",
-                        item: () => ({ kind: "Term" }),
-                    }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#in"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Term" },
+                    },
+                },
             },
             isDefinedBy: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Identifier" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Identifier" },
+                },
             },
             label: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
             languageIn: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "List",
-                        item: () => ({ kind: "String" }),
-                    }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#languageIn"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "String" },
+                    },
+                },
             },
             maxCount: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "BigInt" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxCount"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
             },
             maxExclusive: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Literal" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
             },
             maxInclusive: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Literal" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxInclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
             },
             maxLength: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "BigInt" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
             },
             minCount: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "BigInt" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
             },
             minExclusive: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Literal" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
             },
             minInclusive: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Literal" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minInclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
             },
             minLength: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "BigInt" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
             },
             mutable: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Boolean" }),
-                }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#mutable"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
             },
             name: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#name"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
             node: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Identifier" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Identifier" },
+                },
             },
             nodeKind: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"),
+                type: {
+                    kind: "Option",
+                    itemType: {
                         kind: "Iri",
                         in: [
                             dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNode"),
@@ -1190,84 +1171,79 @@ export var PropertyShape;
                             dataFactory.namedNode("http://www.w3.org/ns/shacl#IRIOrLiteral"),
                             dataFactory.namedNode("http://www.w3.org/ns/shacl#Literal"),
                         ],
-                    }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"),
+                    },
+                },
             },
             not: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Identifier" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#not"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Identifier" },
+                },
             },
             or: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "List",
-                        item: () => ({ kind: "Identifier" }),
-                    }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#or"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
             },
             order: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Float" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#order"),
+                type: { kind: "Option", itemType: { kind: "Float" } },
             },
             path: {
                 kind: "Shacl",
-                type: () => $PropertyPath.schema,
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#path"),
+                get type() {
+                    return $PropertyPath.schema;
+                },
             },
             patterns: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
+                type: { kind: "Set", itemType: { kind: "String" } },
             },
             resolve: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Identifier" }),
-                }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#resolve"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Identifier" },
+                },
             },
             shaclmateName: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
             uniqueLang: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Boolean" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
             },
             xone: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "List",
-                        item: () => ({ kind: "Identifier" }),
-                    }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
             },
         },
     };
@@ -1494,8 +1470,8 @@ export var PropertyGroup;
     function create(parameters) {
         return $sequenceRecord({
             $identifier: $convertToIdentifierProperty(parameters?.$identifier),
-            comment: $convertToMaybe($identityConversionFunction)(parameters?.comment).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.comment.type(), value)),
-            label: $convertToMaybe($identityConversionFunction)(parameters?.label).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.label.type(), value)),
+            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) => $monkeyPatchObject({ ...properties, $type: "PropertyGroup" }, { $toString }));
     }
     PropertyGroup.create = create;
@@ -1510,22 +1486,8 @@ export var PropertyGroup;
     })(Identifier = PropertyGroup.Identifier || (PropertyGroup.Identifier = {}));
     PropertyGroup._fromRdfResource = ($resource, _$options) => {
         return (!_$options.ignoreRdfType
-            ? $resource
-                .value($RdfVocabularies.rdf.type, { graph: _$options.graph })
-                .chain((actualRdfType) => actualRdfType.toIri())
-                .chain((actualRdfType) => {
-                // Check the expected type and its known subtypes
-                switch (actualRdfType.value) {
-                    case "http://www.w3.org/ns/shacl#PropertyGroup":
-                        return Right(true);
-                }
-                // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($resource.isInstanceOf(PropertyGroup.fromRdfType, {
-                    graph: _$options.graph,
-                })) {
-                    return Right(true);
-                }
-                return Left(new Error(`${$resource.identifier} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#PropertyGroup)`));
+            ? $ensureRdfResourceType($resource, [PropertyGroup.fromRdfType], {
+                graph: _$options.graph,
             })
             : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
             $identifier: Right(new Resource.Value({
@@ -1586,30 +1548,23 @@ export var PropertyGroup;
         properties: {
             $identifier: {
                 kind: "Identifier",
-                type: () => ({ kind: "Identifier" }),
-            },
-            $type: {
-                kind: "Discriminant",
-                type: () => ({
-                    kind: "TypeDiscriminant",
-                    ownValues: ["PropertyGroup"],
-                }),
+                type: { kind: "Identifier" },
             },
             comment: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
             label: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
         },
     };
@@ -1643,8 +1598,8 @@ export var Ontology;
     function create(parameters) {
         return $sequenceRecord({
             $identifier: $convertToIdentifierProperty(parameters?.$identifier),
-            comment: $convertToMaybe($identityConversionFunction)(parameters?.comment).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.comment.type(), value)),
-            label: $convertToMaybe($identityConversionFunction)(parameters?.label).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.label.type(), value)),
+            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) => $monkeyPatchObject({ ...properties, $type: "Ontology" }, { $toString }));
     }
     Ontology.create = create;
@@ -1659,22 +1614,8 @@ export var Ontology;
     })(Identifier = Ontology.Identifier || (Ontology.Identifier = {}));
     Ontology._fromRdfResource = ($resource, _$options) => {
         return (!_$options.ignoreRdfType
-            ? $resource
-                .value($RdfVocabularies.rdf.type, { graph: _$options.graph })
-                .chain((actualRdfType) => actualRdfType.toIri())
-                .chain((actualRdfType) => {
-                // Check the expected type and its known subtypes
-                switch (actualRdfType.value) {
-                    case "http://www.w3.org/2002/07/owl#Ontology":
-                        return Right(true);
-                }
-                // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($resource.isInstanceOf(Ontology.fromRdfType, {
-                    graph: _$options.graph,
-                })) {
-                    return Right(true);
-                }
-                return Left(new Error(`${$resource.identifier} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/2002/07/owl#Ontology)`));
+            ? $ensureRdfResourceType($resource, [Ontology.fromRdfType], {
+                graph: _$options.graph,
             })
             : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
             $identifier: Right(new Resource.Value({
@@ -1735,30 +1676,23 @@ export var Ontology;
         properties: {
             $identifier: {
                 kind: "Identifier",
-                type: () => ({ kind: "Identifier" }),
-            },
-            $type: {
-                kind: "Discriminant",
-                type: () => ({
-                    kind: "TypeDiscriminant",
-                    ownValues: ["Ontology"],
-                }),
+                type: { kind: "Identifier" },
             },
             comment: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
             label: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
         },
     };
@@ -1792,44 +1726,44 @@ export var NodeShape;
     function create(parameters) {
         return $sequenceRecord({
             $identifier: $convertToIdentifierProperty(parameters?.$identifier),
-            and: $convertToMaybe($convertToArray($convertToIdentifier, true))(parameters?.and).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.and.type(), value)),
-            classes: $convertToArray(($convertToIri), true)(parameters?.classes).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.classes.type(), value)),
-            closed: $convertToMaybe($identityConversionFunction)(parameters?.closed).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.closed.type(), value)),
-            comment: $convertToMaybe($identityConversionFunction)(parameters?.comment).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.comment.type(), value)),
-            datatype: $convertToMaybe(($convertToIri))(parameters?.datatype).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.datatype.type(), value)),
-            deactivated: $convertToMaybe($identityConversionFunction)(parameters?.deactivated).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.deactivated.type(), value)),
-            discriminantValue: $convertToMaybe($identityConversionFunction)(parameters?.discriminantValue).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.discriminantValue.type(), value)),
-            extern: $convertToMaybe($identityConversionFunction)(parameters?.extern).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.extern.type(), value)),
-            flags: $convertToArray($identityConversionFunction, true)(parameters?.flags).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.flags.type(), value)),
-            fromRdfType: $convertToMaybe(($convertToIri))(parameters?.fromRdfType).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.fromRdfType.type(), value)),
-            hasValues: $convertToArray($identityConversionFunction, true)(parameters?.hasValues).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.hasValues.type(), value)),
-            ignoredProperties: $convertToMaybe($convertToArray(($convertToIri), true))(parameters?.ignoredProperties).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.ignoredProperties.type(), value)),
-            in_: $convertToMaybe($convertToArray($identityConversionFunction, true))(parameters?.in_).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.in_.type(), value)),
-            isDefinedBy: $convertToMaybe($convertToIdentifier)(parameters?.isDefinedBy).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.isDefinedBy.type(), value)),
-            label: $convertToMaybe($identityConversionFunction)(parameters?.label).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.label.type(), value)),
-            languageIn: $convertToMaybe($convertToArray($identityConversionFunction, true))(parameters?.languageIn).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.languageIn.type(), value)),
-            maxCount: $convertToMaybe($identityConversionFunction)(parameters?.maxCount).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxCount.type(), value)),
-            maxExclusive: $convertToMaybe($convertToLiteral)(parameters?.maxExclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxExclusive.type(), value)),
-            maxInclusive: $convertToMaybe($convertToLiteral)(parameters?.maxInclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxInclusive.type(), value)),
-            maxLength: $convertToMaybe($identityConversionFunction)(parameters?.maxLength).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxLength.type(), value)),
-            minCount: $convertToMaybe($identityConversionFunction)(parameters?.minCount).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minCount.type(), value)),
-            minExclusive: $convertToMaybe($convertToLiteral)(parameters?.minExclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minExclusive.type(), value)),
-            minInclusive: $convertToMaybe($convertToLiteral)(parameters?.minInclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minInclusive.type(), value)),
-            minLength: $convertToMaybe($identityConversionFunction)(parameters?.minLength).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minLength.type(), value)),
-            mutable: $convertToMaybe($identityConversionFunction)(parameters?.mutable).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.mutable.type(), value)),
-            node: $convertToMaybe($convertToIdentifier)(parameters?.node).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.node.type(), value)),
-            nodeKind: $convertToMaybe(($convertToIri))(parameters?.nodeKind).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.nodeKind.type(), value)),
-            not: $convertToArray($convertToIdentifier, true)(parameters?.not).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.not.type(), value)),
-            or: $convertToMaybe($convertToArray($convertToIdentifier, true))(parameters?.or).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.or.type(), value)),
-            patterns: $convertToArray($identityConversionFunction, true)(parameters?.patterns).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.patterns.type(), value)),
-            properties: $convertToArray($convertToIdentifier, true)(parameters?.properties).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.properties.type(), value)),
-            rdfType: $convertToMaybe(($convertToIri))(parameters?.rdfType).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.rdfType.type(), value)),
-            shaclmateName: $convertToMaybe($identityConversionFunction)(parameters?.shaclmateName).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.shaclmateName.type(), value)),
-            subClassOf: $convertToArray(($convertToIri), true)(parameters?.subClassOf).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.subClassOf.type(), value)),
-            toRdfTypes: $convertToArray(($convertToIri), true)(parameters?.toRdfTypes).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.toRdfTypes.type(), value)),
-            tsImports: $convertToArray($identityConversionFunction, true)(parameters?.tsImports).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.tsImports.type(), value)),
-            types: $convertToArray(($convertToIri), true)(parameters?.types).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.types.type(), value)),
-            xone: $convertToMaybe($convertToArray($convertToIdentifier, true))(parameters?.xone).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.xone.type(), value)),
+            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) => $monkeyPatchObject({ ...properties, $type: "NodeShape" }, { $toString }));
     }
     NodeShape.create = create;
@@ -1844,22 +1778,8 @@ export var NodeShape;
     })(Identifier = NodeShape.Identifier || (NodeShape.Identifier = {}));
     NodeShape._fromRdfResource = ($resource, _$options) => {
         return (!_$options.ignoreRdfType
-            ? $resource
-                .value($RdfVocabularies.rdf.type, { graph: _$options.graph })
-                .chain((actualRdfType) => actualRdfType.toIri())
-                .chain((actualRdfType) => {
-                // Check the expected type and its known subtypes
-                switch (actualRdfType.value) {
-                    case "http://www.w3.org/ns/shacl#NodeShape":
-                        return Right(true);
-                }
-                // Check arbitrary rdfs:subClassOf's of the expected type
-                if ($resource.isInstanceOf(NodeShape.fromRdfType, {
-                    graph: _$options.graph,
-                })) {
-                    return Right(true);
-                }
-                return Left(new Error(`${$resource.identifier} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#NodeShape)`));
+            ? $ensureRdfResourceType($resource, [NodeShape.fromRdfType], {
+                graph: _$options.graph,
             })
             : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
             $identifier: Right(new Resource.Value({
@@ -2494,240 +2414,219 @@ export var NodeShape;
         properties: {
             $identifier: {
                 kind: "Identifier",
-                type: () => ({ kind: "Identifier" }),
-            },
-            $type: {
-                kind: "Discriminant",
-                type: () => ({
-                    kind: "TypeDiscriminant",
-                    ownValues: ["NodeShape"],
-                }),
+                type: { kind: "Identifier" },
             },
             and: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "List",
-                        item: () => ({ kind: "Identifier" }),
-                    }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#and"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
             },
             classes: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Iri" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#class"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
             },
             closed: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Boolean" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#closed"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
             },
             comment: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
             datatype: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Iri" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"),
+                type: { kind: "Option", itemType: { kind: "Iri" } },
             },
             deactivated: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Boolean" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
             },
             discriminantValue: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#discriminantValue"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
             extern: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Boolean" }),
-                }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#extern"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
             },
             flags: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
+                type: { kind: "Set", itemType: { kind: "String" } },
             },
             fromRdfType: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Iri" }),
-                }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#fromRdfType"),
+                type: { kind: "Option", itemType: { kind: "Iri" } },
             },
             hasValues: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Term" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"),
+                type: { kind: "Set", itemType: { kind: "Term" } },
             },
             ignoredProperties: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "List",
-                        item: () => ({ kind: "Iri" }),
-                    }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#ignoredProperties"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Iri" },
+                    },
+                },
             },
             in_: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "List",
-                        item: () => ({ kind: "Term" }),
-                    }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#in"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Term" },
+                    },
+                },
             },
             isDefinedBy: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Identifier" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Identifier" },
+                },
             },
             label: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
             languageIn: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "List",
-                        item: () => ({ kind: "String" }),
-                    }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#languageIn"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "String" },
+                    },
+                },
             },
             maxCount: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "BigInt" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxCount"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
             },
             maxExclusive: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Literal" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
             },
             maxInclusive: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Literal" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxInclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
             },
             maxLength: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "BigInt" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
             },
             minCount: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "BigInt" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
             },
             minExclusive: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Literal" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
             },
             minInclusive: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Literal" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minInclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
             },
             minLength: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "BigInt" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
             },
             mutable: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Boolean" }),
-                }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#mutable"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
             },
             node: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Identifier" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Identifier" },
+                },
             },
             nodeKind: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"),
+                type: {
+                    kind: "Option",
+                    itemType: {
                         kind: "Iri",
                         in: [
                             dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNode"),
@@ -2737,103 +2636,84 @@ export var NodeShape;
                             dataFactory.namedNode("http://www.w3.org/ns/shacl#IRIOrLiteral"),
                             dataFactory.namedNode("http://www.w3.org/ns/shacl#Literal"),
                         ],
-                    }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"),
+                    },
+                },
             },
             not: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Identifier" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#not"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Identifier" },
+                },
             },
             or: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "List",
-                        item: () => ({ kind: "Identifier" }),
-                    }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#or"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
             },
             patterns: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
+                type: { kind: "Set", itemType: { kind: "String" } },
             },
             properties: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Identifier" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#property"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Identifier" },
+                },
             },
             rdfType: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Iri" }),
-                }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#rdfType"),
+                type: { kind: "Option", itemType: { kind: "Iri" } },
             },
             shaclmateName: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
             subClassOf: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Iri" }),
-                }),
                 path: $RdfVocabularies.rdfs.subClassOf,
+                type: { kind: "Set", itemType: { kind: "Iri" } },
             },
             toRdfTypes: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Iri" }),
-                }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#toRdfType"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
             },
             tsImports: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsImport"),
+                type: { kind: "Set", itemType: { kind: "String" } },
             },
             types: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Iri" }),
-                }),
                 path: $RdfVocabularies.rdf.type,
+                type: { kind: "Set", itemType: { kind: "Iri" } },
             },
             xone: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "List",
-                        item: () => ({ kind: "Identifier" }),
-                    }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
             },
         },
     };
@@ -3126,186 +3006,175 @@ export var Shape;
         properties: {
             and: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "List",
-                        item: () => ({ kind: "Identifier" }),
-                    }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#and"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
             },
             classes: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Iri" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#class"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
             },
             comment: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
             datatype: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Iri" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"),
+                type: { kind: "Option", itemType: { kind: "Iri" } },
             },
             deactivated: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Boolean" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
             },
             flags: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
+                type: { kind: "Set", itemType: { kind: "String" } },
             },
             hasValues: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Term" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"),
+                type: { kind: "Set", itemType: { kind: "Term" } },
             },
             in_: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "List",
-                        item: () => ({ kind: "Term" }),
-                    }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#in"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Term" },
+                    },
+                },
             },
             isDefinedBy: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Identifier" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Identifier" },
+                },
             },
             label: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
             languageIn: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "List",
-                        item: () => ({ kind: "String" }),
-                    }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#languageIn"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "String" },
+                    },
+                },
             },
             maxCount: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "BigInt" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxCount"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
             },
             maxExclusive: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Literal" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
             },
             maxInclusive: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Literal" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxInclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
             },
             maxLength: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "BigInt" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
             },
             minCount: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "BigInt" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
             },
             minExclusive: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Literal" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
             },
             minInclusive: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Literal" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minInclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
             },
             minLength: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "BigInt" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
             },
             mutable: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Boolean" }),
-                }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#mutable"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
             },
             node: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "Identifier" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Identifier" },
+                },
             },
             nodeKind: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"),
+                type: {
+                    kind: "Option",
+                    itemType: {
                         kind: "Iri",
                         in: [
                             dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNode"),
@@ -3315,55 +3184,51 @@ export var Shape;
                             dataFactory.namedNode("http://www.w3.org/ns/shacl#IRIOrLiteral"),
                             dataFactory.namedNode("http://www.w3.org/ns/shacl#Literal"),
                         ],
-                    }),
-                }),
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"),
+                    },
+                },
             },
             not: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "Identifier" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#not"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Identifier" },
+                },
             },
             or: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "List",
-                        item: () => ({ kind: "Identifier" }),
-                    }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#or"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
             },
             patterns: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Set",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
+                type: { kind: "Set", itemType: { kind: "String" } },
             },
             shaclmateName: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
             xone: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({
-                        kind: "List",
-                        item: () => ({ kind: "Identifier" }),
-                    }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
             },
         },
     };
@@ -3487,19 +3352,19 @@ export var $Object;
         properties: {
             comment: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
             label: {
                 kind: "Shacl",
-                type: () => ({
-                    kind: "Maybe",
-                    item: () => ({ kind: "String" }),
-                }),
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
         },
     };