@shaclmate/compiler 4.0.8 → 4.0.10

package/dist/input/generated.d.ts

@@ -1,6 +1,6 @@
 import type { BlankNode, DatasetCore, Literal, NamedNode, Quad_Graph, Variable } from "@rdfjs/types";
 import { Either, Maybe } from "purify-ts";
-import { PropertyPath, Resource, ResourceSet } from "rdfjs-resource";
+import { PropertyPath as RdfjsResourcePropertyPath, Resource, ResourceSet } from "rdfjs-resource";
 interface $BooleanFilter {
     readonly value?: boolean;
 }
@@ -8,13 +8,22 @@ type $CollectionFilter<ItemFilterT> = ItemFilterT & {
     readonly $maxCount?: number;
     readonly $minCount?: number;
 };
-type $FromRdfOptions = {
+export type $FromRdfResourceFunction<T> = (resource: Resource, options?: {
     context?: unknown;
     graph?: Exclude<Quad_Graph, Variable>;
     ignoreRdfType?: boolean;
     objectSet?: $ObjectSet;
     preferredLanguages?: readonly string[];
-};
+}) => Either<Error, T>;
+export type $FromRdfResourceValuesFunction<T> = (resourceValues: Either<Error, Resource.Values>, options: {
+    context?: unknown;
+    graph?: Exclude<Quad_Graph, Variable>;
+    ignoreRdfType?: boolean;
+    objectSet?: $ObjectSet;
+    preferredLanguages?: readonly string[];
+    propertyPath: $PropertyPath;
+    resource: Resource;
+}) => Either<Error, Resource.Values<T>>;
 interface $IdentifierFilter {
     readonly in?: readonly (BlankNode | NamedNode)[];
     readonly type?: "BlankNode" | "NamedNode";
@@ -34,17 +43,25 @@ interface $NumericFilter<T> {
     readonly minExclusive?: T;
     readonly minInclusive?: T;
 }
-type $PropertiesFromRdfParameters = {
-    context?: unknown;
-    graph?: Exclude<Quad_Graph, Variable>;
+type $PropertiesFromRdfResourceFunction<T> = (resource: Resource, options: {
+    context: undefined | unknown;
+    graph: Exclude<Quad_Graph, Variable> | undefined;
     ignoreRdfType: boolean;
     objectSet: $ObjectSet;
     preferredLanguages?: readonly string[];
-    resource: Resource;
-};
+}) => Either<Error, T>;
+export type $PropertyPath = RdfjsResourcePropertyPath;
+export declare namespace $PropertyPath {
+    type $Filter = object;
+    function $filter(_filter: $Filter, _value: $PropertyPath): boolean;
+    const $fromRdfResource: $FromRdfResourceFunction<$PropertyPath>;
+    const $fromRdfResourceValues: $FromRdfResourceValuesFunction<$PropertyPath>;
+    const $schema: Readonly<object>;
+    const $toRdfResource: $ToRdfResourceFunction<$PropertyPath>;
+}
 export interface $ShaclPropertySchema<TypeSchemaT = object> {
     readonly kind: "Shacl";
-    readonly path: PropertyPath;
+    readonly path: $PropertyPath;
     readonly type: () => TypeSchemaT;
 }
 interface $StringFilter {
@@ -58,6 +75,18 @@ interface $TermFilter {
     readonly languageIn?: readonly string[];
     readonly typeIn?: readonly ("BlankNode" | "Literal" | "NamedNode")[];
 }
+export type $ToRdfResourceFunction<T> = (value: T, options?: {
+    graph?: Exclude<Quad_Graph, Variable>;
+    ignoreRdfType?: boolean;
+    resourceSet?: ResourceSet;
+}) => Resource;
+export type $ToRdfResourceValuesFunction<T> = (value: T, options: {
+    graph?: Exclude<Quad_Graph, Variable>;
+    ignoreRdfType?: boolean;
+    propertyPath: $PropertyPath;
+    resource: Resource;
+    resourceSet: ResourceSet;
+}) => (bigint | boolean | number | string | BlankNode | Literal | NamedNode)[];
 export interface PropertyShape {
     readonly $identifier: PropertyShape.$Identifier;
     readonly $type: "PropertyShape";
@@ -91,7 +120,7 @@ export interface PropertyShape {
     readonly not: readonly (BlankNode | NamedNode)[];
     readonly or: readonly (readonly (BlankNode | NamedNode)[])[];
     readonly order: Maybe<number>;
-    readonly path: PropertyPath;
+    readonly path: $PropertyPath;
     readonly patterns: readonly string[];
     readonly resolve: Maybe<BlankNode | NamedNode>;
     readonly uniqueLang: Maybe<boolean>;
@@ -137,17 +166,18 @@ export declare namespace PropertyShape {
         readonly not?: $CollectionFilter<$IdentifierFilter>;
         readonly or?: $CollectionFilter<$CollectionFilter<$IdentifierFilter>>;
         readonly order?: $MaybeFilter<$NumericFilter<number>>;
-        readonly path?: PropertyPath.$Filter;
+        readonly path?: $PropertyPath.$Filter;
         readonly patterns?: $CollectionFilter<$StringFilter>;
         readonly resolve?: $MaybeFilter<$IdentifierFilter>;
         readonly uniqueLang?: $MaybeFilter<$BooleanFilter>;
         readonly visibility?: $MaybeFilter<$IriFilter>;
         readonly xone?: $CollectionFilter<$CollectionFilter<$IdentifierFilter>>;
     };
-    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, PropertyShape>;
+    const $fromRdfResource: $FromRdfResourceFunction<PropertyShape>;
+    const $fromRdfResourceValues: $FromRdfResourceValuesFunction<PropertyShape>;
     const $fromRdfType: NamedNode<string>;
     function isPropertyShape(object: $Object): object is PropertyShape;
-    function $propertiesFromRdf($parameters: $PropertiesFromRdfParameters): Either<Error, {
+    const $propertiesFromRdfResource: $PropertiesFromRdfResourceFunction<{
         $identifier: BlankNode | NamedNode;
         $type: "PropertyShape";
         and: readonly (readonly (BlankNode | NamedNode)[])[];
@@ -180,7 +210,7 @@ export declare namespace PropertyShape {
         not: readonly (BlankNode | NamedNode)[];
         or: readonly (readonly (BlankNode | NamedNode)[])[];
         order: Maybe<number>;
-        path: PropertyPath;
+        path: $PropertyPath;
         patterns: readonly string[];
         resolve: Maybe<BlankNode | NamedNode>;
         uniqueLang: Maybe<boolean>;
@@ -196,7 +226,7 @@ export declare namespace PropertyShape {
                 };
             };
             readonly $type: {
-                readonly kind: "TypeDiscriminant";
+                readonly kind: "Discriminant";
                 readonly type: () => {
                     kind: "TypeDiscriminant";
                     ownValues: string[];
@@ -576,11 +606,7 @@ export declare namespace PropertyShape {
             };
         };
     };
-    function $toRdf(_propertyShape: PropertyShape, options?: {
-        ignoreRdfType?: boolean;
-        graph?: Exclude<Quad_Graph, Variable>;
-        resourceSet?: ResourceSet;
-    }): Resource;
+    function $toRdfResource(_propertyShape: PropertyShape, options?: Parameters<$ToRdfResourceFunction<PropertyShape>>[1]): Resource;
 }
 export interface PropertyGroup {
     readonly $identifier: PropertyGroup.$Identifier;
@@ -600,10 +626,11 @@ export declare namespace PropertyGroup {
         readonly comments?: $CollectionFilter<$StringFilter>;
         readonly labels?: $CollectionFilter<$StringFilter>;
     };
-    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, PropertyGroup>;
+    const $fromRdfResource: $FromRdfResourceFunction<PropertyGroup>;
+    const $fromRdfResourceValues: $FromRdfResourceValuesFunction<PropertyGroup>;
     const $fromRdfType: NamedNode<string>;
     function isPropertyGroup(object: $Object): object is PropertyGroup;
-    function $propertiesFromRdf($parameters: $PropertiesFromRdfParameters): Either<Error, {
+    const $propertiesFromRdfResource: $PropertiesFromRdfResourceFunction<{
         $identifier: BlankNode | NamedNode;
         $type: "PropertyGroup";
         comments: readonly string[];
@@ -618,7 +645,7 @@ export declare namespace PropertyGroup {
                 };
             };
             readonly $type: {
-                readonly kind: "TypeDiscriminant";
+                readonly kind: "Discriminant";
                 readonly type: () => {
                     kind: "TypeDiscriminant";
                     ownValues: string[];
@@ -646,11 +673,7 @@ export declare namespace PropertyGroup {
             };
         };
     };
-    function $toRdf(_propertyGroup: PropertyGroup, options?: {
-        ignoreRdfType?: boolean;
-        graph?: Exclude<Quad_Graph, Variable>;
-        resourceSet?: ResourceSet;
-    }): Resource;
+    function $toRdfResource(_propertyGroup: PropertyGroup, options?: Parameters<$ToRdfResourceFunction<PropertyGroup>>[1]): Resource;
 }
 export interface Ontology {
     readonly $identifier: Ontology.$Identifier;
@@ -676,10 +699,11 @@ export declare namespace Ontology {
         readonly tsImports?: $CollectionFilter<$StringFilter>;
         readonly tsObjectDeclarationType?: $MaybeFilter<$IriFilter>;
     };
-    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, Ontology>;
+    const $fromRdfResource: $FromRdfResourceFunction<Ontology>;
+    const $fromRdfResourceValues: $FromRdfResourceValuesFunction<Ontology>;
     const $fromRdfType: NamedNode<string>;
     function isOntology(object: $Object): object is Ontology;
-    function $propertiesFromRdf($parameters: $PropertiesFromRdfParameters): Either<Error, {
+    const $propertiesFromRdfResource: $PropertiesFromRdfResourceFunction<{
         $identifier: BlankNode | NamedNode;
         $type: "Ontology";
         labels: readonly string[];
@@ -697,7 +721,7 @@ export declare namespace Ontology {
                 };
             };
             readonly $type: {
-                readonly kind: "TypeDiscriminant";
+                readonly kind: "Discriminant";
                 readonly type: () => {
                     kind: "TypeDiscriminant";
                     ownValues: string[];
@@ -758,11 +782,7 @@ export declare namespace Ontology {
             };
         };
     };
-    function $toRdf(_ontology: Ontology, options?: {
-        ignoreRdfType?: boolean;
-        graph?: Exclude<Quad_Graph, Variable>;
-        resourceSet?: ResourceSet;
-    }): Resource;
+    function $toRdfResource(_ontology: Ontology, options?: Parameters<$ToRdfResourceFunction<Ontology>>[1]): Resource;
 }
 export interface NodeShape {
     readonly $identifier: NodeShape.$Identifier;
@@ -775,7 +795,6 @@ export interface NodeShape {
     readonly datatype: Maybe<NamedNode>;
     readonly deactivated: Maybe<boolean>;
     readonly discriminantValue: Maybe<string>;
-    readonly export_: Maybe<boolean>;
     readonly extern: Maybe<boolean>;
     readonly flags: readonly string[];
     readonly fromRdfType: Maybe<NamedNode>;
@@ -827,7 +846,6 @@ export declare namespace NodeShape {
         readonly datatype?: $MaybeFilter<$IriFilter>;
         readonly deactivated?: $MaybeFilter<$BooleanFilter>;
         readonly discriminantValue?: $MaybeFilter<$StringFilter>;
-        readonly export_?: $MaybeFilter<$BooleanFilter>;
         readonly extern?: $MaybeFilter<$BooleanFilter>;
         readonly flags?: $CollectionFilter<$StringFilter>;
         readonly fromRdfType?: $MaybeFilter<$IriFilter>;
@@ -862,10 +880,11 @@ export declare namespace NodeShape {
         readonly tsObjectDeclarationType?: $MaybeFilter<$IriFilter>;
         readonly xone?: $CollectionFilter<$CollectionFilter<$IdentifierFilter>>;
     };
-    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, NodeShape>;
+    const $fromRdfResource: $FromRdfResourceFunction<NodeShape>;
+    const $fromRdfResourceValues: $FromRdfResourceValuesFunction<NodeShape>;
     const $fromRdfType: NamedNode<string>;
     function isNodeShape(object: $Object): object is NodeShape;
-    function $propertiesFromRdf($parameters: $PropertiesFromRdfParameters): Either<Error, {
+    const $propertiesFromRdfResource: $PropertiesFromRdfResourceFunction<{
         $identifier: BlankNode | NamedNode;
         $type: "NodeShape";
         abstract: Maybe<boolean>;
@@ -876,7 +895,6 @@ export declare namespace NodeShape {
         datatype: Maybe<NamedNode>;
         deactivated: Maybe<boolean>;
         discriminantValue: Maybe<string>;
-        export_: Maybe<boolean>;
         extern: Maybe<boolean>;
         flags: readonly string[];
         fromRdfType: Maybe<NamedNode>;
@@ -920,7 +938,7 @@ export declare namespace NodeShape {
                 };
             };
             readonly $type: {
-                readonly kind: "TypeDiscriminant";
+                readonly kind: "Discriminant";
                 readonly type: () => {
                     kind: "TypeDiscriminant";
                     ownValues: string[];
@@ -1009,16 +1027,6 @@ export declare namespace NodeShape {
                 };
                 readonly path: NamedNode<"http://purl.org/shaclmate/ontology#discriminantValue">;
             };
-            readonly export_: {
-                readonly kind: "Shacl";
-                readonly type: () => {
-                    kind: "Maybe";
-                    item: () => {
-                        kind: "Boolean";
-                    };
-                };
-                readonly path: NamedNode<"http://purl.org/shaclmate/ontology#export">;
-            };
             readonly extern: {
                 readonly kind: "Shacl";
                 readonly type: () => {
@@ -1371,30 +1379,875 @@ export declare namespace NodeShape {
             };
         };
     };
-    function $toRdf(_nodeShape: NodeShape, options?: {
-        ignoreRdfType?: boolean;
-        graph?: Exclude<Quad_Graph, Variable>;
-        resourceSet?: ResourceSet;
-    }): Resource;
+    function $toRdfResource(_nodeShape: NodeShape, options?: Parameters<$ToRdfResourceFunction<NodeShape>>[1]): Resource;
 }
 export type Shape = NodeShape | PropertyShape;
 export declare namespace Shape {
+    const $toRdfResource: $ToRdfResourceFunction<Shape>;
+    const $filter: (filter: Shape.$Filter, value: Shape) => boolean;
+    type $Filter = {
+        readonly $identifier?: $IdentifierFilter;
+        readonly on?: {
+            readonly NodeShape?: NodeShape.$Filter;
+            readonly PropertyShape?: PropertyShape.$Filter;
+        };
+    };
+    const $fromRdfResource: $FromRdfResourceFunction<Shape>;
+    const $fromRdfResourceValues: $FromRdfResourceValuesFunction<Shape>;
     type $Identifier = BlankNode | NamedNode;
     namespace $Identifier {
         const fromString: typeof $identifierFromString;
         const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
     }
-    function $filter(filter: Shape.$Filter, value: Shape): boolean;
-    interface $Filter {
-        readonly $identifier?: $IdentifierFilter;
-        readonly on?: {
-            readonly NodeShape?: Omit<NodeShape.$Filter, "$identifier">;
-            readonly PropertyShape?: Omit<PropertyShape.$Filter, "$identifier">;
-        };
-    }
-    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, Shape>;
-    function isShape(object: $Object): object is Shape;
     const $schema: {
+        readonly kind: "NamedObjectUnion";
+        readonly members: {
+            readonly NodeShape: {
+                readonly discriminantValues: readonly ["NodeShape"];
+                readonly type: {
+                    readonly properties: {
+                        readonly $identifier: {
+                            readonly kind: "Identifier";
+                            readonly type: () => {
+                                kind: "Identifier";
+                            };
+                        };
+                        readonly $type: {
+                            readonly kind: "Discriminant";
+                            readonly type: () => {
+                                kind: "TypeDiscriminant";
+                                ownValues: string[];
+                            };
+                        };
+                        readonly abstract: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#abstract">;
+                        };
+                        readonly and: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#and">;
+                        };
+                        readonly classes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#class">;
+                        };
+                        readonly closed: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#closed">;
+                        };
+                        readonly comments: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#comment">;
+                        };
+                        readonly datatype: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#datatype">;
+                        };
+                        readonly deactivated: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#deactivated">;
+                        };
+                        readonly discriminantValue: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#discriminantValue">;
+                        };
+                        readonly extern: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#extern">;
+                        };
+                        readonly flags: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#flags">;
+                        };
+                        readonly fromRdfType: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#fromRdfType">;
+                        };
+                        readonly hasValues: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Term";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#hasValue">;
+                        };
+                        readonly identifierMintingStrategy: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode"> | NamedNode<"http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_SHA256"> | NamedNode<"http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_UUIDv4">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#identifierMintingStrategy">;
+                        };
+                        readonly ignoredProperties: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Iri";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#ignoredProperties">;
+                        };
+                        readonly in_: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Term";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#in">;
+                        };
+                        readonly isDefinedBy: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#isDefinedBy">;
+                        };
+                        readonly labels: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
+                        };
+                        readonly languageIn: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "String";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#languageIn">;
+                        };
+                        readonly maxCount: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxCount">;
+                        };
+                        readonly maxExclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxExclusive">;
+                        };
+                        readonly maxInclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxInclusive">;
+                        };
+                        readonly maxLength: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxLength">;
+                        };
+                        readonly minCount: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minCount">;
+                        };
+                        readonly minExclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minExclusive">;
+                        };
+                        readonly minInclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minInclusive">;
+                        };
+                        readonly minLength: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minLength">;
+                        };
+                        readonly mutable: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#mutable">;
+                        };
+                        readonly name: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#name">;
+                        };
+                        readonly nodeKind: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | NamedNode<"http://www.w3.org/ns/shacl#IRI"> | NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
+                        };
+                        readonly nodes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#node">;
+                        };
+                        readonly not: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#not">;
+                        };
+                        readonly or: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#or">;
+                        };
+                        readonly patterns: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#pattern">;
+                        };
+                        readonly properties: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#property">;
+                        };
+                        readonly rdfType: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#rdfType">;
+                        };
+                        readonly toRdfTypes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#toRdfType">;
+                        };
+                        readonly tsFeatureExcludes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Create"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_Default"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Equals"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Graphql"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Hash"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Json"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_None"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Rdf"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Sparql">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#tsFeatureExclude">;
+                        };
+                        readonly tsFeatureIncludes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Create"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_Default"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Equals"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Graphql"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Hash"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Json"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_None"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Rdf"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Sparql">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#tsFeatureInclude">;
+                        };
+                        readonly tsImports: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#tsImport">;
+                        };
+                        readonly tsObjectDeclarationType: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#tsObjectDeclarationType">;
+                        };
+                        readonly xone: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#xone">;
+                        };
+                    };
+                };
+            };
+            readonly PropertyShape: {
+                readonly discriminantValues: readonly ["PropertyShape"];
+                readonly type: {
+                    readonly properties: {
+                        readonly $identifier: {
+                            readonly kind: "Identifier";
+                            readonly type: () => {
+                                kind: "Identifier";
+                            };
+                        };
+                        readonly $type: {
+                            readonly kind: "Discriminant";
+                            readonly type: () => {
+                                kind: "TypeDiscriminant";
+                                ownValues: string[];
+                            };
+                        };
+                        readonly and: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#and">;
+                        };
+                        readonly classes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#class">;
+                        };
+                        readonly comments: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#comment">;
+                        };
+                        readonly datatype: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#datatype">;
+                        };
+                        readonly deactivated: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#deactivated">;
+                        };
+                        readonly defaultValue: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Term";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#defaultValue">;
+                        };
+                        readonly descriptions: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#description">;
+                        };
+                        readonly flags: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#flags">;
+                        };
+                        readonly groups: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#group">;
+                        };
+                        readonly hasValues: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Term";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#hasValue">;
+                        };
+                        readonly in_: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Term";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#in">;
+                        };
+                        readonly isDefinedBy: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#isDefinedBy">;
+                        };
+                        readonly labels: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
+                        };
+                        readonly languageIn: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "String";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#languageIn">;
+                        };
+                        readonly maxCount: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxCount">;
+                        };
+                        readonly maxExclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxExclusive">;
+                        };
+                        readonly maxInclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxInclusive">;
+                        };
+                        readonly maxLength: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxLength">;
+                        };
+                        readonly minCount: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minCount">;
+                        };
+                        readonly minExclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minExclusive">;
+                        };
+                        readonly minInclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minInclusive">;
+                        };
+                        readonly minLength: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minLength">;
+                        };
+                        readonly mutable: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#mutable">;
+                        };
+                        readonly name: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#name">;
+                        };
+                        readonly names: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#name">;
+                        };
+                        readonly nodeKind: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | NamedNode<"http://www.w3.org/ns/shacl#IRI"> | NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
+                        };
+                        readonly nodes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#node">;
+                        };
+                        readonly not: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#not">;
+                        };
+                        readonly or: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#or">;
+                        };
+                        readonly order: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Float";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#order">;
+                        };
+                        readonly path: {
+                            readonly kind: "Shacl";
+                            readonly type: () => object;
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#path">;
+                        };
+                        readonly patterns: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#pattern">;
+                        };
+                        readonly resolve: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#resolve">;
+                        };
+                        readonly uniqueLang: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#uniqueLang">;
+                        };
+                        readonly visibility: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://purl.org/shaclmate/ontology#_Visibility_Private"> | NamedNode<"http://purl.org/shaclmate/ontology#_Visibility_Protected"> | NamedNode<"http://purl.org/shaclmate/ontology#_Visibility_Public">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#visibility">;
+                        };
+                        readonly xone: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#xone">;
+                        };
+                    };
+                };
+            };
+        };
         readonly properties: {
             readonly and: {
                 readonly kind: "Shacl";
@@ -1684,30 +2537,991 @@ export declare namespace Shape {
             };
         };
     };
-    function $toRdf(_shape: Shape, _parameters?: {
-        graph?: Exclude<Quad_Graph, Variable>;
-        resourceSet?: ResourceSet;
-    }): Resource;
+    const $toRdfResourceValues: $ToRdfResourceValuesFunction<Shape>;
+    function isShape(object: $Object): object is Shape;
 }
 export type $Object = NodeShape | Ontology | PropertyGroup | PropertyShape;
 export declare namespace $Object {
+    const $toRdfResource: $ToRdfResourceFunction<$Object>;
+    const $filter: (filter: $Object.$Filter, value: $Object) => boolean;
+    type $Filter = {
+        readonly $identifier?: $IdentifierFilter;
+        readonly on?: {
+            readonly NodeShape?: NodeShape.$Filter;
+            readonly Ontology?: Ontology.$Filter;
+            readonly PropertyGroup?: PropertyGroup.$Filter;
+            readonly PropertyShape?: PropertyShape.$Filter;
+        };
+    };
+    const $fromRdfResource: $FromRdfResourceFunction<$Object>;
+    const $fromRdfResourceValues: $FromRdfResourceValuesFunction<$Object>;
     type $Identifier = BlankNode | NamedNode;
     namespace $Identifier {
         const fromString: typeof $identifierFromString;
         const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
     }
-    function $filter(filter: $Object.$Filter, value: $Object): boolean;
-    interface $Filter {
-        readonly $identifier?: $IdentifierFilter;
-        readonly on?: {
-            readonly NodeShape?: Omit<NodeShape.$Filter, "$identifier">;
-            readonly Ontology?: Omit<Ontology.$Filter, "$identifier">;
-            readonly PropertyGroup?: Omit<PropertyGroup.$Filter, "$identifier">;
-            readonly PropertyShape?: Omit<PropertyShape.$Filter, "$identifier">;
-        };
-    }
-    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, $Object>;
     const $schema: {
+        readonly kind: "NamedObjectUnion";
+        readonly members: {
+            readonly NodeShape: {
+                readonly discriminantValues: readonly ["NodeShape"];
+                readonly type: {
+                    readonly properties: {
+                        readonly $identifier: {
+                            readonly kind: "Identifier";
+                            readonly type: () => {
+                                kind: "Identifier";
+                            };
+                        };
+                        readonly $type: {
+                            readonly kind: "Discriminant";
+                            readonly type: () => {
+                                kind: "TypeDiscriminant";
+                                ownValues: string[];
+                            };
+                        };
+                        readonly abstract: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#abstract">;
+                        };
+                        readonly and: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#and">;
+                        };
+                        readonly classes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#class">;
+                        };
+                        readonly closed: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#closed">;
+                        };
+                        readonly comments: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#comment">;
+                        };
+                        readonly datatype: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#datatype">;
+                        };
+                        readonly deactivated: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#deactivated">;
+                        };
+                        readonly discriminantValue: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#discriminantValue">;
+                        };
+                        readonly extern: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#extern">;
+                        };
+                        readonly flags: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#flags">;
+                        };
+                        readonly fromRdfType: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#fromRdfType">;
+                        };
+                        readonly hasValues: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Term";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#hasValue">;
+                        };
+                        readonly identifierMintingStrategy: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode"> | NamedNode<"http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_SHA256"> | NamedNode<"http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_UUIDv4">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#identifierMintingStrategy">;
+                        };
+                        readonly ignoredProperties: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Iri";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#ignoredProperties">;
+                        };
+                        readonly in_: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Term";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#in">;
+                        };
+                        readonly isDefinedBy: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#isDefinedBy">;
+                        };
+                        readonly labels: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
+                        };
+                        readonly languageIn: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "String";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#languageIn">;
+                        };
+                        readonly maxCount: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxCount">;
+                        };
+                        readonly maxExclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxExclusive">;
+                        };
+                        readonly maxInclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxInclusive">;
+                        };
+                        readonly maxLength: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxLength">;
+                        };
+                        readonly minCount: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minCount">;
+                        };
+                        readonly minExclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minExclusive">;
+                        };
+                        readonly minInclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minInclusive">;
+                        };
+                        readonly minLength: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minLength">;
+                        };
+                        readonly mutable: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#mutable">;
+                        };
+                        readonly name: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#name">;
+                        };
+                        readonly nodeKind: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | NamedNode<"http://www.w3.org/ns/shacl#IRI"> | NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
+                        };
+                        readonly nodes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#node">;
+                        };
+                        readonly not: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#not">;
+                        };
+                        readonly or: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#or">;
+                        };
+                        readonly patterns: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#pattern">;
+                        };
+                        readonly properties: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#property">;
+                        };
+                        readonly rdfType: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#rdfType">;
+                        };
+                        readonly toRdfTypes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#toRdfType">;
+                        };
+                        readonly tsFeatureExcludes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Create"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_Default"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Equals"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Graphql"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Hash"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Json"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_None"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Rdf"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Sparql">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#tsFeatureExclude">;
+                        };
+                        readonly tsFeatureIncludes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Create"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_Default"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Equals"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Graphql"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Hash"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Json"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_None"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Rdf"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Sparql">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#tsFeatureInclude">;
+                        };
+                        readonly tsImports: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#tsImport">;
+                        };
+                        readonly tsObjectDeclarationType: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#tsObjectDeclarationType">;
+                        };
+                        readonly xone: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#xone">;
+                        };
+                    };
+                };
+            };
+            readonly Ontology: {
+                readonly discriminantValues: readonly ["Ontology"];
+                readonly type: {
+                    readonly properties: {
+                        readonly $identifier: {
+                            readonly kind: "Identifier";
+                            readonly type: () => {
+                                kind: "Identifier";
+                            };
+                        };
+                        readonly $type: {
+                            readonly kind: "Discriminant";
+                            readonly type: () => {
+                                kind: "TypeDiscriminant";
+                                ownValues: string[];
+                            };
+                        };
+                        readonly labels: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
+                        };
+                        readonly tsFeatureExcludes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Create"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_Default"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Equals"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Graphql"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Hash"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Json"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_None"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Rdf"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Sparql">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#tsFeatureExclude">;
+                        };
+                        readonly tsFeatureIncludes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Create"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_Default"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Equals"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Graphql"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Hash"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Json"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_None"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Rdf"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_Sparql">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#tsFeatureInclude">;
+                        };
+                        readonly tsImports: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#tsImport">;
+                        };
+                        readonly tsObjectDeclarationType: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class"> | NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#tsObjectDeclarationType">;
+                        };
+                    };
+                };
+            };
+            readonly PropertyGroup: {
+                readonly discriminantValues: readonly ["PropertyGroup"];
+                readonly type: {
+                    readonly properties: {
+                        readonly $identifier: {
+                            readonly kind: "Identifier";
+                            readonly type: () => {
+                                kind: "Identifier";
+                            };
+                        };
+                        readonly $type: {
+                            readonly kind: "Discriminant";
+                            readonly type: () => {
+                                kind: "TypeDiscriminant";
+                                ownValues: string[];
+                            };
+                        };
+                        readonly comments: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#comment">;
+                        };
+                        readonly labels: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
+                        };
+                    };
+                };
+            };
+            readonly PropertyShape: {
+                readonly discriminantValues: readonly ["PropertyShape"];
+                readonly type: {
+                    readonly properties: {
+                        readonly $identifier: {
+                            readonly kind: "Identifier";
+                            readonly type: () => {
+                                kind: "Identifier";
+                            };
+                        };
+                        readonly $type: {
+                            readonly kind: "Discriminant";
+                            readonly type: () => {
+                                kind: "TypeDiscriminant";
+                                ownValues: string[];
+                            };
+                        };
+                        readonly and: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#and">;
+                        };
+                        readonly classes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#class">;
+                        };
+                        readonly comments: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#comment">;
+                        };
+                        readonly datatype: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#datatype">;
+                        };
+                        readonly deactivated: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#deactivated">;
+                        };
+                        readonly defaultValue: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Term";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#defaultValue">;
+                        };
+                        readonly descriptions: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#description">;
+                        };
+                        readonly flags: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#flags">;
+                        };
+                        readonly groups: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#group">;
+                        };
+                        readonly hasValues: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Term";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#hasValue">;
+                        };
+                        readonly in_: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Term";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#in">;
+                        };
+                        readonly isDefinedBy: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#isDefinedBy">;
+                        };
+                        readonly labels: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
+                        };
+                        readonly languageIn: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "String";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#languageIn">;
+                        };
+                        readonly maxCount: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxCount">;
+                        };
+                        readonly maxExclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxExclusive">;
+                        };
+                        readonly maxInclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxInclusive">;
+                        };
+                        readonly maxLength: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxLength">;
+                        };
+                        readonly minCount: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minCount">;
+                        };
+                        readonly minExclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minExclusive">;
+                        };
+                        readonly minInclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minInclusive">;
+                        };
+                        readonly minLength: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minLength">;
+                        };
+                        readonly mutable: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#mutable">;
+                        };
+                        readonly name: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#name">;
+                        };
+                        readonly names: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#name">;
+                        };
+                        readonly nodeKind: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | NamedNode<"http://www.w3.org/ns/shacl#IRI"> | NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
+                        };
+                        readonly nodes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#node">;
+                        };
+                        readonly not: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#not">;
+                        };
+                        readonly or: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#or">;
+                        };
+                        readonly order: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Float";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#order">;
+                        };
+                        readonly path: {
+                            readonly kind: "Shacl";
+                            readonly type: () => object;
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#path">;
+                        };
+                        readonly patterns: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#pattern">;
+                        };
+                        readonly resolve: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#resolve">;
+                        };
+                        readonly uniqueLang: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#uniqueLang">;
+                        };
+                        readonly visibility: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://purl.org/shaclmate/ontology#_Visibility_Private"> | NamedNode<"http://purl.org/shaclmate/ontology#_Visibility_Protected"> | NamedNode<"http://purl.org/shaclmate/ontology#_Visibility_Public">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://purl.org/shaclmate/ontology#visibility">;
+                        };
+                        readonly xone: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#xone">;
+                        };
+                    };
+                };
+            };
+        };
         readonly properties: {
             readonly labels: {
                 readonly kind: "Shacl";
@@ -1721,10 +3535,7 @@ export declare namespace $Object {
             };
         };
     };
-    function $toRdf(_object: $Object, _parameters?: {
-        graph?: Exclude<Quad_Graph, Variable>;
-        resourceSet?: ResourceSet;
-    }): Resource;
+    const $toRdfResourceValues: $ToRdfResourceValuesFunction<$Object>;
 }
 export interface $ObjectSet {
     nodeShape(identifier: NodeShape.$Identifier, options?: {
@@ -1858,14 +3669,14 @@ export declare class $RdfjsDatasetObjectSet implements $ObjectSet {
         readonly $identifier: ObjectIdentifierT;
     }, ObjectFilterT, ObjectIdentifierT extends BlankNode | NamedNode>(objectType: {
         $filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
-        $fromRdf: (resource: Resource, options?: $FromRdfOptions) => Either<Error, ObjectT>;
+        $fromRdfResource: $FromRdfResourceFunction<ObjectT>;
         $fromRdfTypes: readonly NamedNode[];
     }, query?: $ObjectSet.Query<ObjectFilterT, ObjectIdentifierT>): Either<Error, readonly ObjectT[]>;
     protected $objectUnionsSync<ObjectT extends {
         readonly $identifier: ObjectIdentifierT;
     }, ObjectFilterT, ObjectIdentifierT extends BlankNode | NamedNode>(objectTypes: readonly {
         $filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
-        $fromRdf: (resource: Resource, options?: $FromRdfOptions) => Either<Error, ObjectT>;
+        $fromRdfResource: $FromRdfResourceFunction<ObjectT>;
         $fromRdfTypes: readonly NamedNode[];
     }[], query?: $ObjectSet.Query<ObjectFilterT, ObjectIdentifierT>): Either<Error, readonly ObjectT[]>;
 }