@shaclmate/compiler 2.0.13 → 2.0.15

package/input/generated.js

@@ -0,0 +1,1436 @@
+import { PropertyPath } from "@shaclmate/shacl-ast/PropertyPath.js";
+import { DataFactory as dataFactory } from "n3";
+import * as purify from "purify-ts";
+import * as rdfjsResource from "rdfjs-resource";
+export var BaseShaclCoreShape;
+(function (BaseShaclCoreShape) {
+    function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    // @ts-ignore
+    ..._context }) {
+        const _andEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#and"), {
+                unique: true,
+            })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((value) => value.toList())
+                .map((values) => values.flatMap((_value) => _value
+                .toValues()
+                .head()
+                .chain((_value) => _value.toIdentifier())
+                .toMaybe()
+                .toList()))
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_andEither.isLeft()) {
+            return _andEither;
+        }
+        const and = _andEither.unsafeCoerce();
+        const _classesEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#class"), {
+                unique: true,
+            })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((_value) => _value.toIri())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_classesEither.isLeft()) {
+            return _classesEither;
+        }
+        const classes = _classesEither.unsafeCoerce();
+        const _commentsEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), { unique: true })
+                .flatMap((_item) => _item
+                .toValues()
+                .filter((_value) => {
+                const _languageInOrDefault = _languageIn ?? [];
+                if (_languageInOrDefault.length === 0) {
+                    return true;
+                }
+                const _valueLiteral = _value.toLiteral().toMaybe().extract();
+                if (typeof _valueLiteral === "undefined") {
+                    return false;
+                }
+                return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+            })
+                .head()
+                .chain((_value) => _value.toLiteral())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_commentsEither.isLeft()) {
+            return _commentsEither;
+        }
+        const comments = _commentsEither.unsafeCoerce();
+        const _datatypeEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"), {
+            unique: true,
+        })
+            .head()
+            .chain((_value) => _value.toIri())
+            .toMaybe());
+        if (_datatypeEither.isLeft()) {
+            return _datatypeEither;
+        }
+        const datatype = _datatypeEither.unsafeCoerce();
+        const _deactivatedEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"), { unique: true })
+            .head()
+            .chain((_value) => _value.toBoolean())
+            .toMaybe());
+        if (_deactivatedEither.isLeft()) {
+            return _deactivatedEither;
+        }
+        const deactivated = _deactivatedEither.unsafeCoerce();
+        const _flagsEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"), {
+                unique: true,
+            })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((_value) => _value.toString())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_flagsEither.isLeft()) {
+            return _flagsEither;
+        }
+        const flags = _flagsEither.unsafeCoerce();
+        const _hasValuesEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"), {
+                unique: true,
+            })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((_value) => purify.Either.of(_value.toTerm()))
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_hasValuesEither.isLeft()) {
+            return _hasValuesEither;
+        }
+        const hasValues = _hasValuesEither.unsafeCoerce();
+        const identifier = _resource.identifier;
+        const _in_Either = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#in"), {
+            unique: true,
+        })
+            .head()
+            .chain((value) => value.toList())
+            .map((values) => values.flatMap((_value) => _value
+            .toValues()
+            .head()
+            .chain((_value) => purify.Either.of(_value.toTerm()))
+            .toMaybe()
+            .toList()))
+            .toMaybe());
+        if (_in_Either.isLeft()) {
+            return _in_Either;
+        }
+        const in_ = _in_Either.unsafeCoerce();
+        const _isDefinedByEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"), { unique: true })
+            .head()
+            .chain((_value) => _value.toIdentifier())
+            .toMaybe());
+        if (_isDefinedByEither.isLeft()) {
+            return _isDefinedByEither;
+        }
+        const isDefinedBy = _isDefinedByEither.unsafeCoerce();
+        const _labelsEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), { unique: true })
+                .flatMap((_item) => _item
+                .toValues()
+                .filter((_value) => {
+                const _languageInOrDefault = _languageIn ?? [];
+                if (_languageInOrDefault.length === 0) {
+                    return true;
+                }
+                const _valueLiteral = _value.toLiteral().toMaybe().extract();
+                if (typeof _valueLiteral === "undefined") {
+                    return false;
+                }
+                return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+            })
+                .head()
+                .chain((_value) => _value.toLiteral())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_labelsEither.isLeft()) {
+            return _labelsEither;
+        }
+        const labels = _labelsEither.unsafeCoerce();
+        const _languageInEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#languageIn"), { unique: true })
+            .head()
+            .chain((value) => value.toList())
+            .map((values) => values.flatMap((_value) => _value
+            .toValues()
+            .head()
+            .chain((_value) => _value.toString())
+            .toMaybe()
+            .toList()))
+            .toMaybe());
+        if (_languageInEither.isLeft()) {
+            return _languageInEither;
+        }
+        const languageIn = _languageInEither.unsafeCoerce();
+        const _maxCountEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxCount"), {
+            unique: true,
+        })
+            .head()
+            .chain((_value) => _value.toNumber())
+            .toMaybe());
+        if (_maxCountEither.isLeft()) {
+            return _maxCountEither;
+        }
+        const maxCount = _maxCountEither.unsafeCoerce();
+        const _maxExclusiveEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"), { unique: true })
+            .filter((_value) => {
+            const _languageInOrDefault = _languageIn ?? [];
+            if (_languageInOrDefault.length === 0) {
+                return true;
+            }
+            const _valueLiteral = _value.toLiteral().toMaybe().extract();
+            if (typeof _valueLiteral === "undefined") {
+                return false;
+            }
+            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        })
+            .head()
+            .chain((_value) => _value.toLiteral())
+            .toMaybe());
+        if (_maxExclusiveEither.isLeft()) {
+            return _maxExclusiveEither;
+        }
+        const maxExclusive = _maxExclusiveEither.unsafeCoerce();
+        const _maxInclusiveEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxInclusive"), { unique: true })
+            .filter((_value) => {
+            const _languageInOrDefault = _languageIn ?? [];
+            if (_languageInOrDefault.length === 0) {
+                return true;
+            }
+            const _valueLiteral = _value.toLiteral().toMaybe().extract();
+            if (typeof _valueLiteral === "undefined") {
+                return false;
+            }
+            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        })
+            .head()
+            .chain((_value) => _value.toLiteral())
+            .toMaybe());
+        if (_maxInclusiveEither.isLeft()) {
+            return _maxInclusiveEither;
+        }
+        const maxInclusive = _maxInclusiveEither.unsafeCoerce();
+        const _maxLengthEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"), {
+            unique: true,
+        })
+            .head()
+            .chain((_value) => _value.toNumber())
+            .toMaybe());
+        if (_maxLengthEither.isLeft()) {
+            return _maxLengthEither;
+        }
+        const maxLength = _maxLengthEither.unsafeCoerce();
+        const _minCountEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"), {
+            unique: true,
+        })
+            .head()
+            .chain((_value) => _value.toNumber())
+            .toMaybe());
+        if (_minCountEither.isLeft()) {
+            return _minCountEither;
+        }
+        const minCount = _minCountEither.unsafeCoerce();
+        const _minExclusiveEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"), { unique: true })
+            .filter((_value) => {
+            const _languageInOrDefault = _languageIn ?? [];
+            if (_languageInOrDefault.length === 0) {
+                return true;
+            }
+            const _valueLiteral = _value.toLiteral().toMaybe().extract();
+            if (typeof _valueLiteral === "undefined") {
+                return false;
+            }
+            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        })
+            .head()
+            .chain((_value) => _value.toLiteral())
+            .toMaybe());
+        if (_minExclusiveEither.isLeft()) {
+            return _minExclusiveEither;
+        }
+        const minExclusive = _minExclusiveEither.unsafeCoerce();
+        const _minInclusiveEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#minInclusive"), { unique: true })
+            .filter((_value) => {
+            const _languageInOrDefault = _languageIn ?? [];
+            if (_languageInOrDefault.length === 0) {
+                return true;
+            }
+            const _valueLiteral = _value.toLiteral().toMaybe().extract();
+            if (typeof _valueLiteral === "undefined") {
+                return false;
+            }
+            return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+        })
+            .head()
+            .chain((_value) => _value.toLiteral())
+            .toMaybe());
+        if (_minInclusiveEither.isLeft()) {
+            return _minInclusiveEither;
+        }
+        const minInclusive = _minInclusiveEither.unsafeCoerce();
+        const _minLengthEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"), {
+            unique: true,
+        })
+            .head()
+            .chain((_value) => _value.toNumber())
+            .toMaybe());
+        if (_minLengthEither.isLeft()) {
+            return _minLengthEither;
+        }
+        const minLength = _minLengthEither.unsafeCoerce();
+        const _nodeKindEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"), {
+            unique: true,
+        })
+            .head()
+            .chain((_value) => _value.toIri().chain((iri) => {
+            switch (iri.value) {
+                case "http://www.w3.org/ns/shacl#BlankNode":
+                    return purify.Either.of(iri);
+                case "http://www.w3.org/ns/shacl#BlankNodeOrIRI":
+                    return purify.Either.of(iri);
+                case "http://www.w3.org/ns/shacl#BlankNodeOrLiteral":
+                    return purify.Either.of(iri);
+                case "http://www.w3.org/ns/shacl#IRI":
+                    return purify.Either.of(iri);
+                case "http://www.w3.org/ns/shacl#IRIOrLiteral":
+                    return purify.Either.of(iri);
+                case "http://www.w3.org/ns/shacl#Literal":
+                    return purify.Either.of(iri);
+                default:
+                    return purify.Left(new rdfjsResource.Resource.MistypedValueError({
+                        actualValue: iri,
+                        expectedValueType: 'rdfjs.NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">',
+                        focusResource: _resource,
+                        predicate: dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"),
+                    }));
+            }
+        }))
+            .toMaybe());
+        if (_nodeKindEither.isLeft()) {
+            return _nodeKindEither;
+        }
+        const nodeKind = _nodeKindEither.unsafeCoerce();
+        const _nodesEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#node"), {
+                unique: true,
+            })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((_value) => _value.toIdentifier())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_nodesEither.isLeft()) {
+            return _nodesEither;
+        }
+        const nodes = _nodesEither.unsafeCoerce();
+        const _notEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#not"), {
+                unique: true,
+            })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((_value) => _value.toIdentifier())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_notEither.isLeft()) {
+            return _notEither;
+        }
+        const not = _notEither.unsafeCoerce();
+        const _orEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#or"), {
+                unique: true,
+            })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((value) => value.toList())
+                .map((values) => values.flatMap((_value) => _value
+                .toValues()
+                .head()
+                .chain((_value) => _value.toIdentifier())
+                .toMaybe()
+                .toList()))
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_orEither.isLeft()) {
+            return _orEither;
+        }
+        const or = _orEither.unsafeCoerce();
+        const _patternsEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"), {
+                unique: true,
+            })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((_value) => _value.toString())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_patternsEither.isLeft()) {
+            return _patternsEither;
+        }
+        const patterns = _patternsEither.unsafeCoerce();
+        const _xoneEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"), {
+                unique: true,
+            })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((value) => value.toList())
+                .map((values) => values.flatMap((_value) => _value
+                .toValues()
+                .head()
+                .chain((_value) => _value.toIdentifier())
+                .toMaybe()
+                .toList()))
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_xoneEither.isLeft()) {
+            return _xoneEither;
+        }
+        const xone = _xoneEither.unsafeCoerce();
+        return purify.Either.of({
+            and,
+            classes,
+            comments,
+            datatype,
+            deactivated,
+            flags,
+            hasValues,
+            identifier,
+            in_,
+            isDefinedBy,
+            labels,
+            languageIn,
+            maxCount,
+            maxExclusive,
+            maxInclusive,
+            maxLength,
+            minCount,
+            minExclusive,
+            minInclusive,
+            minLength,
+            nodeKind,
+            nodes,
+            not,
+            or,
+            patterns,
+            xone,
+        });
+    }
+    BaseShaclCoreShape.propertiesFromRdf = propertiesFromRdf;
+})(BaseShaclCoreShape || (BaseShaclCoreShape = {}));
+export var ShaclCorePropertyShape;
+(function (ShaclCorePropertyShape) {
+    function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    // @ts-ignore
+    ..._context }) {
+        const _super0Either = BaseShaclCoreShape.propertiesFromRdf({
+            ..._context,
+            ignoreRdfType: true,
+            languageIn: _languageIn,
+            resource: _resource,
+        });
+        if (_super0Either.isLeft()) {
+            return _super0Either;
+        }
+        const _super0 = _super0Either.unsafeCoerce();
+        if (!_ignoreRdfType &&
+            !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"))) {
+            return purify.Left(new rdfjsResource.Resource.ValueError({
+                focusResource: _resource,
+                message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
+                predicate: dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"),
+            }));
+        }
+        const _defaultValueEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#defaultValue"), { unique: true })
+            .head()
+            .chain((_value) => purify.Either.of(_value.toTerm()))
+            .toMaybe());
+        if (_defaultValueEither.isLeft()) {
+            return _defaultValueEither;
+        }
+        const defaultValue = _defaultValueEither.unsafeCoerce();
+        const _descriptionsEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#description"), { unique: true })
+                .flatMap((_item) => _item
+                .toValues()
+                .filter((_value) => {
+                const _languageInOrDefault = _languageIn ?? [];
+                if (_languageInOrDefault.length === 0) {
+                    return true;
+                }
+                const _valueLiteral = _value.toLiteral().toMaybe().extract();
+                if (typeof _valueLiteral === "undefined") {
+                    return false;
+                }
+                return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+            })
+                .head()
+                .chain((_value) => _value.toLiteral())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_descriptionsEither.isLeft()) {
+            return _descriptionsEither;
+        }
+        const descriptions = _descriptionsEither.unsafeCoerce();
+        const _groupsEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#group"), {
+                unique: true,
+            })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((_value) => _value.toIdentifier())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_groupsEither.isLeft()) {
+            return _groupsEither;
+        }
+        const groups = _groupsEither.unsafeCoerce();
+        const identifier = _resource.identifier;
+        const _namesEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#name"), {
+                unique: true,
+            })
+                .flatMap((_item) => _item
+                .toValues()
+                .filter((_value) => {
+                const _languageInOrDefault = _languageIn ?? [];
+                if (_languageInOrDefault.length === 0) {
+                    return true;
+                }
+                const _valueLiteral = _value.toLiteral().toMaybe().extract();
+                if (typeof _valueLiteral === "undefined") {
+                    return false;
+                }
+                return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+            })
+                .head()
+                .chain((_value) => _value.toLiteral())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_namesEither.isLeft()) {
+            return _namesEither;
+        }
+        const names = _namesEither.unsafeCoerce();
+        const _orderEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#order"), {
+            unique: true,
+        })
+            .head()
+            .chain((_value) => _value.toNumber())
+            .toMaybe());
+        if (_orderEither.isLeft()) {
+            return _orderEither;
+        }
+        const order = _orderEither.unsafeCoerce();
+        const _pathEither = _resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#path"), {
+            unique: true,
+        })
+            .head()
+            .chain((value) => value.toResource())
+            .chain((_resource) => PropertyPath.fromRdf({
+            ..._context,
+            ignoreRdfType: true,
+            languageIn: _languageIn,
+            resource: _resource,
+        }));
+        if (_pathEither.isLeft()) {
+            return _pathEither;
+        }
+        const path = _pathEither.unsafeCoerce();
+        const type = "ShaclCorePropertyShape";
+        const _uniqueLangEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"), { unique: true })
+            .head()
+            .chain((_value) => _value.toBoolean())
+            .toMaybe());
+        if (_uniqueLangEither.isLeft()) {
+            return _uniqueLangEither;
+        }
+        const uniqueLang = _uniqueLangEither.unsafeCoerce();
+        return purify.Either.of({
+            ..._super0,
+            defaultValue,
+            descriptions,
+            groups,
+            identifier,
+            names,
+            order,
+            path,
+            type,
+            uniqueLang,
+        });
+    }
+    ShaclCorePropertyShape.propertiesFromRdf = propertiesFromRdf;
+    function fromRdf(parameters) {
+        return ShaclCorePropertyShape.propertiesFromRdf(parameters);
+    }
+    ShaclCorePropertyShape.fromRdf = fromRdf;
+})(ShaclCorePropertyShape || (ShaclCorePropertyShape = {}));
+export var ShaclmatePropertyShape;
+(function (ShaclmatePropertyShape) {
+    function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    // @ts-ignore
+    ..._context }) {
+        const _super0Either = ShaclCorePropertyShape.propertiesFromRdf({
+            ..._context,
+            ignoreRdfType: true,
+            languageIn: _languageIn,
+            resource: _resource,
+        });
+        if (_super0Either.isLeft()) {
+            return _super0Either;
+        }
+        const _super0 = _super0Either.unsafeCoerce();
+        if (!_ignoreRdfType &&
+            !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"))) {
+            return purify.Left(new rdfjsResource.Resource.ValueError({
+                focusResource: _resource,
+                message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
+                predicate: dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"),
+            }));
+        }
+        const _externEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#extern"), { unique: true })
+            .head()
+            .chain((_value) => _value.toBoolean())
+            .toMaybe());
+        if (_externEither.isLeft()) {
+            return _externEither;
+        }
+        const extern = _externEither.unsafeCoerce();
+        const identifier = _resource.identifier;
+        const _mutableEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#mutable"), { unique: true })
+            .head()
+            .chain((_value) => _value.toBoolean())
+            .toMaybe());
+        if (_mutableEither.isLeft()) {
+            return _mutableEither;
+        }
+        const mutable = _mutableEither.unsafeCoerce();
+        const _nameEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#name"), { unique: true })
+            .head()
+            .chain((_value) => _value.toString())
+            .toMaybe());
+        if (_nameEither.isLeft()) {
+            return _nameEither;
+        }
+        const name = _nameEither.unsafeCoerce();
+        const type = "ShaclmatePropertyShape";
+        const _visibilityEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#visibility"), { unique: true })
+            .head()
+            .chain((_value) => _value.toIri().chain((iri) => {
+            switch (iri.value) {
+                case "http://minorg.github.io/shaclmate/ns#_Visibility_Private":
+                    return purify.Either.of(iri);
+                case "http://minorg.github.io/shaclmate/ns#_Visibility_Protected":
+                    return purify.Either.of(iri);
+                case "http://minorg.github.io/shaclmate/ns#_Visibility_Public":
+                    return purify.Either.of(iri);
+                default:
+                    return purify.Left(new rdfjsResource.Resource.MistypedValueError({
+                        actualValue: iri,
+                        expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_Visibility_Private" | "http://minorg.github.io/shaclmate/ns#_Visibility_Protected" | "http://minorg.github.io/shaclmate/ns#_Visibility_Public">',
+                        focusResource: _resource,
+                        predicate: dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#visibility"),
+                    }));
+            }
+        }))
+            .toMaybe());
+        if (_visibilityEither.isLeft()) {
+            return _visibilityEither;
+        }
+        const visibility = _visibilityEither.unsafeCoerce();
+        return purify.Either.of({
+            ..._super0,
+            extern,
+            identifier,
+            mutable,
+            name,
+            type,
+            visibility,
+        });
+    }
+    ShaclmatePropertyShape.propertiesFromRdf = propertiesFromRdf;
+    function fromRdf(parameters) {
+        return ShaclmatePropertyShape.propertiesFromRdf(parameters);
+    }
+    ShaclmatePropertyShape.fromRdf = fromRdf;
+})(ShaclmatePropertyShape || (ShaclmatePropertyShape = {}));
+export var OwlOntology;
+(function (OwlOntology) {
+    function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    // @ts-ignore
+    ..._context }) {
+        if (!_ignoreRdfType &&
+            !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"))) {
+            return purify.Left(new rdfjsResource.Resource.ValueError({
+                focusResource: _resource,
+                message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
+                predicate: dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"),
+            }));
+        }
+        const identifier = _resource.identifier;
+        const _labelsEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), { unique: true })
+                .flatMap((_item) => _item
+                .toValues()
+                .filter((_value) => {
+                const _languageInOrDefault = _languageIn ?? [];
+                if (_languageInOrDefault.length === 0) {
+                    return true;
+                }
+                const _valueLiteral = _value.toLiteral().toMaybe().extract();
+                if (typeof _valueLiteral === "undefined") {
+                    return false;
+                }
+                return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+            })
+                .head()
+                .chain((_value) => _value.toLiteral())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_labelsEither.isLeft()) {
+            return _labelsEither;
+        }
+        const labels = _labelsEither.unsafeCoerce();
+        const type = "OwlOntology";
+        return purify.Either.of({ identifier, labels, type });
+    }
+    OwlOntology.propertiesFromRdf = propertiesFromRdf;
+    function fromRdf(parameters) {
+        return OwlOntology.propertiesFromRdf(parameters);
+    }
+    OwlOntology.fromRdf = fromRdf;
+})(OwlOntology || (OwlOntology = {}));
+export var ShaclmateOntology;
+(function (ShaclmateOntology) {
+    function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    // @ts-ignore
+    ..._context }) {
+        const _super0Either = OwlOntology.propertiesFromRdf({
+            ..._context,
+            ignoreRdfType: true,
+            languageIn: _languageIn,
+            resource: _resource,
+        });
+        if (_super0Either.isLeft()) {
+            return _super0Either;
+        }
+        const _super0 = _super0Either.unsafeCoerce();
+        if (!_ignoreRdfType &&
+            !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"))) {
+            return purify.Left(new rdfjsResource.Resource.ValueError({
+                focusResource: _resource,
+                message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
+                predicate: dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"),
+            }));
+        }
+        const identifier = _resource.identifier;
+        const _tsDataFactoryVariableEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsDataFactoryVariable"), { unique: true })
+            .head()
+            .chain((_value) => _value.toString())
+            .toMaybe());
+        if (_tsDataFactoryVariableEither.isLeft()) {
+            return _tsDataFactoryVariableEither;
+        }
+        const tsDataFactoryVariable = _tsDataFactoryVariableEither.unsafeCoerce();
+        const _tsFeatureExcludesEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsFeatureExclude"), { unique: true })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((_value) => _value.toIri().chain((iri) => {
+                switch (iri.value) {
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Create":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Json":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf":
+                        return purify.Either.of(iri);
+                    default:
+                        return purify.Left(new rdfjsResource.Resource.MistypedValueError({
+                            actualValue: iri,
+                            expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">',
+                            focusResource: _resource,
+                            predicate: dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsFeatureExclude"),
+                        }));
+                }
+            }))
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_tsFeatureExcludesEither.isLeft()) {
+            return _tsFeatureExcludesEither;
+        }
+        const tsFeatureExcludes = _tsFeatureExcludesEither.unsafeCoerce();
+        const _tsFeatureIncludesEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsFeatureInclude"), { unique: true })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((_value) => _value.toIri().chain((iri) => {
+                switch (iri.value) {
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Create":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Json":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf":
+                        return purify.Either.of(iri);
+                    default:
+                        return purify.Left(new rdfjsResource.Resource.MistypedValueError({
+                            actualValue: iri,
+                            expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">',
+                            focusResource: _resource,
+                            predicate: dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsFeatureInclude"),
+                        }));
+                }
+            }))
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_tsFeatureIncludesEither.isLeft()) {
+            return _tsFeatureIncludesEither;
+        }
+        const tsFeatureIncludes = _tsFeatureIncludesEither.unsafeCoerce();
+        const _tsImportsEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsImport"), { unique: true })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((_value) => _value.toString())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_tsImportsEither.isLeft()) {
+            return _tsImportsEither;
+        }
+        const tsImports = _tsImportsEither.unsafeCoerce();
+        const _tsObjectDeclarationTypeEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsObjectDeclarationType"), { unique: true })
+            .head()
+            .chain((_value) => _value.toIri().chain((iri) => {
+            switch (iri.value) {
+                case "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class":
+                    return purify.Either.of(iri);
+                case "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface":
+                    return purify.Either.of(iri);
+                default:
+                    return purify.Left(new rdfjsResource.Resource.MistypedValueError({
+                        actualValue: iri,
+                        expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class" | "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface">',
+                        focusResource: _resource,
+                        predicate: dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsObjectDeclarationType"),
+                    }));
+            }
+        }))
+            .toMaybe());
+        if (_tsObjectDeclarationTypeEither.isLeft()) {
+            return _tsObjectDeclarationTypeEither;
+        }
+        const tsObjectDeclarationType = _tsObjectDeclarationTypeEither.unsafeCoerce();
+        const _tsObjectIdentifierPropertyNameEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsObjectIdentifierPropertyName"), { unique: true })
+            .head()
+            .chain((_value) => _value.toString())
+            .toMaybe());
+        if (_tsObjectIdentifierPropertyNameEither.isLeft()) {
+            return _tsObjectIdentifierPropertyNameEither;
+        }
+        const tsObjectIdentifierPropertyName = _tsObjectIdentifierPropertyNameEither.unsafeCoerce();
+        const _tsObjectTypeDiscriminatorPropertyNameEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsObjectTypeDiscriminatorPropertyName"), { unique: true })
+            .head()
+            .chain((_value) => _value.toString())
+            .toMaybe());
+        if (_tsObjectTypeDiscriminatorPropertyNameEither.isLeft()) {
+            return _tsObjectTypeDiscriminatorPropertyNameEither;
+        }
+        const tsObjectTypeDiscriminatorPropertyName = _tsObjectTypeDiscriminatorPropertyNameEither.unsafeCoerce();
+        const type = "ShaclmateOntology";
+        return purify.Either.of({
+            ..._super0,
+            identifier,
+            tsDataFactoryVariable,
+            tsFeatureExcludes,
+            tsFeatureIncludes,
+            tsImports,
+            tsObjectDeclarationType,
+            tsObjectIdentifierPropertyName,
+            tsObjectTypeDiscriminatorPropertyName,
+            type,
+        });
+    }
+    ShaclmateOntology.propertiesFromRdf = propertiesFromRdf;
+    function fromRdf(parameters) {
+        return ShaclmateOntology.propertiesFromRdf(parameters);
+    }
+    ShaclmateOntology.fromRdf = fromRdf;
+})(ShaclmateOntology || (ShaclmateOntology = {}));
+export var ShaclCoreNodeShape;
+(function (ShaclCoreNodeShape) {
+    function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    // @ts-ignore
+    ..._context }) {
+        const _super0Either = BaseShaclCoreShape.propertiesFromRdf({
+            ..._context,
+            ignoreRdfType: true,
+            languageIn: _languageIn,
+            resource: _resource,
+        });
+        if (_super0Either.isLeft()) {
+            return _super0Either;
+        }
+        const _super0 = _super0Either.unsafeCoerce();
+        if (!_ignoreRdfType &&
+            !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"))) {
+            return purify.Left(new rdfjsResource.Resource.ValueError({
+                focusResource: _resource,
+                message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
+                predicate: dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"),
+            }));
+        }
+        const _closedEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#closed"), {
+            unique: true,
+        })
+            .head()
+            .chain((_value) => _value.toBoolean())
+            .toMaybe());
+        if (_closedEither.isLeft()) {
+            return _closedEither;
+        }
+        const closed = _closedEither.unsafeCoerce();
+        const identifier = _resource.identifier;
+        const _ignoredPropertiesEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#ignoredProperties"), { unique: true })
+            .head()
+            .chain((value) => value.toList())
+            .map((values) => values.flatMap((_value) => _value
+            .toValues()
+            .head()
+            .chain((_value) => _value.toIri())
+            .toMaybe()
+            .toList()))
+            .toMaybe());
+        if (_ignoredPropertiesEither.isLeft()) {
+            return _ignoredPropertiesEither;
+        }
+        const ignoredProperties = _ignoredPropertiesEither.unsafeCoerce();
+        const _propertiesEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#property"), {
+                unique: true,
+            })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((_value) => _value.toIdentifier())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_propertiesEither.isLeft()) {
+            return _propertiesEither;
+        }
+        const properties = _propertiesEither.unsafeCoerce();
+        const type = "ShaclCoreNodeShape";
+        return purify.Either.of({
+            ..._super0,
+            closed,
+            identifier,
+            ignoredProperties,
+            properties,
+            type,
+        });
+    }
+    ShaclCoreNodeShape.propertiesFromRdf = propertiesFromRdf;
+    function fromRdf(parameters) {
+        return ShaclCoreNodeShape.propertiesFromRdf(parameters);
+    }
+    ShaclCoreNodeShape.fromRdf = fromRdf;
+})(ShaclCoreNodeShape || (ShaclCoreNodeShape = {}));
+export var ShaclmateNodeShape;
+(function (ShaclmateNodeShape) {
+    function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    // @ts-ignore
+    ..._context }) {
+        const _super0Either = ShaclCoreNodeShape.propertiesFromRdf({
+            ..._context,
+            ignoreRdfType: true,
+            languageIn: _languageIn,
+            resource: _resource,
+        });
+        if (_super0Either.isLeft()) {
+            return _super0Either;
+        }
+        const _super0 = _super0Either.unsafeCoerce();
+        if (!_ignoreRdfType &&
+            !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"))) {
+            return purify.Left(new rdfjsResource.Resource.ValueError({
+                focusResource: _resource,
+                message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
+                predicate: dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"),
+            }));
+        }
+        const _abstractEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#abstract"), { unique: true })
+            .head()
+            .chain((_value) => _value.toBoolean())
+            .toMaybe());
+        if (_abstractEither.isLeft()) {
+            return _abstractEither;
+        }
+        const abstract = _abstractEither.unsafeCoerce();
+        const _export_Either = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#export"), { unique: true })
+            .head()
+            .chain((_value) => _value.toBoolean())
+            .toMaybe());
+        if (_export_Either.isLeft()) {
+            return _export_Either;
+        }
+        const export_ = _export_Either.unsafeCoerce();
+        const _externEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#extern"), { unique: true })
+            .head()
+            .chain((_value) => _value.toBoolean())
+            .toMaybe());
+        if (_externEither.isLeft()) {
+            return _externEither;
+        }
+        const extern = _externEither.unsafeCoerce();
+        const _fromRdfTypeEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#fromRdfType"), { unique: true })
+            .head()
+            .chain((_value) => _value.toIri())
+            .toMaybe());
+        if (_fromRdfTypeEither.isLeft()) {
+            return _fromRdfTypeEither;
+        }
+        const fromRdfType = _fromRdfTypeEither.unsafeCoerce();
+        const identifier = _resource.identifier;
+        const _mintingStrategyEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#mintingStrategy"), { unique: true })
+            .head()
+            .chain((_value) => _value.toIri().chain((iri) => {
+            switch (iri.value) {
+                case "http://minorg.github.io/shaclmate/ns#_MintingStrategy_SHA256":
+                    return purify.Either.of(iri);
+                case "http://minorg.github.io/shaclmate/ns#_MintingStrategy_UUIDv4":
+                    return purify.Either.of(iri);
+                default:
+                    return purify.Left(new rdfjsResource.Resource.MistypedValueError({
+                        actualValue: iri,
+                        expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_MintingStrategy_SHA256" | "http://minorg.github.io/shaclmate/ns#_MintingStrategy_UUIDv4">',
+                        focusResource: _resource,
+                        predicate: dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#mintingStrategy"),
+                    }));
+            }
+        }))
+            .toMaybe());
+        if (_mintingStrategyEither.isLeft()) {
+            return _mintingStrategyEither;
+        }
+        const mintingStrategy = _mintingStrategyEither.unsafeCoerce();
+        const _mutableEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#mutable"), { unique: true })
+            .head()
+            .chain((_value) => _value.toBoolean())
+            .toMaybe());
+        if (_mutableEither.isLeft()) {
+            return _mutableEither;
+        }
+        const mutable = _mutableEither.unsafeCoerce();
+        const _nameEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#name"), { unique: true })
+            .head()
+            .chain((_value) => _value.toString())
+            .toMaybe());
+        if (_nameEither.isLeft()) {
+            return _nameEither;
+        }
+        const name = _nameEither.unsafeCoerce();
+        const _toRdfTypesEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#toRdfType"), { unique: true })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((_value) => _value.toIri())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_toRdfTypesEither.isLeft()) {
+            return _toRdfTypesEither;
+        }
+        const toRdfTypes = _toRdfTypesEither.unsafeCoerce();
+        const _tsFeatureExcludesEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsFeatureExclude"), { unique: true })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((_value) => _value.toIri().chain((iri) => {
+                switch (iri.value) {
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Create":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Json":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf":
+                        return purify.Either.of(iri);
+                    default:
+                        return purify.Left(new rdfjsResource.Resource.MistypedValueError({
+                            actualValue: iri,
+                            expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">',
+                            focusResource: _resource,
+                            predicate: dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsFeatureExclude"),
+                        }));
+                }
+            }))
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_tsFeatureExcludesEither.isLeft()) {
+            return _tsFeatureExcludesEither;
+        }
+        const tsFeatureExcludes = _tsFeatureExcludesEither.unsafeCoerce();
+        const _tsFeatureIncludesEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsFeatureInclude"), { unique: true })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((_value) => _value.toIri().chain((iri) => {
+                switch (iri.value) {
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Create":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Json":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson":
+                        return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf":
+                        return purify.Either.of(iri);
+                    default:
+                        return purify.Left(new rdfjsResource.Resource.MistypedValueError({
+                            actualValue: iri,
+                            expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">',
+                            focusResource: _resource,
+                            predicate: dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsFeatureInclude"),
+                        }));
+                }
+            }))
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_tsFeatureIncludesEither.isLeft()) {
+            return _tsFeatureIncludesEither;
+        }
+        const tsFeatureIncludes = _tsFeatureIncludesEither.unsafeCoerce();
+        const _tsImportsEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsImport"), { unique: true })
+                .flatMap((_item) => _item
+                .toValues()
+                .head()
+                .chain((_value) => _value.toString())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_tsImportsEither.isLeft()) {
+            return _tsImportsEither;
+        }
+        const tsImports = _tsImportsEither.unsafeCoerce();
+        const _tsObjectDeclarationTypeEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsObjectDeclarationType"), { unique: true })
+            .head()
+            .chain((_value) => _value.toIri().chain((iri) => {
+            switch (iri.value) {
+                case "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class":
+                    return purify.Either.of(iri);
+                case "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface":
+                    return purify.Either.of(iri);
+                default:
+                    return purify.Left(new rdfjsResource.Resource.MistypedValueError({
+                        actualValue: iri,
+                        expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class" | "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface">',
+                        focusResource: _resource,
+                        predicate: dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsObjectDeclarationType"),
+                    }));
+            }
+        }))
+            .toMaybe());
+        if (_tsObjectDeclarationTypeEither.isLeft()) {
+            return _tsObjectDeclarationTypeEither;
+        }
+        const tsObjectDeclarationType = _tsObjectDeclarationTypeEither.unsafeCoerce();
+        const _tsObjectIdentifierPropertyNameEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsObjectIdentifierPropertyName"), { unique: true })
+            .head()
+            .chain((_value) => _value.toString())
+            .toMaybe());
+        if (_tsObjectIdentifierPropertyNameEither.isLeft()) {
+            return _tsObjectIdentifierPropertyNameEither;
+        }
+        const tsObjectIdentifierPropertyName = _tsObjectIdentifierPropertyNameEither.unsafeCoerce();
+        const _tsObjectTypeDiscriminatorPropertyNameEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsObjectTypeDiscriminatorPropertyName"), { unique: true })
+            .head()
+            .chain((_value) => _value.toString())
+            .toMaybe());
+        if (_tsObjectTypeDiscriminatorPropertyNameEither.isLeft()) {
+            return _tsObjectTypeDiscriminatorPropertyNameEither;
+        }
+        const tsObjectTypeDiscriminatorPropertyName = _tsObjectTypeDiscriminatorPropertyNameEither.unsafeCoerce();
+        const type = "ShaclmateNodeShape";
+        return purify.Either.of({
+            ..._super0,
+            abstract,
+            export_,
+            extern,
+            fromRdfType,
+            identifier,
+            mintingStrategy,
+            mutable,
+            name,
+            toRdfTypes,
+            tsFeatureExcludes,
+            tsFeatureIncludes,
+            tsImports,
+            tsObjectDeclarationType,
+            tsObjectIdentifierPropertyName,
+            tsObjectTypeDiscriminatorPropertyName,
+            type,
+        });
+    }
+    ShaclmateNodeShape.propertiesFromRdf = propertiesFromRdf;
+    function fromRdf(parameters) {
+        return ShaclmateNodeShape.propertiesFromRdf(parameters);
+    }
+    ShaclmateNodeShape.fromRdf = fromRdf;
+})(ShaclmateNodeShape || (ShaclmateNodeShape = {}));
+export var ShaclCorePropertyGroup;
+(function (ShaclCorePropertyGroup) {
+    function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    // @ts-ignore
+    ..._context }) {
+        if (!_ignoreRdfType &&
+            !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"))) {
+            return purify.Left(new rdfjsResource.Resource.ValueError({
+                focusResource: _resource,
+                message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
+                predicate: dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"),
+            }));
+        }
+        const _commentsEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), { unique: true })
+                .flatMap((_item) => _item
+                .toValues()
+                .filter((_value) => {
+                const _languageInOrDefault = _languageIn ?? [];
+                if (_languageInOrDefault.length === 0) {
+                    return true;
+                }
+                const _valueLiteral = _value.toLiteral().toMaybe().extract();
+                if (typeof _valueLiteral === "undefined") {
+                    return false;
+                }
+                return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+            })
+                .head()
+                .chain((_value) => _value.toLiteral())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_commentsEither.isLeft()) {
+            return _commentsEither;
+        }
+        const comments = _commentsEither.unsafeCoerce();
+        const identifier = _resource.identifier;
+        const _labelsEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), { unique: true })
+                .flatMap((_item) => _item
+                .toValues()
+                .filter((_value) => {
+                const _languageInOrDefault = _languageIn ?? [];
+                if (_languageInOrDefault.length === 0) {
+                    return true;
+                }
+                const _valueLiteral = _value.toLiteral().toMaybe().extract();
+                if (typeof _valueLiteral === "undefined") {
+                    return false;
+                }
+                return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+            })
+                .head()
+                .chain((_value) => _value.toLiteral())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_labelsEither.isLeft()) {
+            return _labelsEither;
+        }
+        const labels = _labelsEither.unsafeCoerce();
+        const type = "ShaclCorePropertyGroup";
+        return purify.Either.of({ comments, identifier, labels, type });
+    }
+    ShaclCorePropertyGroup.propertiesFromRdf = propertiesFromRdf;
+    function fromRdf(parameters) {
+        return ShaclCorePropertyGroup.propertiesFromRdf(parameters);
+    }
+    ShaclCorePropertyGroup.fromRdf = fromRdf;
+})(ShaclCorePropertyGroup || (ShaclCorePropertyGroup = {}));
+export var ShaclCoreShape;
+(function (ShaclCoreShape) {
+    function fromRdf(parameters) {
+        return ShaclCoreNodeShape.fromRdf(parameters).altLazy(() => ShaclCorePropertyShape.fromRdf(parameters));
+    }
+    ShaclCoreShape.fromRdf = fromRdf;
+})(ShaclCoreShape || (ShaclCoreShape = {}));
+export var ShaclmateShape;
+(function (ShaclmateShape) {
+    function fromRdf(parameters) {
+        return ShaclmateNodeShape.fromRdf(parameters).altLazy(() => ShaclCorePropertyShape.fromRdf(parameters));
+    }
+    ShaclmateShape.fromRdf = fromRdf;
+})(ShaclmateShape || (ShaclmateShape = {}));
+//# sourceMappingURL=generated.js.map