@shaclmate/shacl-ast 4.0.49 → 4.0.50

package/dist/generated.js

@@ -1,3473 +0,0 @@
-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 = {}));
-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(new Resource.Value({
-            dataFactory: dataFactory,
-            focusResource: $resource,
-            propertyPath: $RdfVocabularies.rdf.subject,
-            term: $resource.identifier,
-        }).toValues(), {
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            preferredLanguages: _$options.preferredLanguages,
-            propertyPath: $RdfVocabularies.rdf.subject,
-            schema: NodeShape.schema.properties.$identifier.type,
-        }).chain((values) => values.head()),
-        and: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.and,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
-        }),
-        classes: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.classes,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        closed: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.closed,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
-        }),
-        comment: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.comment,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
-        }),
-        datatype: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.datatype,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        deactivated: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.deactivated,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
-        }),
-        flags: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.flags,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
-        }),
-        hasValues: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.hasValues,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($termFromRdfResourceValues)),
-        }),
-        ignoredProperties: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.ignoredProperties,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues(($iriFromRdfResourceValues))),
-        }),
-        in_: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.in_,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues(($termFromRdfResourceValues))),
-        }),
-        isDefinedBy: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.isDefinedBy,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
-        }),
-        label: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.label,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
-        }),
-        languageIn: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.languageIn,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues(($stringFromRdfResourceValues))),
-        }),
-        maxExclusive: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.maxExclusive,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
-        }),
-        maxInclusive: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.maxInclusive,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
-        }),
-        maxLength: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.maxLength,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
-        }),
-        message: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.message,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
-        }),
-        minExclusive: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.minExclusive,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
-        }),
-        minInclusive: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.minInclusive,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
-        }),
-        minLength: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.minLength,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
-        }),
-        node: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.node,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
-        }),
-        nodeKind: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.nodeKind,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        not: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.not,
-            typeFromRdfResourceValues: $setFromRdfResourceValues($identifierFromRdfResourceValues),
-        }),
-        or: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.or,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
-        }),
-        pattern: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.pattern,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
-        }),
-        properties: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.properties,
-            typeFromRdfResourceValues: $setFromRdfResourceValues($identifierFromRdfResourceValues),
-        }),
-        severity: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.severity,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        subClassOf: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.subClassOf,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        targetClasses: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.targetClasses,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        targetNodes: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.targetNodes,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($termFromRdfResourceValues)),
-        }),
-        targetObjectsOf: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.targetObjectsOf,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        targetSubjectsOf: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.targetSubjectsOf,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        types: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.types,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        xone: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            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" },
-                    },
-                },
-            },
-        },
-    };
-    NodeShape._toRdfResource = (parameters) => {
-        if (!parameters.ignoreRdfType) {
-            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"), 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(new Resource.Value({
-            dataFactory: dataFactory,
-            focusResource: $resource,
-            propertyPath: $RdfVocabularies.rdf.subject,
-            term: $resource.identifier,
-        }).toValues(), {
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            preferredLanguages: _$options.preferredLanguages,
-            propertyPath: $RdfVocabularies.rdf.subject,
-            schema: Ontology.schema.properties.$identifier.type,
-        }).chain((values) => values.head()),
-        comment: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.comment,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
-        }),
-        label: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            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" },
-                },
-            },
-        },
-    };
-    Ontology._toRdfResource = (parameters) => {
-        if (!parameters.ignoreRdfType) {
-            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"), 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(new Resource.Value({
-            dataFactory: dataFactory,
-            focusResource: $resource,
-            propertyPath: $RdfVocabularies.rdf.subject,
-            term: $resource.identifier,
-        }).toValues(), {
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            preferredLanguages: _$options.preferredLanguages,
-            propertyPath: $RdfVocabularies.rdf.subject,
-            schema: PropertyGroup.schema.properties.$identifier.type,
-        }).chain((values) => values.head()),
-        comment: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.comment,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
-        }),
-        label: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            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" },
-                },
-            },
-        },
-    };
-    PropertyGroup._toRdfResource = (parameters) => {
-        if (!parameters.ignoreRdfType) {
-            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"), 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(new Resource.Value({
-            dataFactory: dataFactory,
-            focusResource: $resource,
-            propertyPath: $RdfVocabularies.rdf.subject,
-            term: $resource.identifier,
-        }).toValues(), {
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            preferredLanguages: _$options.preferredLanguages,
-            propertyPath: $RdfVocabularies.rdf.subject,
-            schema: PropertyShape.schema.properties.$identifier.type,
-        }).chain((values) => values.head()),
-        and: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.and,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
-        }),
-        classes: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.classes,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        comment: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.comment,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
-        }),
-        datatype: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.datatype,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        deactivated: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.deactivated,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
-        }),
-        defaultValue: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: PropertyShape.schema.properties.defaultValue,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($termFromRdfResourceValues)),
-        }),
-        description: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: PropertyShape.schema.properties.description,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
-        }),
-        disjoint: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: PropertyShape.schema.properties.disjoint,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        equals: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: PropertyShape.schema.properties.equals,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        flags: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.flags,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
-        }),
-        groups: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: PropertyShape.schema.properties.groups,
-            typeFromRdfResourceValues: $setFromRdfResourceValues($identifierFromRdfResourceValues),
-        }),
-        hasValues: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.hasValues,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($termFromRdfResourceValues)),
-        }),
-        in_: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.in_,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues(($termFromRdfResourceValues))),
-        }),
-        isDefinedBy: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.isDefinedBy,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
-        }),
-        label: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.label,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
-        }),
-        languageIn: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.languageIn,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues(($stringFromRdfResourceValues))),
-        }),
-        lessThan: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: PropertyShape.schema.properties.lessThan,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        lessThanOrEquals: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: PropertyShape.schema.properties.lessThanOrEquals,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        maxCount: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: PropertyShape.schema.properties.maxCount,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
-        }),
-        maxExclusive: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.maxExclusive,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
-        }),
-        maxInclusive: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.maxInclusive,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
-        }),
-        maxLength: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.maxLength,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
-        }),
-        message: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.message,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
-        }),
-        minCount: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: PropertyShape.schema.properties.minCount,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
-        }),
-        minExclusive: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.minExclusive,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
-        }),
-        minInclusive: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.minInclusive,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
-        }),
-        minLength: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.minLength,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
-        }),
-        name: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: PropertyShape.schema.properties.name,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
-        }),
-        node: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.node,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
-        }),
-        nodeKind: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.nodeKind,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        not: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.not,
-            typeFromRdfResourceValues: $setFromRdfResourceValues($identifierFromRdfResourceValues),
-        }),
-        or: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.or,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
-        }),
-        order: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: PropertyShape.schema.properties.order,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($floatFromRdfResourceValues)),
-        }),
-        path: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: PropertyShape.schema.properties.path,
-            typeFromRdfResourceValues: $PropertyPath.fromRdfResourceValues,
-        }),
-        pattern: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.pattern,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
-        }),
-        qualifiedMaxCount: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: PropertyShape.schema.properties.qualifiedMaxCount,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
-        }),
-        qualifiedMinCount: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: PropertyShape.schema.properties.qualifiedMinCount,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
-        }),
-        qualifiedValueShape: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: PropertyShape.schema.properties.qualifiedValueShape,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
-        }),
-        qualifiedValueShapesDisjoint: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: PropertyShape.schema.properties.qualifiedValueShapesDisjoint,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
-        }),
-        severity: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.severity,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        targetClasses: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.targetClasses,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        targetNodes: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.targetNodes,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($termFromRdfResourceValues)),
-        }),
-        targetObjectsOf: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.targetObjectsOf,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        targetSubjectsOf: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: NodeShape.schema.properties.targetSubjectsOf,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
-        }),
-        uniqueLang: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: PropertyShape.schema.properties.uniqueLang,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
-        }),
-        xone: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            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" },
-                    },
-                },
-            },
-        },
-    };
-    PropertyShape._toRdfResource = (parameters) => {
-        if (!parameters.ignoreRdfType) {
-            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"), 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(new Resource.Value({
-            dataFactory: dataFactory,
-            focusResource: $resource,
-            propertyPath: $RdfVocabularies.rdf.subject,
-            term: $resource.identifier,
-        }).toValues(), {
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            preferredLanguages: _$options.preferredLanguages,
-            propertyPath: $RdfVocabularies.rdf.subject,
-            schema: ValidationReport.schema.properties.$identifier.type,
-        }).chain((values) => values.head()),
-        conforms: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: ValidationReport.schema.properties.conforms,
-            typeFromRdfResourceValues: ($booleanFromRdfResourceValues),
-        }),
-        results: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: ValidationReport.schema.properties.results,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(ValidationResult.fromRdfResourceValues),
-        }),
-        shapesGraphWellFormed: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            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" },
-                },
-            },
-        },
-    };
-    ValidationReport._toRdfResource = (parameters) => {
-        if (!parameters.ignoreRdfType) {
-            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#ValidationReport"), 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(new Resource.Value({
-            dataFactory: dataFactory,
-            focusResource: $resource,
-            propertyPath: $RdfVocabularies.rdf.subject,
-            term: $resource.identifier,
-        }).toValues(), {
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            preferredLanguages: _$options.preferredLanguages,
-            propertyPath: $RdfVocabularies.rdf.subject,
-            schema: ValidationResult.schema.properties.$identifier.type,
-        }).chain((values) => values.head()),
-        details: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: ValidationResult.schema.properties.details,
-            typeFromRdfResourceValues: $setFromRdfResourceValues(($termFromRdfResourceValues)),
-        }),
-        focusNode: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: ValidationResult.schema.properties.focusNode,
-            typeFromRdfResourceValues: ($termFromRdfResourceValues),
-        }),
-        message: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: ValidationResult.schema.properties.message,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
-        }),
-        path: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: ValidationResult.schema.properties.path,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($PropertyPath.fromRdfResourceValues),
-        }),
-        severity: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: ValidationResult.schema.properties.severity,
-            typeFromRdfResourceValues: ($iriFromRdfResourceValues),
-        }),
-        sourceConstraintComponent: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: ValidationResult.schema.properties.sourceConstraintComponent,
-            typeFromRdfResourceValues: ($iriFromRdfResourceValues),
-        }),
-        sourceShape: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            propertySchema: ValidationResult.schema.properties.sourceShape,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
-        }),
-        value: $shaclPropertyFromRdf({
-            context: _$options.context,
-            graph: _$options.graph,
-            focusResource: $resource,
-            ignoreRdfType: true,
-            preferredLanguages: _$options.preferredLanguages,
-            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"],
-                    },
-                },
-            },
-        },
-    };
-    ValidationResult._toRdfResource = (parameters) => {
-        if (!parameters.ignoreRdfType) {
-            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#ValidationResult"), 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=generated.js.map