@shaclmate/shacl-ast 4.0.50 → 4.0.52

package/dist/shacl-ast.shaclmate.js

@@ -0,0 +1,3265 @@
+import datasetFactory from "@rdfjs/dataset";
+import dataFactory from "@rdfx/data-factory";
+import { LiteralFactory } from "@rdfx/literal";
+import { PropertyPath as RdfxResourcePropertyPath, Resource, ResourceSet, } from "@rdfx/resource";
+import { NTriplesIdentifier, NTriplesTerm } from "@rdfx/string";
+import { Either, Left, Maybe, Right } from "purify-ts";
+function $bigIntFromRdfResourceValues(values, options) {
+    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => options.schema.in
+        ? value.toBigInt(options.schema.in)
+        : value.toBigInt()));
+}
+function $booleanFromRdfResourceValues(values, options) {
+    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => options.schema.in
+        ? value.toBoolean(options.schema.in)
+        : value.toBoolean()));
+}
+/**
+ * Remove undefined values from a record.
+ */
+function $compactRecord(record) {
+    return globalThis.Object.entries(record).reduce((definedProperties, [propertyName, propertyValue]) => {
+        if (propertyValue !== undefined) {
+            definedProperties[propertyName] = propertyValue;
+        }
+        return definedProperties;
+    }, {});
+}
+function $convertToIdentifier(value) {
+    switch (typeof value) {
+        case "object":
+            return Either.of(value);
+        case "string":
+            return Either.of(dataFactory.namedNode(value));
+        case "undefined":
+            return Either.of(dataFactory.blankNode());
+    }
+}
+function $convertToIdentifierProperty(identifier) {
+    switch (typeof identifier) {
+        case "function":
+            return Either.of(identifier);
+        case "object": {
+            const captureIdentifier = identifier;
+            return Either.of(() => captureIdentifier);
+        }
+        case "string": {
+            const captureIdentifier = dataFactory.namedNode(identifier);
+            return Either.of(() => captureIdentifier);
+        }
+        case "undefined": {
+            const captureIdentifier = dataFactory.blankNode();
+            return Either.of(() => captureIdentifier);
+        }
+    }
+}
+function $convertToIri(value) {
+    switch (typeof value) {
+        case "object":
+            return Either.of(value);
+        case "string":
+            return Either.of(dataFactory.namedNode(value));
+    }
+}
+function $convertToList(convertToItem, _readonly) {
+    return (value) => Either.sequence(value.map(convertToItem));
+}
+function $convertToLiteral(value) {
+    if (typeof value === "object") {
+        if (value instanceof Date) {
+            return Either.of($literalFactory.date(value));
+        }
+        return Either.of(value);
+    }
+    return Either.of($literalFactory.primitive(value));
+}
+function $convertToMaybe(convertToItem) {
+    return (value) => {
+        switch (typeof value) {
+            case "object": {
+                if (Maybe.isMaybe(value)) {
+                    return Either.of(value);
+                }
+                break;
+            }
+            case "undefined":
+                return Either.of(Maybe.empty());
+        }
+        return convertToItem(value).map(Maybe.of);
+    };
+}
+function $convertToScalarSet(convertToItem, _readonly) {
+    return (value) => {
+        if (typeof value === "undefined") {
+            return Either.of([]);
+        }
+        if (Array.isArray(value)) {
+            return Either.sequence(value.map(convertToItem));
+        }
+        return convertToItem(value).map((value) => [
+            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})`));
+    });
+}
+function $floatFromRdfResourceValues(values, options) {
+    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => options.schema.in
+        ? value.toFloat(options.schema.in)
+        : value.toFloat()));
+}
+function $identifierFromRdfResourceValues(values, options) {
+    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => value.toIdentifier()));
+}
+function $identityConversionFunction(value) {
+    return Either.of(value);
+}
+function $identityValidationFunction(_schema, value) {
+    return Either.of(value);
+}
+function $iriFromRdfResourceValues(values, options) {
+    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => options.schema.in
+        ? value.toIri(options.schema.in)
+        : value.toIri()));
+}
+function $listFromRdfResourceValues(itemFromRdfResourceValues) {
+    return (values, options) => values
+        .chainMap((value) => value.toList({ graph: options.graph })) // Resource.Values<Resource.Value> to Resource.Values<Resource.Values>;
+        .chain((valueLists) => valueLists.chainMap((valueList) => itemFromRdfResourceValues(Resource.Values.fromArray({
+        focusResource: options.focusResource,
+        propertyPath: options.propertyPath,
+        values: valueList.toArray(),
+    }), { ...options, schema: options.schema.itemType }))) // Resource.Values<Resource.Values> to Resource.Values<item type arrays>
+        .map((valueLists) => valueLists.map((valueList) => valueList.toArray())); // Convert inner Resource.Values to arrays
+}
+const $literalFactory = new LiteralFactory({ dataFactory: dataFactory });
+function $literalFromRdfResourceValues(values, options) {
+    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => value.toLiteral()));
+}
+function $maybeFromRdfResourceValues(itemFromRdfResourceValues) {
+    return (values, options) => itemFromRdfResourceValues(values, {
+        ...options,
+        schema: options.schema.itemType,
+    }).map((values) => values.length > 0
+        ? values.map((value) => Maybe.of(value))
+        : Resource.Values.fromValue({
+            focusResource: options.focusResource,
+            propertyPath: options.propertyPath,
+            value: Maybe.empty(),
+        }));
+}
+function $monkeyPatchObject(obj, methods) {
+    if (methods.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") ||
+            typeof obj.toJSON === "function")) {
+        const toStringMethod = methods.$toString;
+        obj.toString = function () {
+            return toStringMethod(this);
+        };
+    }
+    return obj;
+}
+const $parseIdentifier = NTriplesIdentifier.parser(dataFactory);
+export var $PropertyPath;
+(function ($PropertyPath) {
+    $PropertyPath.fromRdfResource = RdfxResourcePropertyPath.fromResource;
+    $PropertyPath.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => $PropertyPath.fromRdfResource(resource, options)));
+    $PropertyPath.schema = {};
+    $PropertyPath.toRdfResource = RdfxResourcePropertyPath.toResource;
+    $PropertyPath.$toString = RdfxResourcePropertyPath.toString;
+})($PropertyPath || ($PropertyPath = {}));
+function $rdfResourceIdentifierValues(resource) {
+    return new Resource.Value({
+        dataFactory: dataFactory,
+        focusResource: resource,
+        propertyPath: $RdfVocabularies.rdf.subject,
+        term: resource.identifier,
+    }).toValues();
+}
+var $RdfVocabularies;
+(function ($RdfVocabularies) {
+    $RdfVocabularies.rdf = {
+        first: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#first"),
+        nil: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil"),
+        rest: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest"),
+        subject: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#subject"),
+        type: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"),
+    };
+    $RdfVocabularies.rdfs = {
+        subClassOf: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#subClassOf"),
+    };
+    $RdfVocabularies.xsd = {
+        boolean: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#boolean"),
+        byte: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#byte"),
+        date: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#date"),
+        dateTime: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#dateTime"),
+        decimal: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#decimal"),
+        double: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#double"),
+        float: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#float"),
+        int: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#int"),
+        integer: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#integer"),
+        long: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#long"),
+        negativeInteger: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#negativeInteger"),
+        nonNegativeInteger: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#nonNegativeInteger"),
+        nonPositiveInteger: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#nonPositiveInteger"),
+        positiveInteger: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#positiveInteger"),
+        short: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#short"),
+        string: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#string"),
+        unsignedByte: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedByte"),
+        unsignedInt: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedInt"),
+        unsignedLong: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedLong"),
+        unsignedShort: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedShort"),
+    };
+})($RdfVocabularies || ($RdfVocabularies = {}));
+function $sequenceRecord(record) {
+    const result = {};
+    for (const key of globalThis.Object.keys(record)) {
+        const either = record[key];
+        if (either.isLeft()) {
+            return either;
+        }
+        result[key] = either.extract();
+    }
+    return Right(result);
+}
+function $setFromRdfResourceValues(itemFromRdfResourceValues) {
+    return (values, options) => itemFromRdfResourceValues(values, {
+        ...options,
+        schema: options.schema.itemType,
+    })
+        .map((values) => values.toArray())
+        .map((valuesArray) => Resource.Values.fromValue({
+        focusResource: options.focusResource,
+        propertyPath: options.propertyPath,
+        value: valuesArray,
+    }));
+}
+function $shaclPropertyFromRdf({ focusResource, graph, propertySchema, typeFromRdfResourceValues, ...otherParameters }) {
+    return typeFromRdfResourceValues(focusResource.values(propertySchema.path, { graph, unique: true }), {
+        ...otherParameters,
+        focusResource,
+        graph,
+        propertyPath: propertySchema.path,
+        schema: propertySchema.type,
+    }).chain((values) => values.head());
+}
+function $stringFromRdfResourceValues(values, options) {
+    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => options.schema.in
+        ? value.toString(options.schema.in)
+        : value.toString()));
+}
+function $termFromRdfResourceValues(values, options) {
+    const { focusResource, propertyPath, schema } = options;
+    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
+        if (schema.in &&
+            schema.in.length > 0 &&
+            !schema.in.some((in_) => in_.equals(term))) {
+            return Left(new Resource.MistypedTermValueError({
+                actualValue: term,
+                expectedValueType: "Term in",
+                focusResource,
+                propertyPath,
+            }));
+        }
+        if (!schema.types.some((type) => term.termType === type)) {
+            return Left(new Resource.MistypedTermValueError({
+                actualValue: term,
+                expectedValueType: "Term types",
+                focusResource,
+                propertyPath,
+            }));
+        }
+        return Right(term);
+    })));
+}
+const $termLikeFromRdfResourceValues = (values, { preferredLanguages, schema: { hasValues, languageIn } }) => {
+    let chain = Either.of(values);
+    if (hasValues && hasValues.length > 0) {
+        chain = chain.chain((values) => Either.sequence(hasValues.map((hasValue) => values.find((value) => value.term.equals(hasValue)))).map(() => values));
+    }
+    if (languageIn && languageIn.length > 0) {
+        chain = chain.chain((values) => values.chainMap((value) => value.toLiteral().chain((literal) => languageIn.includes(literal.language)
+            ? Right(value)
+            : Left(new Resource.MistypedTermValueError({
+                actualValue: literal,
+                expectedValueType: "Literal",
+                focusResource: value.focusResource,
+                propertyPath: value.propertyPath,
+            })))));
+    }
+    if (preferredLanguages && preferredLanguages.length > 0) {
+        chain = chain.chain((values) => {
+            const literals = [];
+            const literalValues = [];
+            const nonLiteralValues = [];
+            for (const value of values) {
+                const term = value.toTerm().unsafeCoerce();
+                if (term.termType === "Literal") {
+                    literals.push(term);
+                    literalValues.push(value);
+                }
+                else {
+                    nonLiteralValues.push(value);
+                }
+            }
+            // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
+            // Within a preferredLanguage the literals may be in any order.
+            const preferredLanguageLiteralValues = [];
+            for (const preferredLanguage of preferredLanguages) {
+                for (let literalI = 0; literalI < literals.length; literalI++) {
+                    if (literals[literalI].language === preferredLanguage) {
+                        preferredLanguageLiteralValues.push(literalValues[literalI]);
+                    }
+                }
+            }
+            return Right(Resource.Values.fromArray({
+                focusResource: values.focusResource,
+                propertyPath: values.propertyPath,
+                values: nonLiteralValues.concat(preferredLanguageLiteralValues),
+            }));
+        });
+    }
+    return chain;
+};
+function $validateArray(validateItem, _readonly) {
+    return (schema, valueArray) => {
+        if (schema.minCount !== undefined && valueArray.length < schema.minCount) {
+            return Left(new Error(`value array has length (${valueArray.length}) less than minCount (${schema.minCount})`));
+        }
+        return Either.sequence(valueArray.map((value) => validateItem(schema.itemType, value)));
+    };
+}
+function $validateMaybe(validateItem) {
+    return (schema, valueMaybe) => valueMaybe
+        .map((value) => validateItem(schema.itemType, value).map(() => valueMaybe))
+        .orDefault(Either.of(valueMaybe));
+}
+function $wrap_FromRdfResourceFunction(_fromRdfResourceFunction) {
+    return (resource, options) => {
+        const { context, graph, ignoreRdfType = false, preferredLanguages, } = options ?? {};
+        return _fromRdfResourceFunction(resource, {
+            context,
+            graph,
+            ignoreRdfType,
+            preferredLanguages,
+        });
+    };
+}
+function $wrap_ToRdfResourceFunction(_toRdfResourceFunction) {
+    return (object, options) => {
+        let { graph, ignoreRdfType = false, resourceSet } = options ?? {};
+        if (!resourceSet) {
+            resourceSet = new ResourceSet({
+                dataFactory: dataFactory,
+                dataset: datasetFactory.dataset(),
+            });
+        }
+        const resource = resourceSet.resource(object.$identifier());
+        _toRdfResourceFunction({
+            graph,
+            ignoreRdfType,
+            object,
+            resource,
+            resourceSet,
+        });
+        return resource;
+    };
+}
+export var NodeShape;
+(function (NodeShape) {
+    NodeShape.create = (parameters) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters?.$identifier),
+        and: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters?.and).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.and.type, value)),
+        classes: $convertToScalarSet(($convertToIri), true)(parameters?.classes).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.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)(NodeShape.schema.properties.comment.type, value)),
+        datatype: $convertToMaybe(($convertToIri))(parameters?.datatype).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.datatype.type, value)),
+        deactivated: $convertToMaybe($identityConversionFunction)(parameters?.deactivated).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.deactivated.type, value)),
+        flags: $convertToMaybe($identityConversionFunction)(parameters?.flags).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.flags.type, value)),
+        hasValues: $convertToScalarSet($identityConversionFunction, true)(parameters?.hasValues).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.hasValues.type, value)),
+        ignoredProperties: $convertToMaybe($convertToList(($convertToIri), true))(parameters?.ignoredProperties).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.ignoredProperties.type, value)),
+        in_: $convertToMaybe($convertToList($identityConversionFunction, true))(parameters?.in_).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.in_.type, value)),
+        isDefinedBy: $convertToMaybe($convertToIdentifier)(parameters?.isDefinedBy).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.isDefinedBy.type, value)),
+        label: $convertToMaybe($identityConversionFunction)(parameters?.label).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.label.type, value)),
+        languageIn: $convertToMaybe($convertToList($identityConversionFunction, true))(parameters?.languageIn).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.languageIn.type, value)),
+        maxExclusive: $convertToMaybe($convertToLiteral)(parameters?.maxExclusive).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxExclusive.type, value)),
+        maxInclusive: $convertToMaybe($convertToLiteral)(parameters?.maxInclusive).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxInclusive.type, value)),
+        maxLength: $convertToMaybe($identityConversionFunction)(parameters?.maxLength).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxLength.type, value)),
+        message: $convertToMaybe($identityConversionFunction)(parameters?.message).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.message.type, value)),
+        minExclusive: $convertToMaybe($convertToLiteral)(parameters?.minExclusive).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minExclusive.type, value)),
+        minInclusive: $convertToMaybe($convertToLiteral)(parameters?.minInclusive).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minInclusive.type, value)),
+        minLength: $convertToMaybe($identityConversionFunction)(parameters?.minLength).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minLength.type, value)),
+        node: $convertToMaybe($convertToIdentifier)(parameters?.node).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.node.type, value)),
+        nodeKind: $convertToMaybe(($convertToIri))(parameters?.nodeKind).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.nodeKind.type, value)),
+        not: $convertToScalarSet($convertToIdentifier, true)(parameters?.not).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.not.type, value)),
+        or: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters?.or).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.or.type, value)),
+        pattern: $convertToMaybe($identityConversionFunction)(parameters?.pattern).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.pattern.type, value)),
+        properties: $convertToScalarSet($convertToIdentifier, true)(parameters?.properties).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.properties.type, value)),
+        severity: $convertToMaybe(($convertToIri))(parameters?.severity).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.severity.type, value)),
+        subClassOf: $convertToScalarSet(($convertToIri), true)(parameters?.subClassOf).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.subClassOf.type, value)),
+        targetClasses: $convertToScalarSet(($convertToIri), true)(parameters?.targetClasses).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.targetClasses.type, value)),
+        targetNodes: $convertToScalarSet($identityConversionFunction, true)(parameters?.targetNodes).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.targetNodes.type, value)),
+        targetObjectsOf: $convertToScalarSet(($convertToIri), true)(parameters?.targetObjectsOf).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.targetObjectsOf.type, value)),
+        targetSubjectsOf: $convertToScalarSet(($convertToIri), true)(parameters?.targetSubjectsOf).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.targetSubjectsOf.type, value)),
+        types: $convertToScalarSet(($convertToIri), true)(parameters?.types).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.types.type, value)),
+        xone: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters?.xone).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.xone.type, value)),
+    })
+        .map((properties) => ({ ...properties, $type: "NodeShape" }))
+        .map((object) => $monkeyPatchObject(object, { $toString: NodeShape.$toString }));
+    function createUnsafe(parameters) {
+        return NodeShape.create(parameters).unsafeCoerce();
+    }
+    NodeShape.createUnsafe = createUnsafe;
+    NodeShape._fromRdfResource = (resource, options) => (!options.ignoreRdfType
+        ? $ensureRdfResourceType(resource, [NodeShape.schema.fromRdfType], {
+            graph: options.graph,
+        })
+        : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+        $identifier: $identifierFromRdfResourceValues($rdfResourceIdentifierValues(resource), {
+            ...options,
+            focusResource: resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            schema: NodeShape.schema.properties.$identifier.type,
+        }).chain((values) => values.head()),
+        and: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.and,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
+        }),
+        classes: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.classes,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        closed: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.closed,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        comment: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.comment,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        datatype: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.datatype,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        deactivated: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.deactivated,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        flags: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.flags,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        hasValues: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.hasValues,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($termFromRdfResourceValues)),
+        }),
+        ignoredProperties: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.ignoredProperties,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues(($iriFromRdfResourceValues))),
+        }),
+        in_: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.in_,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues(($termFromRdfResourceValues))),
+        }),
+        isDefinedBy: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.isDefinedBy,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        label: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.label,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        languageIn: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.languageIn,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues(($stringFromRdfResourceValues))),
+        }),
+        maxExclusive: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.maxExclusive,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
+        }),
+        maxInclusive: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.maxInclusive,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
+        }),
+        maxLength: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.maxLength,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
+        }),
+        message: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.message,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        minExclusive: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.minExclusive,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
+        }),
+        minInclusive: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.minInclusive,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
+        }),
+        minLength: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.minLength,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
+        }),
+        node: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.node,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        nodeKind: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.nodeKind,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        not: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.not,
+            typeFromRdfResourceValues: $setFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        or: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.or,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
+        }),
+        pattern: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.pattern,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        properties: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.properties,
+            typeFromRdfResourceValues: $setFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        severity: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.severity,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        subClassOf: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.subClassOf,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        targetClasses: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.targetClasses,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        targetNodes: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.targetNodes,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($termFromRdfResourceValues)),
+        }),
+        targetObjectsOf: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.targetObjectsOf,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        targetSubjectsOf: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.targetSubjectsOf,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        types: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.types,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        xone: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.xone,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
+        }),
+    }).chain((properties) => NodeShape.create(properties)));
+    NodeShape.fromRdfResource = $wrap_FromRdfResourceFunction(NodeShape._fromRdfResource);
+    NodeShape.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => NodeShape.fromRdfResource(resource, options)));
+    let Identifier;
+    (function (Identifier) {
+        Identifier.parse = $parseIdentifier;
+        Identifier.stringify = NTriplesTerm.stringify;
+    })(Identifier = NodeShape.Identifier || (NodeShape.Identifier = {}));
+    function isNodeShape(object) {
+        return object.$type === "NodeShape";
+    }
+    NodeShape.isNodeShape = isNodeShape;
+    NodeShape.schema = {
+        fromRdfType: dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"),
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: { kind: "Identifier" },
+            },
+            and: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#and"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
+            },
+            classes: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#class"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            closed: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#closed"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
+            },
+            comment: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            datatype: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"),
+                type: { kind: "Option", itemType: { kind: "Iri" } },
+            },
+            deactivated: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
+            },
+            flags: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            hasValues: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
+                },
+            },
+            ignoredProperties: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#ignoredProperties"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Iri" },
+                    },
+                },
+            },
+            in_: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#in"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: {
+                            kind: "Term",
+                            types: ["NamedNode", "Literal"],
+                        },
+                    },
+                },
+            },
+            isDefinedBy: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Identifier" },
+                },
+            },
+            label: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            languageIn: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#languageIn"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "String" },
+                    },
+                },
+            },
+            maxExclusive: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
+            },
+            maxInclusive: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxInclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
+            },
+            maxLength: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
+            },
+            message: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#message"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            minExclusive: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
+            },
+            minInclusive: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minInclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
+            },
+            minLength: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
+            },
+            node: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Identifier" },
+                },
+            },
+            nodeKind: {
+                kind: "Shacl",
+                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"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrIRI"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrLiteral"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#IRI"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#IRIOrLiteral"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#Literal"),
+                        ],
+                    },
+                },
+            },
+            not: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#not"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Identifier" },
+                },
+            },
+            or: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#or"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
+            },
+            pattern: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            properties: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#property"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Identifier" },
+                },
+            },
+            severity: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#severity"),
+                get type() {
+                    return {
+                        kind: "Option",
+                        get itemType() {
+                            return {
+                                kind: "Iri",
+                                in: [
+                                    dataFactory.namedNode("http://www.w3.org/ns/shacl#Info"),
+                                    dataFactory.namedNode("http://www.w3.org/ns/shacl#Warning"),
+                                    dataFactory.namedNode("http://www.w3.org/ns/shacl#Violation"),
+                                ],
+                            };
+                        },
+                    };
+                },
+            },
+            subClassOf: {
+                kind: "Shacl",
+                path: $RdfVocabularies.rdfs.subClassOf,
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            targetClasses: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetClass"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            targetNodes: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetNode"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
+                },
+            },
+            targetObjectsOf: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetObjectsOf"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            targetSubjectsOf: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetSubjectsOf"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            types: {
+                kind: "Shacl",
+                path: $RdfVocabularies.rdf.type,
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            xone: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
+            },
+        },
+        toRdfTypes: [dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape")],
+    };
+    NodeShape._toRdfResource = (parameters) => {
+        if (!parameters.ignoreRdfType) {
+            parameters.resource.add($RdfVocabularies.rdf.type, NodeShape.schema.toRdfTypes, parameters.graph);
+        }
+        parameters.resource.add(NodeShape.schema.properties.and.path, parameters.object.and.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = parameters.resourceSet.resource((() => dataFactory.blankNode())());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, parameters.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], parameters.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, parameters.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: parameters.resourceSet.resource((() => dataFactory.blankNode())()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.classes.path, parameters.object.classes.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.closed.path, parameters.object.closed
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.comment.path, parameters.object.comment
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.datatype.path, parameters.object.datatype.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.deactivated.path, parameters.object.deactivated
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.flags.path, parameters.object.flags
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.hasValues.path, parameters.object.hasValues.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.ignoredProperties.path, parameters.object.ignoredProperties.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = parameters.resourceSet.resource((() => dataFactory.blankNode())());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, parameters.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], parameters.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, parameters.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: parameters.resourceSet.resource((() => dataFactory.blankNode())()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.in_.path, parameters.object.in_.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = parameters.resourceSet.resource((() => dataFactory.blankNode())());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, parameters.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], parameters.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, parameters.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: parameters.resourceSet.resource((() => dataFactory.blankNode())()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.isDefinedBy.path, parameters.object.isDefinedBy.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.label.path, parameters.object.label
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.languageIn.path, parameters.object.languageIn.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = parameters.resourceSet.resource((() => dataFactory.blankNode())());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, parameters.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [$literalFactory.string(item)], parameters.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, parameters.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: parameters.resourceSet.resource((() => dataFactory.blankNode())()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.maxExclusive.path, parameters.object.maxExclusive.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.maxInclusive.path, parameters.object.maxInclusive.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.maxLength.path, parameters.object.maxLength
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.message.path, parameters.object.message
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.minExclusive.path, parameters.object.minExclusive.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.minInclusive.path, parameters.object.minInclusive.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.minLength.path, parameters.object.minLength
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.node.path, parameters.object.node.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.nodeKind.path, parameters.object.nodeKind.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.not.path, parameters.object.not.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.or.path, parameters.object.or.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = parameters.resourceSet.resource((() => dataFactory.blankNode())());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, parameters.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], parameters.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, parameters.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: parameters.resourceSet.resource((() => dataFactory.blankNode())()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.pattern.path, parameters.object.pattern
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.properties.path, parameters.object.properties.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.severity.path, parameters.object.severity.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.subClassOf.path, parameters.object.subClassOf.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.targetClasses.path, parameters.object.targetClasses.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.targetNodes.path, parameters.object.targetNodes.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.targetObjectsOf.path, parameters.object.targetObjectsOf.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.targetSubjectsOf.path, parameters.object.targetSubjectsOf.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.types.path, parameters.object.types.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.xone.path, parameters.object.xone.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = parameters.resourceSet.resource((() => dataFactory.blankNode())());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, parameters.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], parameters.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, parameters.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: parameters.resourceSet.resource((() => dataFactory.blankNode())()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), parameters.graph);
+        return parameters.resource;
+    };
+    NodeShape.toRdfResource = $wrap_ToRdfResourceFunction(NodeShape._toRdfResource);
+    NodeShape.$toString = (_nodeShape) => `NodeShape(${JSON.stringify(NodeShape.toStringRecord(_nodeShape))})`;
+    NodeShape.toStringRecord = (_nodeShape) => $compactRecord({
+        $identifier: _nodeShape.$identifier().toString(),
+        label: _nodeShape.label.map((item) => item.toString()).extract(),
+    });
+})(NodeShape || (NodeShape = {}));
+export var Ontology;
+(function (Ontology) {
+    Ontology.create = (parameters) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters?.$identifier),
+        comment: $convertToMaybe($identityConversionFunction)(parameters?.comment).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.comment.type, value)),
+        label: $convertToMaybe($identityConversionFunction)(parameters?.label).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.label.type, value)),
+    })
+        .map((properties) => ({ ...properties, $type: "Ontology" }))
+        .map((object) => $monkeyPatchObject(object, { $toString: Ontology.$toString }));
+    function createUnsafe(parameters) {
+        return Ontology.create(parameters).unsafeCoerce();
+    }
+    Ontology.createUnsafe = createUnsafe;
+    Ontology._fromRdfResource = (resource, options) => (!options.ignoreRdfType
+        ? $ensureRdfResourceType(resource, [Ontology.schema.fromRdfType], {
+            graph: options.graph,
+        })
+        : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+        $identifier: $identifierFromRdfResourceValues($rdfResourceIdentifierValues(resource), {
+            ...options,
+            focusResource: resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            schema: Ontology.schema.properties.$identifier.type,
+        }).chain((values) => values.head()),
+        comment: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.comment,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        label: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.label,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+    }).chain((properties) => Ontology.create(properties)));
+    Ontology.fromRdfResource = $wrap_FromRdfResourceFunction(Ontology._fromRdfResource);
+    Ontology.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => Ontology.fromRdfResource(resource, options)));
+    let Identifier;
+    (function (Identifier) {
+        Identifier.parse = $parseIdentifier;
+        Identifier.stringify = NTriplesTerm.stringify;
+    })(Identifier = Ontology.Identifier || (Ontology.Identifier = {}));
+    function isOntology(object) {
+        return object.$type === "Ontology";
+    }
+    Ontology.isOntology = isOntology;
+    Ontology.schema = {
+        fromRdfType: dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"),
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: { kind: "Identifier" },
+            },
+            comment: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            label: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+        },
+        toRdfTypes: [
+            dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"),
+        ],
+    };
+    Ontology._toRdfResource = (parameters) => {
+        if (!parameters.ignoreRdfType) {
+            parameters.resource.add($RdfVocabularies.rdf.type, Ontology.schema.toRdfTypes, parameters.graph);
+        }
+        parameters.resource.add(NodeShape.schema.properties.comment.path, parameters.object.comment
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.label.path, parameters.object.label
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        return parameters.resource;
+    };
+    Ontology.toRdfResource = $wrap_ToRdfResourceFunction(Ontology._toRdfResource);
+    Ontology.$toString = (_ontology) => `Ontology(${JSON.stringify(Ontology.toStringRecord(_ontology))})`;
+    Ontology.toStringRecord = (_ontology) => $compactRecord({
+        $identifier: _ontology.$identifier().toString(),
+        label: _ontology.label.map((item) => item.toString()).extract(),
+    });
+})(Ontology || (Ontology = {}));
+export var PropertyGroup;
+(function (PropertyGroup) {
+    PropertyGroup.create = (parameters) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters?.$identifier),
+        comment: $convertToMaybe($identityConversionFunction)(parameters?.comment).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.comment.type, value)),
+        label: $convertToMaybe($identityConversionFunction)(parameters?.label).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.label.type, value)),
+    })
+        .map((properties) => ({ ...properties, $type: "PropertyGroup" }))
+        .map((object) => $monkeyPatchObject(object, { $toString: PropertyGroup.$toString }));
+    function createUnsafe(parameters) {
+        return PropertyGroup.create(parameters).unsafeCoerce();
+    }
+    PropertyGroup.createUnsafe = createUnsafe;
+    PropertyGroup._fromRdfResource = (resource, options) => (!options.ignoreRdfType
+        ? $ensureRdfResourceType(resource, [PropertyGroup.schema.fromRdfType], {
+            graph: options.graph,
+        })
+        : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+        $identifier: $identifierFromRdfResourceValues($rdfResourceIdentifierValues(resource), {
+            ...options,
+            focusResource: resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            schema: PropertyGroup.schema.properties.$identifier.type,
+        }).chain((values) => values.head()),
+        comment: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.comment,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        label: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.label,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+    }).chain((properties) => PropertyGroup.create(properties)));
+    PropertyGroup.fromRdfResource = $wrap_FromRdfResourceFunction(PropertyGroup._fromRdfResource);
+    PropertyGroup.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => PropertyGroup.fromRdfResource(resource, options)));
+    let Identifier;
+    (function (Identifier) {
+        Identifier.parse = $parseIdentifier;
+        Identifier.stringify = NTriplesTerm.stringify;
+    })(Identifier = PropertyGroup.Identifier || (PropertyGroup.Identifier = {}));
+    function isPropertyGroup(object) {
+        return object.$type === "PropertyGroup";
+    }
+    PropertyGroup.isPropertyGroup = isPropertyGroup;
+    PropertyGroup.schema = {
+        fromRdfType: dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"),
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: { kind: "Identifier" },
+            },
+            comment: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            label: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+        },
+        toRdfTypes: [
+            dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"),
+        ],
+    };
+    PropertyGroup._toRdfResource = (parameters) => {
+        if (!parameters.ignoreRdfType) {
+            parameters.resource.add($RdfVocabularies.rdf.type, PropertyGroup.schema.toRdfTypes, parameters.graph);
+        }
+        parameters.resource.add(NodeShape.schema.properties.comment.path, parameters.object.comment
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.label.path, parameters.object.label
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        return parameters.resource;
+    };
+    PropertyGroup.toRdfResource = $wrap_ToRdfResourceFunction(PropertyGroup._toRdfResource);
+    PropertyGroup.$toString = (_propertyGroup) => `PropertyGroup(${JSON.stringify(PropertyGroup.toStringRecord(_propertyGroup))})`;
+    PropertyGroup.toStringRecord = (_propertyGroup) => $compactRecord({
+        $identifier: _propertyGroup.$identifier().toString(),
+        label: _propertyGroup.label.map((item) => item.toString()).extract(),
+    });
+})(PropertyGroup || (PropertyGroup = {}));
+export var PropertyShape;
+(function (PropertyShape) {
+    PropertyShape.create = (parameters) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters.$identifier),
+        and: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters.and).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.and.type, value)),
+        classes: $convertToScalarSet(($convertToIri), true)(parameters.classes).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.classes.type, value)),
+        comment: $convertToMaybe($identityConversionFunction)(parameters.comment).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.comment.type, value)),
+        datatype: $convertToMaybe(($convertToIri))(parameters.datatype).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.datatype.type, value)),
+        deactivated: $convertToMaybe($identityConversionFunction)(parameters.deactivated).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.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)),
+        disjoint: $convertToScalarSet(($convertToIri), true)(parameters.disjoint).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.disjoint.type, value)),
+        equals: $convertToScalarSet(($convertToIri), true)(parameters.equals).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.equals.type, value)),
+        flags: $convertToMaybe($identityConversionFunction)(parameters.flags).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.flags.type, value)),
+        groups: $convertToScalarSet($convertToIdentifier, true)(parameters.groups).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.groups.type, value)),
+        hasValues: $convertToScalarSet($identityConversionFunction, true)(parameters.hasValues).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.hasValues.type, value)),
+        in_: $convertToMaybe($convertToList($identityConversionFunction, true))(parameters.in_).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.in_.type, value)),
+        isDefinedBy: $convertToMaybe($convertToIdentifier)(parameters.isDefinedBy).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.isDefinedBy.type, value)),
+        label: $convertToMaybe($identityConversionFunction)(parameters.label).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.label.type, value)),
+        languageIn: $convertToMaybe($convertToList($identityConversionFunction, true))(parameters.languageIn).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.languageIn.type, value)),
+        lessThan: $convertToScalarSet(($convertToIri), true)(parameters.lessThan).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.lessThan.type, value)),
+        lessThanOrEquals: $convertToScalarSet(($convertToIri), true)(parameters.lessThanOrEquals).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.lessThanOrEquals.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)(NodeShape.schema.properties.maxExclusive.type, value)),
+        maxInclusive: $convertToMaybe($convertToLiteral)(parameters.maxInclusive).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxInclusive.type, value)),
+        maxLength: $convertToMaybe($identityConversionFunction)(parameters.maxLength).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxLength.type, value)),
+        message: $convertToMaybe($identityConversionFunction)(parameters.message).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.message.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)(NodeShape.schema.properties.minExclusive.type, value)),
+        minInclusive: $convertToMaybe($convertToLiteral)(parameters.minInclusive).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minInclusive.type, value)),
+        minLength: $convertToMaybe($identityConversionFunction)(parameters.minLength).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minLength.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)(NodeShape.schema.properties.node.type, value)),
+        nodeKind: $convertToMaybe(($convertToIri))(parameters.nodeKind).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.nodeKind.type, value)),
+        not: $convertToScalarSet($convertToIdentifier, true)(parameters.not).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.not.type, value)),
+        or: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters.or).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.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),
+        pattern: $convertToMaybe($identityConversionFunction)(parameters.pattern).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.pattern.type, value)),
+        qualifiedMaxCount: $convertToMaybe($identityConversionFunction)(parameters.qualifiedMaxCount).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedMaxCount.type, value)),
+        qualifiedMinCount: $convertToMaybe($identityConversionFunction)(parameters.qualifiedMinCount).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedMinCount.type, value)),
+        qualifiedValueShape: $convertToMaybe($convertToIdentifier)(parameters.qualifiedValueShape).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedValueShape.type, value)),
+        qualifiedValueShapesDisjoint: $convertToMaybe($identityConversionFunction)(parameters.qualifiedValueShapesDisjoint).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedValueShapesDisjoint.type, value)),
+        severity: $convertToMaybe(($convertToIri))(parameters.severity).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.severity.type, value)),
+        targetClasses: $convertToScalarSet(($convertToIri), true)(parameters.targetClasses).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.targetClasses.type, value)),
+        targetNodes: $convertToScalarSet($identityConversionFunction, true)(parameters.targetNodes).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.targetNodes.type, value)),
+        targetObjectsOf: $convertToScalarSet(($convertToIri), true)(parameters.targetObjectsOf).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.targetObjectsOf.type, value)),
+        targetSubjectsOf: $convertToScalarSet(($convertToIri), true)(parameters.targetSubjectsOf).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.targetSubjectsOf.type, value)),
+        uniqueLang: $convertToMaybe($identityConversionFunction)(parameters.uniqueLang).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.uniqueLang.type, value)),
+        xone: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters.xone).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.xone.type, value)),
+    })
+        .map((properties) => ({ ...properties, $type: "PropertyShape" }))
+        .map((object) => $monkeyPatchObject(object, { $toString: PropertyShape.$toString }));
+    function createUnsafe(parameters) {
+        return PropertyShape.create(parameters).unsafeCoerce();
+    }
+    PropertyShape.createUnsafe = createUnsafe;
+    PropertyShape._fromRdfResource = (resource, options) => (!options.ignoreRdfType
+        ? $ensureRdfResourceType(resource, [PropertyShape.schema.fromRdfType], {
+            graph: options.graph,
+        })
+        : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+        $identifier: $identifierFromRdfResourceValues($rdfResourceIdentifierValues(resource), {
+            ...options,
+            focusResource: resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            schema: PropertyShape.schema.properties.$identifier.type,
+        }).chain((values) => values.head()),
+        and: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.and,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
+        }),
+        classes: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.classes,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        comment: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.comment,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        datatype: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.datatype,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        deactivated: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.deactivated,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        defaultValue: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: PropertyShape.schema.properties.defaultValue,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($termFromRdfResourceValues)),
+        }),
+        description: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: PropertyShape.schema.properties.description,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        disjoint: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: PropertyShape.schema.properties.disjoint,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        equals: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: PropertyShape.schema.properties.equals,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        flags: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.flags,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        groups: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: PropertyShape.schema.properties.groups,
+            typeFromRdfResourceValues: $setFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        hasValues: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.hasValues,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($termFromRdfResourceValues)),
+        }),
+        in_: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.in_,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues(($termFromRdfResourceValues))),
+        }),
+        isDefinedBy: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.isDefinedBy,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        label: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.label,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        languageIn: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.languageIn,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues(($stringFromRdfResourceValues))),
+        }),
+        lessThan: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: PropertyShape.schema.properties.lessThan,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        lessThanOrEquals: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: PropertyShape.schema.properties.lessThanOrEquals,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        maxCount: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: PropertyShape.schema.properties.maxCount,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
+        }),
+        maxExclusive: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.maxExclusive,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
+        }),
+        maxInclusive: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.maxInclusive,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
+        }),
+        maxLength: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.maxLength,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
+        }),
+        message: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.message,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        minCount: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: PropertyShape.schema.properties.minCount,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
+        }),
+        minExclusive: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.minExclusive,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
+        }),
+        minInclusive: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.minInclusive,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
+        }),
+        minLength: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.minLength,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
+        }),
+        name: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: PropertyShape.schema.properties.name,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        node: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.node,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        nodeKind: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.nodeKind,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        not: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.not,
+            typeFromRdfResourceValues: $setFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        or: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.or,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
+        }),
+        order: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: PropertyShape.schema.properties.order,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($floatFromRdfResourceValues)),
+        }),
+        path: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: PropertyShape.schema.properties.path,
+            typeFromRdfResourceValues: $PropertyPath.fromRdfResourceValues,
+        }),
+        pattern: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.pattern,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        qualifiedMaxCount: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: PropertyShape.schema.properties.qualifiedMaxCount,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
+        }),
+        qualifiedMinCount: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: PropertyShape.schema.properties.qualifiedMinCount,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
+        }),
+        qualifiedValueShape: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: PropertyShape.schema.properties.qualifiedValueShape,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        qualifiedValueShapesDisjoint: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: PropertyShape.schema.properties.qualifiedValueShapesDisjoint,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        severity: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.severity,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        targetClasses: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.targetClasses,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        targetNodes: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.targetNodes,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($termFromRdfResourceValues)),
+        }),
+        targetObjectsOf: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.targetObjectsOf,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        targetSubjectsOf: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.targetSubjectsOf,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        uniqueLang: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: PropertyShape.schema.properties.uniqueLang,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        xone: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.xone,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
+        }),
+    }).chain((properties) => PropertyShape.create(properties)));
+    PropertyShape.fromRdfResource = $wrap_FromRdfResourceFunction(PropertyShape._fromRdfResource);
+    PropertyShape.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => PropertyShape.fromRdfResource(resource, options)));
+    let Identifier;
+    (function (Identifier) {
+        Identifier.parse = $parseIdentifier;
+        Identifier.stringify = NTriplesTerm.stringify;
+    })(Identifier = PropertyShape.Identifier || (PropertyShape.Identifier = {}));
+    function isPropertyShape(object) {
+        return object.$type === "PropertyShape";
+    }
+    PropertyShape.isPropertyShape = isPropertyShape;
+    PropertyShape.schema = {
+        fromRdfType: dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"),
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: { kind: "Identifier" },
+            },
+            and: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#and"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
+            },
+            classes: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#class"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            comment: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            datatype: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"),
+                type: { kind: "Option", itemType: { kind: "Iri" } },
+            },
+            deactivated: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
+            },
+            defaultValue: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#defaultValue"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
+                },
+            },
+            description: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#description"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            disjoint: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#disjoint"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            equals: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#equals"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            flags: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            groups: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#group"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Identifier" },
+                },
+            },
+            hasValues: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
+                },
+            },
+            in_: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#in"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: {
+                            kind: "Term",
+                            types: ["NamedNode", "Literal"],
+                        },
+                    },
+                },
+            },
+            isDefinedBy: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Identifier" },
+                },
+            },
+            label: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            languageIn: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#languageIn"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "String" },
+                    },
+                },
+            },
+            lessThan: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#lessThan"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            lessThanOrEquals: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#lessThanOrEquals"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            maxCount: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxCount"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
+            },
+            maxExclusive: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
+            },
+            maxInclusive: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxInclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
+            },
+            maxLength: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
+            },
+            message: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#message"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            minCount: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
+            },
+            minExclusive: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
+            },
+            minInclusive: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minInclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
+            },
+            minLength: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
+            },
+            name: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#name"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            node: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Identifier" },
+                },
+            },
+            nodeKind: {
+                kind: "Shacl",
+                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"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrIRI"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrLiteral"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#IRI"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#IRIOrLiteral"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#Literal"),
+                        ],
+                    },
+                },
+            },
+            not: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#not"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Identifier" },
+                },
+            },
+            or: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#or"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
+            },
+            order: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#order"),
+                type: { kind: "Option", itemType: { kind: "Float" } },
+            },
+            path: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#path"),
+                get type() {
+                    return $PropertyPath.schema;
+                },
+            },
+            pattern: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            qualifiedMaxCount: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#qualifiedMaxCount"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
+            },
+            qualifiedMinCount: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#qualifiedMinCount"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
+            },
+            qualifiedValueShape: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#qualifiedValueShape"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Identifier" },
+                },
+            },
+            qualifiedValueShapesDisjoint: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#qualifiedValueShapesDisjoint"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
+            },
+            severity: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#severity"),
+                get type() {
+                    return {
+                        kind: "Option",
+                        get itemType() {
+                            return {
+                                kind: "Iri",
+                                in: [
+                                    dataFactory.namedNode("http://www.w3.org/ns/shacl#Info"),
+                                    dataFactory.namedNode("http://www.w3.org/ns/shacl#Warning"),
+                                    dataFactory.namedNode("http://www.w3.org/ns/shacl#Violation"),
+                                ],
+                            };
+                        },
+                    };
+                },
+            },
+            targetClasses: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetClass"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            targetNodes: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetNode"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
+                },
+            },
+            targetObjectsOf: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetObjectsOf"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            targetSubjectsOf: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetSubjectsOf"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            uniqueLang: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
+            },
+            xone: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
+            },
+        },
+        toRdfTypes: [
+            dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"),
+        ],
+    };
+    PropertyShape._toRdfResource = (parameters) => {
+        if (!parameters.ignoreRdfType) {
+            parameters.resource.add($RdfVocabularies.rdf.type, PropertyShape.schema.toRdfTypes, parameters.graph);
+        }
+        parameters.resource.add(NodeShape.schema.properties.and.path, parameters.object.and.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = parameters.resourceSet.resource((() => dataFactory.blankNode())());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, parameters.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], parameters.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, parameters.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: parameters.resourceSet.resource((() => dataFactory.blankNode())()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.classes.path, parameters.object.classes.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.comment.path, parameters.object.comment
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.datatype.path, parameters.object.datatype.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.deactivated.path, parameters.object.deactivated
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
+        ]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.defaultValue.path, parameters.object.defaultValue.toList(), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.description.path, parameters.object.description
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.disjoint.path, parameters.object.disjoint.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.equals.path, parameters.object.equals.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.flags.path, parameters.object.flags
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.groups.path, parameters.object.groups.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.hasValues.path, parameters.object.hasValues.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.in_.path, parameters.object.in_.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = parameters.resourceSet.resource((() => dataFactory.blankNode())());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, parameters.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], parameters.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, parameters.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: parameters.resourceSet.resource((() => dataFactory.blankNode())()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.isDefinedBy.path, parameters.object.isDefinedBy.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.label.path, parameters.object.label
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.languageIn.path, parameters.object.languageIn.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = parameters.resourceSet.resource((() => dataFactory.blankNode())());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, parameters.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [$literalFactory.string(item)], parameters.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, parameters.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: parameters.resourceSet.resource((() => dataFactory.blankNode())()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.lessThan.path, parameters.object.lessThan.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.lessThanOrEquals.path, parameters.object.lessThanOrEquals.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.maxCount.path, parameters.object.maxCount
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.maxExclusive.path, parameters.object.maxExclusive.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.maxInclusive.path, parameters.object.maxInclusive.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.maxLength.path, parameters.object.maxLength
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.message.path, parameters.object.message
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.minCount.path, parameters.object.minCount
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.minExclusive.path, parameters.object.minExclusive.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.minInclusive.path, parameters.object.minInclusive.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.minLength.path, parameters.object.minLength
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
+        ]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.name.path, parameters.object.name
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.node.path, parameters.object.node.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.nodeKind.path, parameters.object.nodeKind.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.not.path, parameters.object.not.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.or.path, parameters.object.or.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = parameters.resourceSet.resource((() => dataFactory.blankNode())());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, parameters.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], parameters.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, parameters.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: parameters.resourceSet.resource((() => dataFactory.blankNode())()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.order.path, parameters.object.order
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.number(value, $RdfVocabularies.xsd.double),
+        ]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.path.path, [
+            $PropertyPath.toRdfResource(parameters.object.path, {
+                graph: parameters.graph,
+                resourceSet: parameters.resourceSet,
+            }).identifier,
+        ], parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.pattern.path, parameters.object.pattern
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.qualifiedMaxCount.path, parameters.object.qualifiedMaxCount
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
+        ]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.qualifiedMinCount.path, parameters.object.qualifiedMinCount
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
+        ]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.qualifiedValueShape.path, parameters.object.qualifiedValueShape.toList(), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.qualifiedValueShapesDisjoint.path, parameters.object.qualifiedValueShapesDisjoint
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.severity.path, parameters.object.severity.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.targetClasses.path, parameters.object.targetClasses.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.targetNodes.path, parameters.object.targetNodes.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.targetObjectsOf.path, parameters.object.targetObjectsOf.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.targetSubjectsOf.path, parameters.object.targetSubjectsOf.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.uniqueLang.path, parameters.object.uniqueLang
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.xone.path, parameters.object.xone.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = parameters.resourceSet.resource((() => dataFactory.blankNode())());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, parameters.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], parameters.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, parameters.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: parameters.resourceSet.resource((() => dataFactory.blankNode())()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), parameters.graph);
+        return parameters.resource;
+    };
+    PropertyShape.toRdfResource = $wrap_ToRdfResourceFunction(PropertyShape._toRdfResource);
+    PropertyShape.$toString = (_propertyShape) => `PropertyShape(${JSON.stringify(PropertyShape.toStringRecord(_propertyShape))})`;
+    PropertyShape.toStringRecord = (_propertyShape) => $compactRecord({
+        $identifier: _propertyShape.$identifier().toString(),
+        label: _propertyShape.label.map((item) => item.toString()).extract(),
+        name: _propertyShape.name.map((item) => item.toString()).extract(),
+        path: $PropertyPath.$toString(_propertyShape.path),
+    });
+})(PropertyShape || (PropertyShape = {}));
+export var ValidationReport;
+(function (ValidationReport) {
+    ValidationReport.create = (parameters) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters.$identifier),
+        conforms: Either.of(parameters.conforms),
+        results: $convertToScalarSet($identityConversionFunction, true)(parameters.results).chain((value) => $validateArray($identityValidationFunction, true)(ValidationReport.schema.properties.results.type, value)),
+        shapesGraphWellFormed: $convertToMaybe($identityConversionFunction)(parameters.shapesGraphWellFormed).chain((value) => $validateMaybe($identityValidationFunction)(ValidationReport.schema.properties.shapesGraphWellFormed.type, value)),
+    })
+        .map((properties) => ({
+        ...properties,
+        $type: "ValidationReport",
+    }))
+        .map((object) => $monkeyPatchObject(object, { $toString: ValidationReport.$toString }));
+    function createUnsafe(parameters) {
+        return ValidationReport.create(parameters).unsafeCoerce();
+    }
+    ValidationReport.createUnsafe = createUnsafe;
+    ValidationReport._fromRdfResource = (resource, options) => (!options.ignoreRdfType
+        ? $ensureRdfResourceType(resource, [ValidationReport.schema.fromRdfType], { graph: options.graph })
+        : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+        $identifier: $identifierFromRdfResourceValues($rdfResourceIdentifierValues(resource), {
+            ...options,
+            focusResource: resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            schema: ValidationReport.schema.properties.$identifier.type,
+        }).chain((values) => values.head()),
+        conforms: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: ValidationReport.schema.properties.conforms,
+            typeFromRdfResourceValues: ($booleanFromRdfResourceValues),
+        }),
+        results: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: ValidationReport.schema.properties.results,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(ValidationResult.fromRdfResourceValues),
+        }),
+        shapesGraphWellFormed: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: ValidationReport.schema.properties.shapesGraphWellFormed,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+    }).chain((properties) => ValidationReport.create(properties)));
+    ValidationReport.fromRdfResource = $wrap_FromRdfResourceFunction(ValidationReport._fromRdfResource);
+    ValidationReport.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => ValidationReport.fromRdfResource(resource, options)));
+    let Identifier;
+    (function (Identifier) {
+        Identifier.parse = $parseIdentifier;
+        Identifier.stringify = NTriplesTerm.stringify;
+    })(Identifier = ValidationReport.Identifier || (ValidationReport.Identifier = {}));
+    function isValidationReport(object) {
+        return object.$type === "ValidationReport";
+    }
+    ValidationReport.isValidationReport = isValidationReport;
+    ValidationReport.schema = {
+        fromRdfType: dataFactory.namedNode("http://www.w3.org/ns/shacl#ValidationReport"),
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: { kind: "Identifier" },
+            },
+            conforms: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#conforms"),
+                type: { kind: "Boolean" },
+            },
+            results: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#result"),
+                get type() {
+                    return {
+                        kind: "Set",
+                        get itemType() {
+                            return ValidationResult.schema;
+                        },
+                    };
+                },
+            },
+            shapesGraphWellFormed: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#shapesGraphWellFormed"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
+            },
+        },
+        toRdfTypes: [
+            dataFactory.namedNode("http://www.w3.org/ns/shacl#ValidationReport"),
+        ],
+    };
+    ValidationReport._toRdfResource = (parameters) => {
+        if (!parameters.ignoreRdfType) {
+            parameters.resource.add($RdfVocabularies.rdf.type, ValidationReport.schema.toRdfTypes, parameters.graph);
+        }
+        parameters.resource.add(ValidationReport.schema.properties.conforms.path, [
+            $literalFactory.boolean(parameters.object.conforms, $RdfVocabularies.xsd.boolean),
+        ], parameters.graph);
+        parameters.resource.add(ValidationReport.schema.properties.results.path, parameters.object.results.flatMap((item) => [
+            ValidationResult.toRdfResource(item, {
+                graph: parameters.graph,
+                resourceSet: parameters.resourceSet,
+            }).identifier,
+        ]), parameters.graph);
+        parameters.resource.add(ValidationReport.schema.properties.shapesGraphWellFormed.path, parameters.object.shapesGraphWellFormed
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
+        ]), parameters.graph);
+        return parameters.resource;
+    };
+    ValidationReport.toRdfResource = $wrap_ToRdfResourceFunction(ValidationReport._toRdfResource);
+    ValidationReport.$toString = (_validationReport) => `ValidationReport(${JSON.stringify(ValidationReport.toStringRecord(_validationReport))})`;
+    ValidationReport.toStringRecord = (_validationReport) => $compactRecord({ $identifier: _validationReport.$identifier().toString() });
+})(ValidationReport || (ValidationReport = {}));
+export var ValidationResult;
+(function (ValidationResult) {
+    ValidationResult.create = (parameters) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters.$identifier),
+        details: $convertToScalarSet($identityConversionFunction, true)(parameters.details).chain((value) => $validateArray($identityValidationFunction, true)(ValidationResult.schema.properties.details.type, value)),
+        focusNode: Either.of(parameters.focusNode),
+        message: $convertToMaybe($identityConversionFunction)(parameters.message).chain((value) => $validateMaybe($identityValidationFunction)(ValidationResult.schema.properties.message.type, value)),
+        path: $convertToMaybe($identityConversionFunction)(parameters.path).chain((value) => $validateMaybe($identityValidationFunction)(ValidationResult.schema.properties.path.type, value)),
+        severity: $convertToIri(parameters.severity),
+        sourceConstraintComponent: $convertToIri(parameters.sourceConstraintComponent),
+        sourceShape: $convertToMaybe($convertToIdentifier)(parameters.sourceShape).chain((value) => $validateMaybe($identityValidationFunction)(ValidationResult.schema.properties.sourceShape.type, value)),
+        value: $convertToMaybe($identityConversionFunction)(parameters.value).chain((value) => $validateMaybe($identityValidationFunction)(ValidationResult.schema.properties.value.type, value)),
+    })
+        .map((properties) => ({
+        ...properties,
+        $type: "ValidationResult",
+    }))
+        .map((object) => $monkeyPatchObject(object, { $toString: ValidationResult.$toString }));
+    function createUnsafe(parameters) {
+        return ValidationResult.create(parameters).unsafeCoerce();
+    }
+    ValidationResult.createUnsafe = createUnsafe;
+    ValidationResult._fromRdfResource = (resource, options) => (!options.ignoreRdfType
+        ? $ensureRdfResourceType(resource, [ValidationResult.schema.fromRdfType], { graph: options.graph })
+        : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+        $identifier: $identifierFromRdfResourceValues($rdfResourceIdentifierValues(resource), {
+            ...options,
+            focusResource: resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            schema: ValidationResult.schema.properties.$identifier.type,
+        }).chain((values) => values.head()),
+        details: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: ValidationResult.schema.properties.details,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($termFromRdfResourceValues)),
+        }),
+        focusNode: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: ValidationResult.schema.properties.focusNode,
+            typeFromRdfResourceValues: ($termFromRdfResourceValues),
+        }),
+        message: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: ValidationResult.schema.properties.message,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        path: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: ValidationResult.schema.properties.path,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($PropertyPath.fromRdfResourceValues),
+        }),
+        severity: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: ValidationResult.schema.properties.severity,
+            typeFromRdfResourceValues: ($iriFromRdfResourceValues),
+        }),
+        sourceConstraintComponent: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: ValidationResult.schema.properties.sourceConstraintComponent,
+            typeFromRdfResourceValues: ($iriFromRdfResourceValues),
+        }),
+        sourceShape: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: ValidationResult.schema.properties.sourceShape,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        value: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: ValidationResult.schema.properties.value,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($termFromRdfResourceValues)),
+        }),
+    }).chain((properties) => ValidationResult.create(properties)));
+    ValidationResult.fromRdfResource = $wrap_FromRdfResourceFunction(ValidationResult._fromRdfResource);
+    ValidationResult.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => ValidationResult.fromRdfResource(resource, options)));
+    let Identifier;
+    (function (Identifier) {
+        Identifier.parse = $parseIdentifier;
+        Identifier.stringify = NTriplesTerm.stringify;
+    })(Identifier = ValidationResult.Identifier || (ValidationResult.Identifier = {}));
+    function isValidationResult(object) {
+        return object.$type === "ValidationResult";
+    }
+    ValidationResult.isValidationResult = isValidationResult;
+    ValidationResult.schema = {
+        fromRdfType: dataFactory.namedNode("http://www.w3.org/ns/shacl#ValidationResult"),
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: { kind: "Identifier" },
+            },
+            details: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#detail"),
+                type: {
+                    kind: "Set",
+                    itemType: {
+                        kind: "Term",
+                        types: ["BlankNode", "NamedNode", "Literal"],
+                    },
+                },
+            },
+            focusNode: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#focusNode"),
+                type: {
+                    kind: "Term",
+                    types: ["BlankNode", "NamedNode", "Literal"],
+                },
+            },
+            message: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#resultMessage"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            path: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#resultPath"),
+                get type() {
+                    return {
+                        kind: "Option",
+                        get itemType() {
+                            return $PropertyPath.schema;
+                        },
+                    };
+                },
+            },
+            severity: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#resultSeverity"),
+                get type() {
+                    return {
+                        kind: "Iri",
+                        in: [
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#Info"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#Warning"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#Violation"),
+                        ],
+                    };
+                },
+            },
+            sourceConstraintComponent: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#sourceConstraintComponent"),
+                type: { kind: "Iri" },
+            },
+            sourceShape: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#sourceShape"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Identifier" },
+                },
+            },
+            value: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#value"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "Term",
+                        types: ["BlankNode", "NamedNode", "Literal"],
+                    },
+                },
+            },
+        },
+        toRdfTypes: [
+            dataFactory.namedNode("http://www.w3.org/ns/shacl#ValidationResult"),
+        ],
+    };
+    ValidationResult._toRdfResource = (parameters) => {
+        if (!parameters.ignoreRdfType) {
+            parameters.resource.add($RdfVocabularies.rdf.type, ValidationResult.schema.toRdfTypes, parameters.graph);
+        }
+        parameters.resource.add(ValidationResult.schema.properties.details.path, parameters.object.details.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(ValidationResult.schema.properties.focusNode.path, [parameters.object.focusNode], parameters.graph);
+        parameters.resource.add(ValidationResult.schema.properties.message.path, parameters.object.message
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(ValidationResult.schema.properties.path.path, parameters.object.path.toList().flatMap((value) => [
+            $PropertyPath.toRdfResource(value, {
+                graph: parameters.graph,
+                resourceSet: parameters.resourceSet,
+            }).identifier,
+        ]), parameters.graph);
+        parameters.resource.add(ValidationResult.schema.properties.severity.path, [parameters.object.severity], parameters.graph);
+        parameters.resource.add(ValidationResult.schema.properties.sourceConstraintComponent.path, [parameters.object.sourceConstraintComponent], parameters.graph);
+        parameters.resource.add(ValidationResult.schema.properties.sourceShape.path, parameters.object.sourceShape.toList(), parameters.graph);
+        parameters.resource.add(ValidationResult.schema.properties.value.path, parameters.object.value.toList(), parameters.graph);
+        return parameters.resource;
+    };
+    ValidationResult.toRdfResource = $wrap_ToRdfResourceFunction(ValidationResult._toRdfResource);
+    ValidationResult.$toString = (_validationResult) => `ValidationResult(${JSON.stringify(ValidationResult.toStringRecord(_validationResult))})`;
+    ValidationResult.toStringRecord = (_validationResult) => $compactRecord({ $identifier: _validationResult.$identifier().toString() });
+})(ValidationResult || (ValidationResult = {}));
+export var Shape;
+(function (Shape) {
+    Shape.$toString = (value) => {
+        if (NodeShape.isNodeShape(value)) {
+            return NodeShape.$toString(value);
+        }
+        if (PropertyShape.isPropertyShape(value)) {
+            return PropertyShape.$toString(value);
+        }
+        throw new Error("unable to serialize to string");
+    };
+    Shape.fromRdfResource = (resource, options) => NodeShape.fromRdfResource(resource, {
+        ...options,
+        ignoreRdfType: false,
+    }).altLazy(() => PropertyShape.fromRdfResource(resource, {
+        ...options,
+        ignoreRdfType: false,
+    }));
+    Shape.fromRdfResourceValues = ((values, options) => values.chainMap((value) => {
+        const valueAsValues = value.toValues();
+        return NodeShape.fromRdfResourceValues(valueAsValues, {
+            ...options,
+            schema: options.schema.members["NodeShape"].type,
+        })
+            .altLazy(() => PropertyShape.fromRdfResourceValues(valueAsValues, {
+            ...options,
+            schema: options.schema.members["PropertyShape"].type,
+        }))
+            .chain((values) => values.head());
+    }));
+    let Identifier;
+    (function (Identifier) {
+        Identifier.parse = $parseIdentifier;
+        Identifier.stringify = NTriplesTerm.stringify;
+    })(Identifier = Shape.Identifier || (Shape.Identifier = {}));
+    function isShape(object) {
+        return (NodeShape.isNodeShape(object) || PropertyShape.isPropertyShape(object));
+    }
+    Shape.isShape = isShape;
+    Shape.schema = {
+        kind: "ObjectUnion",
+        members: {
+            NodeShape: { discriminantValues: ["NodeShape"], type: NodeShape.schema },
+            PropertyShape: {
+                discriminantValues: ["PropertyShape"],
+                type: PropertyShape.schema,
+            },
+        },
+        properties: {
+            and: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#and"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
+            },
+            classes: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#class"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            comment: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            datatype: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"),
+                type: { kind: "Option", itemType: { kind: "Iri" } },
+            },
+            deactivated: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
+            },
+            flags: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            hasValues: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
+                },
+            },
+            in_: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#in"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: {
+                            kind: "Term",
+                            types: ["NamedNode", "Literal"],
+                        },
+                    },
+                },
+            },
+            isDefinedBy: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Identifier" },
+                },
+            },
+            label: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            languageIn: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#languageIn"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "String" },
+                    },
+                },
+            },
+            maxExclusive: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
+            },
+            maxInclusive: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxInclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
+            },
+            maxLength: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
+            },
+            message: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#message"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            minExclusive: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
+            },
+            minInclusive: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minInclusive"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Literal" },
+                },
+            },
+            minLength: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
+            },
+            node: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Identifier" },
+                },
+            },
+            nodeKind: {
+                kind: "Shacl",
+                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"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrIRI"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrLiteral"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#IRI"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#IRIOrLiteral"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#Literal"),
+                        ],
+                    },
+                },
+            },
+            not: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#not"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Identifier" },
+                },
+            },
+            or: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#or"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
+            },
+            pattern: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            severity: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#severity"),
+                get type() {
+                    return {
+                        kind: "Option",
+                        get itemType() {
+                            return {
+                                kind: "Iri",
+                                in: [
+                                    dataFactory.namedNode("http://www.w3.org/ns/shacl#Info"),
+                                    dataFactory.namedNode("http://www.w3.org/ns/shacl#Warning"),
+                                    dataFactory.namedNode("http://www.w3.org/ns/shacl#Violation"),
+                                ],
+                            };
+                        },
+                    };
+                },
+            },
+            targetClasses: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetClass"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            targetNodes: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetNode"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
+                },
+            },
+            targetObjectsOf: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetObjectsOf"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            targetSubjectsOf: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetSubjectsOf"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            xone: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
+            },
+        },
+    };
+    Shape.toRdfResource = (object, options) => {
+        if (NodeShape.isNodeShape(object)) {
+            return NodeShape.toRdfResource(object, options);
+        }
+        if (PropertyShape.isPropertyShape(object)) {
+            return PropertyShape.toRdfResource(object, options);
+        }
+        throw new Error("unrecognized type");
+    };
+    Shape.toRdfResourceValues = ((value, _options) => {
+        if (NodeShape.isNodeShape(value)) {
+            return [
+                NodeShape.toRdfResource(value, {
+                    graph: _options.graph,
+                    resourceSet: _options.resourceSet,
+                }).identifier,
+            ];
+        }
+        if (PropertyShape.isPropertyShape(value)) {
+            return [
+                PropertyShape.toRdfResource(value, {
+                    graph: _options.graph,
+                    resourceSet: _options.resourceSet,
+                }).identifier,
+            ];
+        }
+        throw new Error("unable to serialize to RDF");
+    });
+})(Shape || (Shape = {}));
+export var $Object;
+(function ($Object) {
+    $Object.$toString = (value) => {
+        if (NodeShape.isNodeShape(value)) {
+            return NodeShape.$toString(value);
+        }
+        if (Ontology.isOntology(value)) {
+            return Ontology.$toString(value);
+        }
+        if (PropertyGroup.isPropertyGroup(value)) {
+            return PropertyGroup.$toString(value);
+        }
+        if (PropertyShape.isPropertyShape(value)) {
+            return PropertyShape.$toString(value);
+        }
+        if (ValidationReport.isValidationReport(value)) {
+            return ValidationReport.$toString(value);
+        }
+        if (ValidationResult.isValidationResult(value)) {
+            return ValidationResult.$toString(value);
+        }
+        throw new Error("unable to serialize to string");
+    };
+    $Object.fromRdfResource = (resource, options) => NodeShape.fromRdfResource(resource, {
+        ...options,
+        ignoreRdfType: false,
+    })
+        .altLazy(() => Ontology.fromRdfResource(resource, {
+        ...options,
+        ignoreRdfType: false,
+    }))
+        .altLazy(() => PropertyGroup.fromRdfResource(resource, {
+        ...options,
+        ignoreRdfType: false,
+    }))
+        .altLazy(() => PropertyShape.fromRdfResource(resource, {
+        ...options,
+        ignoreRdfType: false,
+    }))
+        .altLazy(() => ValidationReport.fromRdfResource(resource, {
+        ...options,
+        ignoreRdfType: false,
+    }))
+        .altLazy(() => ValidationResult.fromRdfResource(resource, {
+        ...options,
+        ignoreRdfType: false,
+    }));
+    $Object.fromRdfResourceValues = ((values, options) => values.chainMap((value) => {
+        const valueAsValues = value.toValues();
+        return NodeShape.fromRdfResourceValues(valueAsValues, {
+            ...options,
+            schema: options.schema.members["NodeShape"].type,
+        })
+            .altLazy(() => Ontology.fromRdfResourceValues(valueAsValues, {
+            ...options,
+            schema: options.schema.members["Ontology"].type,
+        }))
+            .altLazy(() => PropertyGroup.fromRdfResourceValues(valueAsValues, {
+            ...options,
+            schema: options.schema.members["PropertyGroup"].type,
+        }))
+            .altLazy(() => PropertyShape.fromRdfResourceValues(valueAsValues, {
+            ...options,
+            schema: options.schema.members["PropertyShape"].type,
+        }))
+            .altLazy(() => ValidationReport.fromRdfResourceValues(valueAsValues, {
+            ...options,
+            schema: options.schema.members["ValidationReport"].type,
+        }))
+            .altLazy(() => ValidationResult.fromRdfResourceValues(valueAsValues, {
+            ...options,
+            schema: options.schema.members["ValidationResult"].type,
+        }))
+            .chain((values) => values.head());
+    }));
+    let Identifier;
+    (function (Identifier) {
+        Identifier.parse = $parseIdentifier;
+        Identifier.stringify = NTriplesTerm.stringify;
+    })(Identifier = $Object.Identifier || ($Object.Identifier = {}));
+    $Object.schema = {
+        kind: "ObjectUnion",
+        members: {
+            NodeShape: { discriminantValues: ["NodeShape"], type: NodeShape.schema },
+            Ontology: { discriminantValues: ["Ontology"], type: Ontology.schema },
+            PropertyGroup: {
+                discriminantValues: ["PropertyGroup"],
+                type: PropertyGroup.schema,
+            },
+            PropertyShape: {
+                discriminantValues: ["PropertyShape"],
+                type: PropertyShape.schema,
+            },
+            ValidationReport: {
+                discriminantValues: ["ValidationReport"],
+                type: ValidationReport.schema,
+            },
+            ValidationResult: {
+                discriminantValues: ["ValidationResult"],
+                type: ValidationResult.schema,
+            },
+        },
+        properties: {},
+    };
+    $Object.toRdfResource = (object, options) => {
+        if (NodeShape.isNodeShape(object)) {
+            return NodeShape.toRdfResource(object, options);
+        }
+        if (Ontology.isOntology(object)) {
+            return Ontology.toRdfResource(object, options);
+        }
+        if (PropertyGroup.isPropertyGroup(object)) {
+            return PropertyGroup.toRdfResource(object, options);
+        }
+        if (PropertyShape.isPropertyShape(object)) {
+            return PropertyShape.toRdfResource(object, options);
+        }
+        if (ValidationReport.isValidationReport(object)) {
+            return ValidationReport.toRdfResource(object, options);
+        }
+        if (ValidationResult.isValidationResult(object)) {
+            return ValidationResult.toRdfResource(object, options);
+        }
+        throw new Error("unrecognized type");
+    };
+    $Object.toRdfResourceValues = ((value, _options) => {
+        if (NodeShape.isNodeShape(value)) {
+            return [
+                NodeShape.toRdfResource(value, {
+                    graph: _options.graph,
+                    resourceSet: _options.resourceSet,
+                }).identifier,
+            ];
+        }
+        if (Ontology.isOntology(value)) {
+            return [
+                Ontology.toRdfResource(value, {
+                    graph: _options.graph,
+                    resourceSet: _options.resourceSet,
+                }).identifier,
+            ];
+        }
+        if (PropertyGroup.isPropertyGroup(value)) {
+            return [
+                PropertyGroup.toRdfResource(value, {
+                    graph: _options.graph,
+                    resourceSet: _options.resourceSet,
+                }).identifier,
+            ];
+        }
+        if (PropertyShape.isPropertyShape(value)) {
+            return [
+                PropertyShape.toRdfResource(value, {
+                    graph: _options.graph,
+                    resourceSet: _options.resourceSet,
+                }).identifier,
+            ];
+        }
+        if (ValidationReport.isValidationReport(value)) {
+            return [
+                ValidationReport.toRdfResource(value, {
+                    graph: _options.graph,
+                    resourceSet: _options.resourceSet,
+                }).identifier,
+            ];
+        }
+        if (ValidationResult.isValidationResult(value)) {
+            return [
+                ValidationResult.toRdfResource(value, {
+                    graph: _options.graph,
+                    resourceSet: _options.resourceSet,
+                }).identifier,
+            ];
+        }
+        throw new Error("unable to serialize to RDF");
+    });
+})($Object || ($Object = {}));
+//# sourceMappingURL=shacl-ast.shaclmate.js.map