@shaclmate/compiler 3.0.4 → 4.0.0

package/dist/input/generated.d.ts

@@ -1,1185 +1,3173 @@
-import type * as rdfjs from "@rdfjs/types";
-import * as purify from "purify-ts";
-import * as rdfjsResource from "rdfjs-resource";
-import { PropertyPath } from "./PropertyPath.js";
-export declare namespace $RdfVocabularies {
-    namespace rdf {
-        const first: import("n3").NamedNode<"http://www.w3.org/1999/02/22-rdf-syntax-ns#first">;
-        const nil: import("n3").NamedNode<"http://www.w3.org/1999/02/22-rdf-syntax-ns#nil">;
-        const rest: import("n3").NamedNode<"http://www.w3.org/1999/02/22-rdf-syntax-ns#rest">;
-        const subject: import("n3").NamedNode<"http://www.w3.org/1999/02/22-rdf-syntax-ns#subject">;
-        const type: import("n3").NamedNode<"http://www.w3.org/1999/02/22-rdf-syntax-ns#type">;
-    }
-    namespace rdfs {
-        const subClassOf: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#subClassOf">;
-    }
-    namespace xsd {
-        const boolean: import("n3").NamedNode<"http://www.w3.org/2001/XMLSchema#boolean">;
-        const date: import("n3").NamedNode<"http://www.w3.org/2001/XMLSchema#date">;
-        const dateTime: import("n3").NamedNode<"http://www.w3.org/2001/XMLSchema#dateTime">;
-        const integer: import("n3").NamedNode<"http://www.w3.org/2001/XMLSchema#integer">;
-    }
+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";
+interface $BooleanFilter {
+    readonly value?: boolean;
+}
+type $CollectionFilter<ItemFilterT> = ItemFilterT & {
+    readonly $maxCount?: number;
+    readonly $minCount?: number;
+};
+type $FromRdfOptions = {
+    context?: unknown;
+    graph?: Exclude<Quad_Graph, Variable>;
+    ignoreRdfType?: boolean;
+    objectSet?: $ObjectSet;
+    preferredLanguages?: readonly string[];
+};
+interface $IdentifierFilter {
+    readonly in?: readonly (BlankNode | NamedNode)[];
+    readonly type?: "BlankNode" | "NamedNode";
 }
-type $UnwrapR<T> = T extends purify.Either<any, infer R> ? R : never;
+declare function $identifierFromString(identifier: string): Either<Error, BlankNode | NamedNode>;
+interface $IriFilter {
+    readonly in?: readonly NamedNode[];
+}
+interface $LiteralFilter extends Omit<$TermFilter, "in" | "type"> {
+    readonly in?: readonly Literal[];
+}
+type $MaybeFilter<ItemFilterT> = ItemFilterT | null;
+interface $NumericFilter<T> {
+    readonly in?: readonly T[];
+    readonly maxExclusive?: T;
+    readonly maxInclusive?: T;
+    readonly minExclusive?: T;
+    readonly minInclusive?: T;
+}
+type $PropertiesFromRdfParameters = {
+    context?: unknown;
+    graph?: Exclude<Quad_Graph, Variable>;
+    ignoreRdfType: boolean;
+    objectSet: $ObjectSet;
+    preferredLanguages?: readonly string[];
+    resource: Resource;
+};
+export interface $ShaclPropertySchema<TypeSchemaT = object> {
+    readonly kind: "Shacl";
+    readonly path: PropertyPath;
+    readonly type: () => TypeSchemaT;
+}
+interface $StringFilter {
+    readonly in?: readonly string[];
+    readonly maxLength?: number;
+    readonly minLength?: number;
+}
+interface $TermFilter {
+    readonly datatypeIn?: readonly NamedNode[];
+    readonly in?: readonly (Literal | NamedNode)[];
+    readonly languageIn?: readonly string[];
+    readonly typeIn?: readonly ("BlankNode" | "Literal" | "NamedNode")[];
+}
+type $UnwrapR<T> = T extends Either<any, infer R> ? R : never;
 export interface BaseShaclCoreShape {
     readonly $identifier: BaseShaclCoreShapeStatic.$Identifier;
     readonly $type: "ShaclCoreNodeShape" | "ShaclCorePropertyShape" | "ShaclmateNodeShape" | "ShaclmatePropertyShape";
-    readonly and: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
-    readonly classes: readonly rdfjs.NamedNode[];
-    readonly comments: readonly rdfjs.Literal[];
-    readonly datatype: purify.Maybe<rdfjs.NamedNode>;
-    readonly deactivated: purify.Maybe<boolean>;
+    readonly and: readonly (readonly (BlankNode | NamedNode)[])[];
+    readonly classes: readonly NamedNode[];
+    readonly comments: readonly string[];
+    readonly datatype: Maybe<NamedNode>;
+    readonly deactivated: Maybe<boolean>;
     readonly flags: readonly string[];
-    readonly hasValues: readonly (rdfjs.Literal | rdfjs.NamedNode)[];
-    readonly in_: purify.Maybe<readonly (rdfjs.Literal | rdfjs.NamedNode)[]>;
-    readonly isDefinedBy: purify.Maybe<rdfjs.BlankNode | rdfjs.NamedNode>;
-    readonly labels: readonly rdfjs.Literal[];
-    readonly languageIn: purify.Maybe<readonly string[]>;
-    readonly maxCount: purify.Maybe<number>;
-    readonly maxExclusive: purify.Maybe<rdfjs.Literal>;
-    readonly maxInclusive: purify.Maybe<rdfjs.Literal>;
-    readonly maxLength: purify.Maybe<number>;
-    readonly minCount: purify.Maybe<number>;
-    readonly minExclusive: purify.Maybe<rdfjs.Literal>;
-    readonly minInclusive: purify.Maybe<rdfjs.Literal>;
-    readonly minLength: purify.Maybe<number>;
-    readonly nodeKind: purify.Maybe<rdfjs.NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">>;
-    readonly nodes: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
-    readonly not: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
-    readonly or: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
+    readonly hasValues: readonly (NamedNode | Literal)[];
+    readonly in_: Maybe<readonly (NamedNode | Literal)[]>;
+    readonly isDefinedBy: Maybe<BlankNode | NamedNode>;
+    readonly labels: readonly string[];
+    readonly languageIn: Maybe<readonly string[]>;
+    readonly maxCount: Maybe<number>;
+    readonly maxExclusive: Maybe<Literal>;
+    readonly maxInclusive: Maybe<Literal>;
+    readonly maxLength: Maybe<number>;
+    readonly minCount: Maybe<number>;
+    readonly minExclusive: Maybe<Literal>;
+    readonly minInclusive: Maybe<Literal>;
+    readonly minLength: Maybe<number>;
+    readonly nodeKind: Maybe<NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">>;
+    readonly nodes: readonly (BlankNode | NamedNode)[];
+    readonly not: readonly (BlankNode | NamedNode)[];
+    readonly or: readonly (readonly (BlankNode | NamedNode)[])[];
     readonly patterns: readonly string[];
-    readonly xone: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
+    readonly xone: readonly (readonly (BlankNode | NamedNode)[])[];
 }
 export declare namespace BaseShaclCoreShapeStatic {
-    type $Identifier = rdfjs.BlankNode | rdfjs.NamedNode;
+    function $filter(filter: BaseShaclCoreShapeStatic.$Filter, value: BaseShaclCoreShape): boolean;
+    type $Filter = {
+        readonly $identifier?: $IdentifierFilter;
+        readonly and?: $CollectionFilter<$CollectionFilter<$IdentifierFilter>>;
+        readonly classes?: $CollectionFilter<$IriFilter>;
+        readonly comments?: $CollectionFilter<$StringFilter>;
+        readonly datatype?: $MaybeFilter<$IriFilter>;
+        readonly deactivated?: $MaybeFilter<$BooleanFilter>;
+        readonly flags?: $CollectionFilter<$StringFilter>;
+        readonly hasValues?: $CollectionFilter<$TermFilter>;
+        readonly in_?: $MaybeFilter<$CollectionFilter<$TermFilter>>;
+        readonly isDefinedBy?: $MaybeFilter<$IdentifierFilter>;
+        readonly labels?: $CollectionFilter<$StringFilter>;
+        readonly languageIn?: $MaybeFilter<$CollectionFilter<$StringFilter>>;
+        readonly maxCount?: $MaybeFilter<$NumericFilter<number>>;
+        readonly maxExclusive?: $MaybeFilter<$LiteralFilter>;
+        readonly maxInclusive?: $MaybeFilter<$LiteralFilter>;
+        readonly maxLength?: $MaybeFilter<$NumericFilter<number>>;
+        readonly minCount?: $MaybeFilter<$NumericFilter<number>>;
+        readonly minExclusive?: $MaybeFilter<$LiteralFilter>;
+        readonly minInclusive?: $MaybeFilter<$LiteralFilter>;
+        readonly minLength?: $MaybeFilter<$NumericFilter<number>>;
+        readonly nodeKind?: $MaybeFilter<$IriFilter>;
+        readonly nodes?: $CollectionFilter<$IdentifierFilter>;
+        readonly not?: $CollectionFilter<$IdentifierFilter>;
+        readonly or?: $CollectionFilter<$CollectionFilter<$IdentifierFilter>>;
+        readonly patterns?: $CollectionFilter<$StringFilter>;
+        readonly xone?: $CollectionFilter<$CollectionFilter<$IdentifierFilter>>;
+    };
+    type $Identifier = BlankNode | NamedNode;
     namespace $Identifier {
-        function fromString(identifier: string): purify.Either<Error, rdfjsResource.Resource.Identifier>;
-        const // biome-ignore lint/suspicious/noShadowRestrictedNames:
-        toString: typeof rdfjsResource.Resource.Identifier.toString;
+        const fromString: typeof $identifierFromString;
+        const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
     }
-    function $fromRdf(resource: rdfjsResource.Resource, options?: {
-        [_index: string]: any;
-        ignoreRdfType?: boolean;
-        objectSet?: $ObjectSet;
-        preferredLanguages?: readonly string[];
-    }): purify.Either<Error, BaseShaclCoreShape>;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, ...$context }: {
-        [_index: string]: any;
-        ignoreRdfType: boolean;
-        objectSet: $ObjectSet;
-        preferredLanguages?: readonly string[];
-        resource: rdfjsResource.Resource;
-    }): purify.Either<Error, {
-        $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
-        and: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
-        classes: readonly rdfjs.NamedNode[];
-        comments: readonly rdfjs.Literal[];
-        datatype: purify.Maybe<rdfjs.NamedNode>;
-        deactivated: purify.Maybe<boolean>;
+    function isBaseShaclCoreShape(object: $Object): object is BaseShaclCoreShape;
+    function $propertiesFromRdf($parameters: $PropertiesFromRdfParameters): Either<Error, {
+        $identifier: BlankNode | NamedNode;
+        and: readonly (readonly (BlankNode | NamedNode)[])[];
+        classes: readonly NamedNode[];
+        comments: readonly string[];
+        datatype: Maybe<NamedNode>;
+        deactivated: Maybe<boolean>;
         flags: readonly string[];
-        hasValues: readonly (rdfjs.Literal | rdfjs.NamedNode)[];
-        in_: purify.Maybe<readonly (rdfjs.Literal | rdfjs.NamedNode)[]>;
-        isDefinedBy: purify.Maybe<rdfjs.BlankNode | rdfjs.NamedNode>;
-        labels: readonly rdfjs.Literal[];
-        languageIn: purify.Maybe<readonly string[]>;
-        maxCount: purify.Maybe<number>;
-        maxExclusive: purify.Maybe<rdfjs.Literal>;
-        maxInclusive: purify.Maybe<rdfjs.Literal>;
-        maxLength: purify.Maybe<number>;
-        minCount: purify.Maybe<number>;
-        minExclusive: purify.Maybe<rdfjs.Literal>;
-        minInclusive: purify.Maybe<rdfjs.Literal>;
-        minLength: purify.Maybe<number>;
-        nodeKind: purify.Maybe<rdfjs.NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">>;
-        nodes: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
-        not: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
-        or: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
+        hasValues: readonly (NamedNode | Literal)[];
+        in_: Maybe<readonly (NamedNode | Literal)[]>;
+        isDefinedBy: Maybe<BlankNode | NamedNode>;
+        labels: readonly string[];
+        languageIn: Maybe<readonly string[]>;
+        maxCount: Maybe<number>;
+        maxExclusive: Maybe<Literal>;
+        maxInclusive: Maybe<Literal>;
+        maxLength: Maybe<number>;
+        minCount: Maybe<number>;
+        minExclusive: Maybe<Literal>;
+        minInclusive: Maybe<Literal>;
+        minLength: Maybe<number>;
+        nodeKind: Maybe<NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">>;
+        nodes: readonly (BlankNode | NamedNode)[];
+        not: readonly (BlankNode | NamedNode)[];
+        or: readonly (readonly (BlankNode | NamedNode)[])[];
         patterns: readonly string[];
-        xone: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
+        xone: readonly (readonly (BlankNode | NamedNode)[])[];
     }>;
     function $toRdf(_baseShaclCoreShape: BaseShaclCoreShape, options?: {
         ignoreRdfType?: boolean;
-        mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet?: rdfjsResource.MutableResourceSet;
-    }): rdfjsResource.MutableResource;
-    const $properties: {
-        and: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#and">;
-        };
-        classes: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#class">;
-        };
-        comments: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#comment">;
-        };
-        datatype: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#datatype">;
-        };
-        deactivated: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#deactivated">;
-        };
-        flags: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#flags">;
-        };
-        hasValues: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#hasValue">;
-        };
-        in_: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#in">;
-        };
-        isDefinedBy: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#isDefinedBy">;
-        };
-        labels: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
-        };
-        languageIn: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#languageIn">;
-        };
-        maxCount: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxCount">;
-        };
-        maxExclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxExclusive">;
-        };
-        maxInclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxInclusive">;
-        };
-        maxLength: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxLength">;
-        };
-        minCount: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minCount">;
-        };
-        minExclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minExclusive">;
-        };
-        minInclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minInclusive">;
-        };
-        minLength: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minLength">;
-        };
-        nodeKind: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
-        };
-        nodes: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#node">;
-        };
-        not: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#not">;
-        };
-        or: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#or">;
-        };
-        patterns: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#pattern">;
-        };
-        xone: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#xone">;
+        graph?: Exclude<Quad_Graph, Variable>;
+        resourceSet?: ResourceSet;
+    }): Resource;
+    const $schema: {
+        readonly properties: {
+            readonly $identifier: {
+                readonly kind: "Identifier";
+                readonly type: () => {
+                    kind: "Identifier";
+                };
+            };
+            readonly $type: {
+                readonly kind: "TypeDiscriminant";
+                readonly type: () => {
+                    descendantValues: string[];
+                    kind: "TypeDiscriminant";
+                };
+            };
+            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 flags: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "String";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#flags">;
+            };
+            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 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 xone: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "List";
+                        item: () => {
+                            kind: "Identifier";
+                        };
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#xone">;
+            };
         };
     };
 }
 export interface ShaclCorePropertyShape extends BaseShaclCoreShape {
     readonly $identifier: ShaclCorePropertyShapeStatic.$Identifier;
     readonly $type: "ShaclCorePropertyShape" | "ShaclmatePropertyShape";
-    readonly defaultValue: purify.Maybe<rdfjs.Literal | rdfjs.NamedNode>;
-    readonly descriptions: readonly rdfjs.Literal[];
-    readonly groups: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
-    readonly names: readonly rdfjs.Literal[];
-    readonly order: purify.Maybe<number>;
+    readonly defaultValue: Maybe<NamedNode | Literal>;
+    readonly descriptions: readonly string[];
+    readonly groups: readonly (BlankNode | NamedNode)[];
+    readonly names: readonly string[];
+    readonly order: Maybe<number>;
     readonly path: PropertyPath;
-    readonly uniqueLang: purify.Maybe<boolean>;
+    readonly uniqueLang: Maybe<boolean>;
 }
 export declare namespace ShaclCorePropertyShapeStatic {
-    const $fromRdfType: rdfjs.NamedNode<string>;
-    type $Identifier = BaseShaclCoreShapeStatic.$Identifier;
-    const $Identifier: typeof BaseShaclCoreShapeStatic.$Identifier;
-    function $fromRdf(resource: rdfjsResource.Resource, options?: {
-        [_index: string]: any;
-        ignoreRdfType?: boolean;
-        objectSet?: $ObjectSet;
-        preferredLanguages?: readonly string[];
-    }): purify.Either<Error, ShaclCorePropertyShape>;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, ...$context }: {
-        [_index: string]: any;
-        ignoreRdfType: boolean;
-        objectSet: $ObjectSet;
-        preferredLanguages?: readonly string[];
-        resource: rdfjsResource.Resource;
-    }): purify.Either<Error, {
-        $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    function $filter(filter: ShaclCorePropertyShapeStatic.$Filter, value: ShaclCorePropertyShape): boolean;
+    type $Filter = {
+        readonly $identifier?: $IdentifierFilter;
+        readonly defaultValue?: $MaybeFilter<$TermFilter>;
+        readonly descriptions?: $CollectionFilter<$StringFilter>;
+        readonly groups?: $CollectionFilter<$IdentifierFilter>;
+        readonly names?: $CollectionFilter<$StringFilter>;
+        readonly order?: $MaybeFilter<$NumericFilter<number>>;
+        readonly path?: PropertyPath.$Filter;
+        readonly uniqueLang?: $MaybeFilter<$BooleanFilter>;
+    } & BaseShaclCoreShapeStatic.$Filter;
+    const $fromRdfType: NamedNode<string>;
+    type $Identifier = BlankNode | NamedNode;
+    namespace $Identifier {
+        const fromString: typeof $identifierFromString;
+        const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
+    }
+    function isShaclCorePropertyShape(object: $Object): object is ShaclCorePropertyShape;
+    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, ShaclCorePropertyShape>;
+    function $propertiesFromRdf($parameters: $PropertiesFromRdfParameters): Either<Error, {
+        $identifier: BlankNode | NamedNode;
         $type: "ShaclCorePropertyShape" | "ShaclmatePropertyShape";
-        defaultValue: purify.Maybe<rdfjs.Literal | rdfjs.NamedNode>;
-        descriptions: readonly rdfjs.Literal[];
-        groups: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
-        names: readonly rdfjs.Literal[];
-        order: purify.Maybe<number>;
+        defaultValue: Maybe<NamedNode | Literal>;
+        descriptions: readonly string[];
+        groups: readonly (BlankNode | NamedNode)[];
+        names: readonly string[];
+        order: Maybe<number>;
         path: PropertyPath;
-        uniqueLang: purify.Maybe<boolean>;
+        uniqueLang: Maybe<boolean>;
     } & $UnwrapR<ReturnType<typeof BaseShaclCoreShapeStatic.$propertiesFromRdf>>>;
     function $toRdf(_shaclCorePropertyShape: ShaclCorePropertyShape, options?: {
         ignoreRdfType?: boolean;
-        mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet?: rdfjsResource.MutableResourceSet;
-    }): rdfjsResource.MutableResource;
-    const $properties: {
-        defaultValue: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#defaultValue">;
-        };
-        descriptions: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#description">;
-        };
-        groups: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#group">;
-        };
-        names: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#name">;
-        };
-        order: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#order">;
-        };
-        path: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#path">;
-        };
-        uniqueLang: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#uniqueLang">;
-        };
-        and: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#and">;
-        };
-        classes: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#class">;
-        };
-        comments: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#comment">;
-        };
-        datatype: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#datatype">;
-        };
-        deactivated: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#deactivated">;
-        };
-        flags: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#flags">;
-        };
-        hasValues: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#hasValue">;
-        };
-        in_: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#in">;
-        };
-        isDefinedBy: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#isDefinedBy">;
-        };
-        labels: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
-        };
-        languageIn: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#languageIn">;
-        };
-        maxCount: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxCount">;
-        };
-        maxExclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxExclusive">;
-        };
-        maxInclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxInclusive">;
-        };
-        maxLength: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxLength">;
-        };
-        minCount: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minCount">;
-        };
-        minExclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minExclusive">;
-        };
-        minInclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minInclusive">;
-        };
-        minLength: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minLength">;
-        };
-        nodeKind: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
-        };
-        nodes: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#node">;
-        };
-        not: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#not">;
-        };
-        or: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#or">;
-        };
-        patterns: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#pattern">;
-        };
-        xone: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#xone">;
+        graph?: Exclude<Quad_Graph, Variable>;
+        resourceSet?: ResourceSet;
+    }): Resource;
+    const $schema: {
+        readonly properties: {
+            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 groups: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "Identifier";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#group">;
+            };
+            readonly names: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "String";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#name">;
+            };
+            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 uniqueLang: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Maybe";
+                    item: () => {
+                        kind: "Boolean";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#uniqueLang">;
+            };
+            readonly $identifier: {
+                readonly kind: "Identifier";
+                readonly type: () => {
+                    kind: "Identifier";
+                };
+            };
+            readonly $type: {
+                readonly kind: "TypeDiscriminant";
+                readonly type: () => {
+                    descendantValues: string[];
+                    kind: "TypeDiscriminant";
+                };
+            };
+            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 flags: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "String";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#flags">;
+            };
+            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 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 xone: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "List";
+                        item: () => {
+                            kind: "Identifier";
+                        };
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#xone">;
+            };
         };
     };
 }
 export interface ShaclmatePropertyShape extends ShaclCorePropertyShape {
     readonly $identifier: ShaclmatePropertyShape.$Identifier;
     readonly $type: "ShaclmatePropertyShape";
-    readonly lazy: purify.Maybe<boolean>;
-    readonly mutable: purify.Maybe<boolean>;
-    readonly name: purify.Maybe<string>;
-    readonly stub: purify.Maybe<rdfjs.BlankNode | rdfjs.NamedNode>;
-    readonly visibility: purify.Maybe<rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_Visibility_Private" | "http://purl.org/shaclmate/ontology#_Visibility_Protected" | "http://purl.org/shaclmate/ontology#_Visibility_Public">>;
-    readonly widen: purify.Maybe<boolean>;
+    readonly mutable: Maybe<boolean>;
+    readonly name: Maybe<string>;
+    readonly resolve: Maybe<BlankNode | NamedNode>;
+    readonly visibility: Maybe<NamedNode<"http://purl.org/shaclmate/ontology#_Visibility_Private" | "http://purl.org/shaclmate/ontology#_Visibility_Protected" | "http://purl.org/shaclmate/ontology#_Visibility_Public">>;
 }
 export declare namespace ShaclmatePropertyShape {
-    const $fromRdfType: rdfjs.NamedNode<string>;
-    type $Identifier = ShaclCorePropertyShapeStatic.$Identifier;
-    const $Identifier: typeof BaseShaclCoreShapeStatic.$Identifier;
-    function $fromRdf(resource: rdfjsResource.Resource, options?: {
-        [_index: string]: any;
-        ignoreRdfType?: boolean;
-        objectSet?: $ObjectSet;
-        preferredLanguages?: readonly string[];
-    }): purify.Either<Error, ShaclmatePropertyShape>;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, ...$context }: {
-        [_index: string]: any;
-        ignoreRdfType: boolean;
-        objectSet: $ObjectSet;
-        preferredLanguages?: readonly string[];
-        resource: rdfjsResource.Resource;
-    }): purify.Either<Error, {
-        $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    function $filter(filter: ShaclmatePropertyShape.$Filter, value: ShaclmatePropertyShape): boolean;
+    type $Filter = {
+        readonly $identifier?: $IdentifierFilter;
+        readonly mutable?: $MaybeFilter<$BooleanFilter>;
+        readonly name?: $MaybeFilter<$StringFilter>;
+        readonly resolve?: $MaybeFilter<$IdentifierFilter>;
+        readonly visibility?: $MaybeFilter<$IriFilter>;
+    } & ShaclCorePropertyShapeStatic.$Filter;
+    const $fromRdfType: NamedNode<string>;
+    type $Identifier = BlankNode | NamedNode;
+    namespace $Identifier {
+        const fromString: typeof $identifierFromString;
+        const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
+    }
+    function isShaclmatePropertyShape(object: $Object): object is ShaclmatePropertyShape;
+    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, ShaclmatePropertyShape>;
+    function $propertiesFromRdf($parameters: $PropertiesFromRdfParameters): Either<Error, {
+        $identifier: BlankNode | NamedNode;
         $type: "ShaclmatePropertyShape";
-        lazy: purify.Maybe<boolean>;
-        mutable: purify.Maybe<boolean>;
-        name: purify.Maybe<string>;
-        stub: purify.Maybe<rdfjs.BlankNode | rdfjs.NamedNode>;
-        visibility: purify.Maybe<rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_Visibility_Private" | "http://purl.org/shaclmate/ontology#_Visibility_Protected" | "http://purl.org/shaclmate/ontology#_Visibility_Public">>;
-        widen: purify.Maybe<boolean>;
+        mutable: Maybe<boolean>;
+        name: Maybe<string>;
+        resolve: Maybe<BlankNode | NamedNode>;
+        visibility: Maybe<NamedNode<"http://purl.org/shaclmate/ontology#_Visibility_Private" | "http://purl.org/shaclmate/ontology#_Visibility_Protected" | "http://purl.org/shaclmate/ontology#_Visibility_Public">>;
     } & $UnwrapR<ReturnType<typeof ShaclCorePropertyShapeStatic.$propertiesFromRdf>>>;
     function $toRdf(_shaclmatePropertyShape: ShaclmatePropertyShape, options?: {
         ignoreRdfType?: boolean;
-        mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet?: rdfjsResource.MutableResourceSet;
-    }): rdfjsResource.MutableResource;
-    const $properties: {
-        lazy: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#lazy">;
-        };
-        mutable: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#mutable">;
-        };
-        name: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#name">;
-        };
-        stub: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#stub">;
-        };
-        visibility: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#visibility">;
-        };
-        widen: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#widen">;
-        };
-        defaultValue: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#defaultValue">;
-        };
-        descriptions: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#description">;
-        };
-        groups: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#group">;
-        };
-        names: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#name">;
-        };
-        order: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#order">;
-        };
-        path: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#path">;
-        };
-        uniqueLang: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#uniqueLang">;
-        };
-        and: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#and">;
-        };
-        classes: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#class">;
-        };
-        comments: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#comment">;
-        };
-        datatype: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#datatype">;
-        };
-        deactivated: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#deactivated">;
-        };
-        flags: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#flags">;
-        };
-        hasValues: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#hasValue">;
-        };
-        in_: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#in">;
-        };
-        isDefinedBy: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#isDefinedBy">;
-        };
-        labels: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
-        };
-        languageIn: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#languageIn">;
-        };
-        maxCount: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxCount">;
-        };
-        maxExclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxExclusive">;
-        };
-        maxInclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxInclusive">;
-        };
-        maxLength: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxLength">;
-        };
-        minCount: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minCount">;
-        };
-        minExclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minExclusive">;
-        };
-        minInclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minInclusive">;
-        };
-        minLength: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minLength">;
-        };
-        nodeKind: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
-        };
-        nodes: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#node">;
-        };
-        not: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#not">;
-        };
-        or: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#or">;
-        };
-        patterns: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#pattern">;
-        };
-        xone: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#xone">;
+        graph?: Exclude<Quad_Graph, Variable>;
+        resourceSet?: ResourceSet;
+    }): Resource;
+    const $schema: {
+        readonly properties: {
+            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 resolve: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Maybe";
+                    item: () => {
+                        kind: "Identifier";
+                    };
+                };
+                readonly path: NamedNode<"http://purl.org/shaclmate/ontology#resolve">;
+            };
+            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 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 groups: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "Identifier";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#group">;
+            };
+            readonly names: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "String";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#name">;
+            };
+            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 uniqueLang: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Maybe";
+                    item: () => {
+                        kind: "Boolean";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#uniqueLang">;
+            };
+            readonly $identifier: {
+                readonly kind: "Identifier";
+                readonly type: () => {
+                    kind: "Identifier";
+                };
+            };
+            readonly $type: {
+                readonly kind: "TypeDiscriminant";
+                readonly type: () => {
+                    descendantValues: string[];
+                    kind: "TypeDiscriminant";
+                };
+            };
+            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 flags: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "String";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#flags">;
+            };
+            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 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 xone: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "List";
+                        item: () => {
+                            kind: "Identifier";
+                        };
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#xone">;
+            };
         };
     };
 }
 export interface OwlOntology {
     readonly $identifier: OwlOntologyStatic.$Identifier;
     readonly $type: "OwlOntology" | "ShaclmateOntology";
-    readonly labels: readonly rdfjs.Literal[];
+    readonly labels: readonly string[];
 }
 export declare namespace OwlOntologyStatic {
-    const $fromRdfType: rdfjs.NamedNode<string>;
-    type $Identifier = rdfjs.BlankNode | rdfjs.NamedNode;
+    function $filter(filter: OwlOntologyStatic.$Filter, value: OwlOntology): boolean;
+    type $Filter = {
+        readonly $identifier?: $IdentifierFilter;
+        readonly labels?: $CollectionFilter<$StringFilter>;
+    };
+    const $fromRdfType: NamedNode<string>;
+    type $Identifier = BlankNode | NamedNode;
     namespace $Identifier {
-        function fromString(identifier: string): purify.Either<Error, rdfjsResource.Resource.Identifier>;
-        const // biome-ignore lint/suspicious/noShadowRestrictedNames:
-        toString: typeof rdfjsResource.Resource.Identifier.toString;
+        const fromString: typeof $identifierFromString;
+        const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
     }
-    function $fromRdf(resource: rdfjsResource.Resource, options?: {
-        [_index: string]: any;
-        ignoreRdfType?: boolean;
-        objectSet?: $ObjectSet;
-        preferredLanguages?: readonly string[];
-    }): purify.Either<Error, OwlOntology>;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, ...$context }: {
-        [_index: string]: any;
-        ignoreRdfType: boolean;
-        objectSet: $ObjectSet;
-        preferredLanguages?: readonly string[];
-        resource: rdfjsResource.Resource;
-    }): purify.Either<Error, {
-        $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    function isOwlOntology(object: $Object): object is OwlOntology;
+    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, OwlOntology>;
+    function $propertiesFromRdf($parameters: $PropertiesFromRdfParameters): Either<Error, {
+        $identifier: BlankNode | NamedNode;
         $type: "OwlOntology" | "ShaclmateOntology";
-        labels: readonly rdfjs.Literal[];
+        labels: readonly string[];
     }>;
     function $toRdf(_owlOntology: OwlOntology, options?: {
         ignoreRdfType?: boolean;
-        mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet?: rdfjsResource.MutableResourceSet;
-    }): rdfjsResource.MutableResource;
-    const $properties: {
-        labels: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
+        graph?: Exclude<Quad_Graph, Variable>;
+        resourceSet?: ResourceSet;
+    }): Resource;
+    const $schema: {
+        readonly properties: {
+            readonly $identifier: {
+                readonly kind: "Identifier";
+                readonly type: () => {
+                    kind: "Identifier";
+                };
+            };
+            readonly $type: {
+                readonly kind: "TypeDiscriminant";
+                readonly type: () => {
+                    descendantValues: string[];
+                    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">;
+            };
         };
     };
 }
 export interface ShaclmateOntology extends OwlOntology {
     readonly $identifier: ShaclmateOntology.$Identifier;
     readonly $type: "ShaclmateOntology";
-    readonly tsFeatureExcludes: readonly rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
-    readonly tsFeatureIncludes: readonly rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
+    readonly tsFeatureExcludes: readonly NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
+    readonly tsFeatureIncludes: readonly NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
     readonly tsImports: readonly string[];
-    readonly tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class" | "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface">>;
+    readonly tsObjectDeclarationType: Maybe<NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class" | "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface">>;
 }
 export declare namespace ShaclmateOntology {
-    const $fromRdfType: rdfjs.NamedNode<string>;
-    type $Identifier = OwlOntologyStatic.$Identifier;
-    const $Identifier: typeof OwlOntologyStatic.$Identifier;
-    function $fromRdf(resource: rdfjsResource.Resource, options?: {
-        [_index: string]: any;
-        ignoreRdfType?: boolean;
-        objectSet?: $ObjectSet;
-        preferredLanguages?: readonly string[];
-    }): purify.Either<Error, ShaclmateOntology>;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, ...$context }: {
-        [_index: string]: any;
-        ignoreRdfType: boolean;
-        objectSet: $ObjectSet;
-        preferredLanguages?: readonly string[];
-        resource: rdfjsResource.Resource;
-    }): purify.Either<Error, {
-        $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    function $filter(filter: ShaclmateOntology.$Filter, value: ShaclmateOntology): boolean;
+    type $Filter = {
+        readonly $identifier?: $IdentifierFilter;
+        readonly tsFeatureExcludes?: $CollectionFilter<$IriFilter>;
+        readonly tsFeatureIncludes?: $CollectionFilter<$IriFilter>;
+        readonly tsImports?: $CollectionFilter<$StringFilter>;
+        readonly tsObjectDeclarationType?: $MaybeFilter<$IriFilter>;
+    } & OwlOntologyStatic.$Filter;
+    const $fromRdfType: NamedNode<string>;
+    type $Identifier = BlankNode | NamedNode;
+    namespace $Identifier {
+        const fromString: typeof $identifierFromString;
+        const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
+    }
+    function isShaclmateOntology(object: $Object): object is ShaclmateOntology;
+    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, ShaclmateOntology>;
+    function $propertiesFromRdf($parameters: $PropertiesFromRdfParameters): Either<Error, {
+        $identifier: BlankNode | NamedNode;
         $type: "ShaclmateOntology";
-        tsFeatureExcludes: readonly rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
-        tsFeatureIncludes: readonly rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
+        tsFeatureExcludes: readonly NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
+        tsFeatureIncludes: readonly NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
         tsImports: readonly string[];
-        tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class" | "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface">>;
+        tsObjectDeclarationType: Maybe<NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class" | "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface">>;
     } & $UnwrapR<ReturnType<typeof OwlOntologyStatic.$propertiesFromRdf>>>;
     function $toRdf(_shaclmateOntology: ShaclmateOntology, options?: {
         ignoreRdfType?: boolean;
-        mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet?: rdfjsResource.MutableResourceSet;
-    }): rdfjsResource.MutableResource;
-    const $properties: {
-        tsFeatureExcludes: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#tsFeatureExclude">;
-        };
-        tsFeatureIncludes: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#tsFeatureInclude">;
-        };
-        tsImports: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#tsImport">;
-        };
-        tsObjectDeclarationType: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#tsObjectDeclarationType">;
-        };
-        labels: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
+        graph?: Exclude<Quad_Graph, Variable>;
+        resourceSet?: ResourceSet;
+    }): Resource;
+    const $schema: {
+        readonly properties: {
+            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 $identifier: {
+                readonly kind: "Identifier";
+                readonly type: () => {
+                    kind: "Identifier";
+                };
+            };
+            readonly $type: {
+                readonly kind: "TypeDiscriminant";
+                readonly type: () => {
+                    descendantValues: string[];
+                    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">;
+            };
         };
     };
 }
 export interface ShaclCoreNodeShape extends BaseShaclCoreShape {
     readonly $identifier: ShaclCoreNodeShapeStatic.$Identifier;
     readonly $type: "ShaclCoreNodeShape" | "ShaclmateNodeShape";
-    readonly closed: purify.Maybe<boolean>;
-    readonly ignoredProperties: purify.Maybe<readonly rdfjs.NamedNode[]>;
-    readonly properties: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
+    readonly closed: Maybe<boolean>;
+    readonly ignoredProperties: Maybe<readonly NamedNode[]>;
+    readonly properties: readonly (BlankNode | NamedNode)[];
 }
 export declare namespace ShaclCoreNodeShapeStatic {
-    const $fromRdfType: rdfjs.NamedNode<string>;
-    type $Identifier = BaseShaclCoreShapeStatic.$Identifier;
-    const $Identifier: typeof BaseShaclCoreShapeStatic.$Identifier;
-    function $fromRdf(resource: rdfjsResource.Resource, options?: {
-        [_index: string]: any;
-        ignoreRdfType?: boolean;
-        objectSet?: $ObjectSet;
-        preferredLanguages?: readonly string[];
-    }): purify.Either<Error, ShaclCoreNodeShape>;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, ...$context }: {
-        [_index: string]: any;
-        ignoreRdfType: boolean;
-        objectSet: $ObjectSet;
-        preferredLanguages?: readonly string[];
-        resource: rdfjsResource.Resource;
-    }): purify.Either<Error, {
-        $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    function $filter(filter: ShaclCoreNodeShapeStatic.$Filter, value: ShaclCoreNodeShape): boolean;
+    type $Filter = {
+        readonly $identifier?: $IdentifierFilter;
+        readonly closed?: $MaybeFilter<$BooleanFilter>;
+        readonly ignoredProperties?: $MaybeFilter<$CollectionFilter<$IriFilter>>;
+        readonly properties?: $CollectionFilter<$IdentifierFilter>;
+    } & BaseShaclCoreShapeStatic.$Filter;
+    const $fromRdfType: NamedNode<string>;
+    type $Identifier = BlankNode | NamedNode;
+    namespace $Identifier {
+        const fromString: typeof $identifierFromString;
+        const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
+    }
+    function isShaclCoreNodeShape(object: $Object): object is ShaclCoreNodeShape;
+    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, ShaclCoreNodeShape>;
+    function $propertiesFromRdf($parameters: $PropertiesFromRdfParameters): Either<Error, {
+        $identifier: BlankNode | NamedNode;
         $type: "ShaclCoreNodeShape" | "ShaclmateNodeShape";
-        closed: purify.Maybe<boolean>;
-        ignoredProperties: purify.Maybe<readonly rdfjs.NamedNode[]>;
-        properties: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
+        closed: Maybe<boolean>;
+        ignoredProperties: Maybe<readonly NamedNode[]>;
+        properties: readonly (BlankNode | NamedNode)[];
     } & $UnwrapR<ReturnType<typeof BaseShaclCoreShapeStatic.$propertiesFromRdf>>>;
     function $toRdf(_shaclCoreNodeShape: ShaclCoreNodeShape, options?: {
         ignoreRdfType?: boolean;
-        mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet?: rdfjsResource.MutableResourceSet;
-    }): rdfjsResource.MutableResource;
-    const $properties: {
-        closed: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#closed">;
-        };
-        ignoredProperties: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#ignoredProperties">;
-        };
-        properties: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#property">;
-        };
-        and: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#and">;
-        };
-        classes: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#class">;
-        };
-        comments: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#comment">;
-        };
-        datatype: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#datatype">;
-        };
-        deactivated: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#deactivated">;
-        };
-        flags: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#flags">;
-        };
-        hasValues: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#hasValue">;
-        };
-        in_: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#in">;
-        };
-        isDefinedBy: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#isDefinedBy">;
-        };
-        labels: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
-        };
-        languageIn: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#languageIn">;
-        };
-        maxCount: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxCount">;
-        };
-        maxExclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxExclusive">;
-        };
-        maxInclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxInclusive">;
-        };
-        maxLength: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxLength">;
-        };
-        minCount: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minCount">;
-        };
-        minExclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minExclusive">;
-        };
-        minInclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minInclusive">;
-        };
-        minLength: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minLength">;
-        };
-        nodeKind: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
-        };
-        nodes: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#node">;
-        };
-        not: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#not">;
-        };
-        or: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#or">;
-        };
-        patterns: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#pattern">;
-        };
-        xone: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#xone">;
+        graph?: Exclude<Quad_Graph, Variable>;
+        resourceSet?: ResourceSet;
+    }): Resource;
+    const $schema: {
+        readonly properties: {
+            readonly closed: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Maybe";
+                    item: () => {
+                        kind: "Boolean";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#closed">;
+            };
+            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 properties: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "Identifier";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#property">;
+            };
+            readonly $identifier: {
+                readonly kind: "Identifier";
+                readonly type: () => {
+                    kind: "Identifier";
+                };
+            };
+            readonly $type: {
+                readonly kind: "TypeDiscriminant";
+                readonly type: () => {
+                    descendantValues: string[];
+                    kind: "TypeDiscriminant";
+                };
+            };
+            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 flags: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "String";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#flags">;
+            };
+            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 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 xone: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "List";
+                        item: () => {
+                            kind: "Identifier";
+                        };
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#xone">;
+            };
         };
     };
 }
 export interface ShaclmateNodeShape extends ShaclCoreNodeShape {
     readonly $identifier: ShaclmateNodeShape.$Identifier;
     readonly $type: "ShaclmateNodeShape";
-    readonly abstract: purify.Maybe<boolean>;
-    readonly export_: purify.Maybe<boolean>;
-    readonly extern: purify.Maybe<boolean>;
-    readonly fromRdfType: purify.Maybe<rdfjs.NamedNode>;
-    readonly identifierMintingStrategy: purify.Maybe<rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode" | "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_SHA256" | "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_UUIDv4">>;
-    readonly mutable: purify.Maybe<boolean>;
-    readonly name: purify.Maybe<string>;
-    readonly rdfType: purify.Maybe<rdfjs.NamedNode>;
-    readonly toRdfTypes: readonly rdfjs.NamedNode[];
-    readonly tsFeatureExcludes: readonly rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
-    readonly tsFeatureIncludes: readonly rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
+    readonly abstract: Maybe<boolean>;
+    readonly discriminantValue: Maybe<string>;
+    readonly export_: Maybe<boolean>;
+    readonly extern: Maybe<boolean>;
+    readonly fromRdfType: Maybe<NamedNode>;
+    readonly identifierMintingStrategy: Maybe<NamedNode<"http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode" | "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_SHA256" | "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_UUIDv4">>;
+    readonly mutable: Maybe<boolean>;
+    readonly name: Maybe<string>;
+    readonly rdfType: Maybe<NamedNode>;
+    readonly toRdfTypes: readonly NamedNode[];
+    readonly tsFeatureExcludes: readonly NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
+    readonly tsFeatureIncludes: readonly NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
     readonly tsImports: readonly string[];
-    readonly tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class" | "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface">>;
+    readonly tsObjectDeclarationType: Maybe<NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class" | "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface">>;
 }
 export declare namespace ShaclmateNodeShape {
-    const $fromRdfType: rdfjs.NamedNode<string>;
-    type $Identifier = ShaclCoreNodeShapeStatic.$Identifier;
-    const $Identifier: typeof BaseShaclCoreShapeStatic.$Identifier;
-    function $fromRdf(resource: rdfjsResource.Resource, options?: {
-        [_index: string]: any;
-        ignoreRdfType?: boolean;
-        objectSet?: $ObjectSet;
-        preferredLanguages?: readonly string[];
-    }): purify.Either<Error, ShaclmateNodeShape>;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, ...$context }: {
-        [_index: string]: any;
-        ignoreRdfType: boolean;
-        objectSet: $ObjectSet;
-        preferredLanguages?: readonly string[];
-        resource: rdfjsResource.Resource;
-    }): purify.Either<Error, {
-        $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    function $filter(filter: ShaclmateNodeShape.$Filter, value: ShaclmateNodeShape): boolean;
+    type $Filter = {
+        readonly $identifier?: $IdentifierFilter;
+        readonly abstract?: $MaybeFilter<$BooleanFilter>;
+        readonly discriminantValue?: $MaybeFilter<$StringFilter>;
+        readonly export_?: $MaybeFilter<$BooleanFilter>;
+        readonly extern?: $MaybeFilter<$BooleanFilter>;
+        readonly fromRdfType?: $MaybeFilter<$IriFilter>;
+        readonly identifierMintingStrategy?: $MaybeFilter<$IriFilter>;
+        readonly mutable?: $MaybeFilter<$BooleanFilter>;
+        readonly name?: $MaybeFilter<$StringFilter>;
+        readonly rdfType?: $MaybeFilter<$IriFilter>;
+        readonly toRdfTypes?: $CollectionFilter<$IriFilter>;
+        readonly tsFeatureExcludes?: $CollectionFilter<$IriFilter>;
+        readonly tsFeatureIncludes?: $CollectionFilter<$IriFilter>;
+        readonly tsImports?: $CollectionFilter<$StringFilter>;
+        readonly tsObjectDeclarationType?: $MaybeFilter<$IriFilter>;
+    } & ShaclCoreNodeShapeStatic.$Filter;
+    const $fromRdfType: NamedNode<string>;
+    type $Identifier = BlankNode | NamedNode;
+    namespace $Identifier {
+        const fromString: typeof $identifierFromString;
+        const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
+    }
+    function isShaclmateNodeShape(object: $Object): object is ShaclmateNodeShape;
+    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, ShaclmateNodeShape>;
+    function $propertiesFromRdf($parameters: $PropertiesFromRdfParameters): Either<Error, {
+        $identifier: BlankNode | NamedNode;
         $type: "ShaclmateNodeShape";
-        abstract: purify.Maybe<boolean>;
-        export_: purify.Maybe<boolean>;
-        extern: purify.Maybe<boolean>;
-        fromRdfType: purify.Maybe<rdfjs.NamedNode>;
-        identifierMintingStrategy: purify.Maybe<rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode" | "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_SHA256" | "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_UUIDv4">>;
-        mutable: purify.Maybe<boolean>;
-        name: purify.Maybe<string>;
-        rdfType: purify.Maybe<rdfjs.NamedNode>;
-        toRdfTypes: readonly rdfjs.NamedNode[];
-        tsFeatureExcludes: readonly rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
-        tsFeatureIncludes: readonly rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
+        abstract: Maybe<boolean>;
+        discriminantValue: Maybe<string>;
+        export_: Maybe<boolean>;
+        extern: Maybe<boolean>;
+        fromRdfType: Maybe<NamedNode>;
+        identifierMintingStrategy: Maybe<NamedNode<"http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode" | "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_SHA256" | "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_UUIDv4">>;
+        mutable: Maybe<boolean>;
+        name: Maybe<string>;
+        rdfType: Maybe<NamedNode>;
+        toRdfTypes: readonly NamedNode[];
+        tsFeatureExcludes: readonly NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
+        tsFeatureIncludes: readonly NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
         tsImports: readonly string[];
-        tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class" | "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface">>;
+        tsObjectDeclarationType: Maybe<NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class" | "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface">>;
     } & $UnwrapR<ReturnType<typeof ShaclCoreNodeShapeStatic.$propertiesFromRdf>>>;
     function $toRdf(_shaclmateNodeShape: ShaclmateNodeShape, options?: {
         ignoreRdfType?: boolean;
-        mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet?: rdfjsResource.MutableResourceSet;
-    }): rdfjsResource.MutableResource;
-    const $properties: {
-        abstract: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#abstract">;
-        };
-        export_: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#export">;
-        };
-        extern: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#extern">;
-        };
-        fromRdfType: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#fromRdfType">;
-        };
-        identifierMintingStrategy: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#identifierMintingStrategy">;
-        };
-        mutable: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#mutable">;
-        };
-        name: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#name">;
-        };
-        rdfType: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#rdfType">;
-        };
-        toRdfTypes: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#toRdfType">;
-        };
-        tsFeatureExcludes: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#tsFeatureExclude">;
-        };
-        tsFeatureIncludes: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#tsFeatureInclude">;
-        };
-        tsImports: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#tsImport">;
-        };
-        tsObjectDeclarationType: {
-            identifier: import("n3").NamedNode<"http://purl.org/shaclmate/ontology#tsObjectDeclarationType">;
-        };
-        closed: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#closed">;
-        };
-        ignoredProperties: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#ignoredProperties">;
-        };
-        properties: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#property">;
-        };
-        and: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#and">;
-        };
-        classes: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#class">;
-        };
-        comments: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#comment">;
-        };
-        datatype: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#datatype">;
-        };
-        deactivated: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#deactivated">;
-        };
-        flags: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#flags">;
-        };
-        hasValues: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#hasValue">;
-        };
-        in_: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#in">;
-        };
-        isDefinedBy: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#isDefinedBy">;
-        };
-        labels: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
-        };
-        languageIn: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#languageIn">;
-        };
-        maxCount: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxCount">;
-        };
-        maxExclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxExclusive">;
-        };
-        maxInclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxInclusive">;
-        };
-        maxLength: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#maxLength">;
-        };
-        minCount: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minCount">;
-        };
-        minExclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minExclusive">;
-        };
-        minInclusive: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minInclusive">;
-        };
-        minLength: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#minLength">;
-        };
-        nodeKind: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
-        };
-        nodes: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#node">;
-        };
-        not: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#not">;
-        };
-        or: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#or">;
-        };
-        patterns: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#pattern">;
-        };
-        xone: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/ns/shacl#xone">;
+        graph?: Exclude<Quad_Graph, Variable>;
+        resourceSet?: ResourceSet;
+    }): Resource;
+    const $schema: {
+        readonly properties: {
+            readonly abstract: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Maybe";
+                    item: () => {
+                        kind: "Boolean";
+                    };
+                };
+                readonly path: NamedNode<"http://purl.org/shaclmate/ontology#abstract">;
+            };
+            readonly discriminantValue: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Maybe";
+                    item: () => {
+                        kind: "String";
+                    };
+                };
+                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: () => {
+                    kind: "Maybe";
+                    item: () => {
+                        kind: "Boolean";
+                    };
+                };
+                readonly path: NamedNode<"http://purl.org/shaclmate/ontology#extern">;
+            };
+            readonly fromRdfType: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Maybe";
+                    item: () => {
+                        kind: "Iri";
+                    };
+                };
+                readonly path: NamedNode<"http://purl.org/shaclmate/ontology#fromRdfType">;
+            };
+            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 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 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 closed: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Maybe";
+                    item: () => {
+                        kind: "Boolean";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#closed">;
+            };
+            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 properties: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "Identifier";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#property">;
+            };
+            readonly $identifier: {
+                readonly kind: "Identifier";
+                readonly type: () => {
+                    kind: "Identifier";
+                };
+            };
+            readonly $type: {
+                readonly kind: "TypeDiscriminant";
+                readonly type: () => {
+                    descendantValues: string[];
+                    kind: "TypeDiscriminant";
+                };
+            };
+            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 flags: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "String";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#flags">;
+            };
+            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 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 xone: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "List";
+                        item: () => {
+                            kind: "Identifier";
+                        };
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#xone">;
+            };
         };
     };
 }
 export interface ShaclCorePropertyGroup {
     readonly $identifier: ShaclCorePropertyGroup.$Identifier;
     readonly $type: "ShaclCorePropertyGroup";
-    readonly comments: readonly rdfjs.Literal[];
-    readonly labels: readonly rdfjs.Literal[];
+    readonly comments: readonly string[];
+    readonly labels: readonly string[];
 }
 export declare namespace ShaclCorePropertyGroup {
-    const $fromRdfType: rdfjs.NamedNode<string>;
-    type $Identifier = rdfjs.BlankNode | rdfjs.NamedNode;
+    function $filter(filter: ShaclCorePropertyGroup.$Filter, value: ShaclCorePropertyGroup): boolean;
+    type $Filter = {
+        readonly $identifier?: $IdentifierFilter;
+        readonly comments?: $CollectionFilter<$StringFilter>;
+        readonly labels?: $CollectionFilter<$StringFilter>;
+    };
+    const $fromRdfType: NamedNode<string>;
+    type $Identifier = BlankNode | NamedNode;
     namespace $Identifier {
-        function fromString(identifier: string): purify.Either<Error, rdfjsResource.Resource.Identifier>;
-        const // biome-ignore lint/suspicious/noShadowRestrictedNames:
-        toString: typeof rdfjsResource.Resource.Identifier.toString;
+        const fromString: typeof $identifierFromString;
+        const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
     }
-    function $fromRdf(resource: rdfjsResource.Resource, options?: {
-        [_index: string]: any;
-        ignoreRdfType?: boolean;
-        objectSet?: $ObjectSet;
-        preferredLanguages?: readonly string[];
-    }): purify.Either<Error, ShaclCorePropertyGroup>;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, ...$context }: {
-        [_index: string]: any;
-        ignoreRdfType: boolean;
-        objectSet: $ObjectSet;
-        preferredLanguages?: readonly string[];
-        resource: rdfjsResource.Resource;
-    }): purify.Either<Error, {
-        $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    function isShaclCorePropertyGroup(object: $Object): object is ShaclCorePropertyGroup;
+    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, ShaclCorePropertyGroup>;
+    function $propertiesFromRdf($parameters: $PropertiesFromRdfParameters): Either<Error, {
+        $identifier: BlankNode | NamedNode;
         $type: "ShaclCorePropertyGroup";
-        comments: readonly rdfjs.Literal[];
-        labels: readonly rdfjs.Literal[];
+        comments: readonly string[];
+        labels: readonly string[];
     }>;
     function $toRdf(_shaclCorePropertyGroup: ShaclCorePropertyGroup, options?: {
         ignoreRdfType?: boolean;
-        mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet?: rdfjsResource.MutableResourceSet;
-    }): rdfjsResource.MutableResource;
-    const $properties: {
-        comments: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#comment">;
-        };
-        labels: {
-            identifier: import("n3").NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
+        graph?: Exclude<Quad_Graph, Variable>;
+        resourceSet?: ResourceSet;
+    }): Resource;
+    const $schema: {
+        readonly properties: {
+            readonly $identifier: {
+                readonly kind: "Identifier";
+                readonly type: () => {
+                    kind: "Identifier";
+                };
+            };
+            readonly $type: {
+                readonly kind: "TypeDiscriminant";
+                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">;
+            };
         };
     };
 }
 export type ShaclCoreShape = ShaclCoreNodeShape | ShaclCorePropertyShape;
 export declare namespace ShaclCoreShape {
-    function $fromRdf(resource: rdfjsResource.Resource, options?: {
-        [_index: string]: any;
-        ignoreRdfType?: boolean;
-        objectSet?: $ObjectSet;
-        preferredLanguages?: readonly string[];
-    }): purify.Either<Error, ShaclCoreShape>;
-    type $Identifier = rdfjs.BlankNode | rdfjs.NamedNode;
+    function $filter(filter: ShaclCoreShape.$Filter, value: ShaclCoreShape): boolean;
+    interface $Filter {
+        readonly $identifier?: $IdentifierFilter;
+        readonly on?: {
+            readonly ShaclCoreNodeShape?: Omit<ShaclCoreNodeShapeStatic.$Filter, "$identifier">;
+            readonly ShaclCorePropertyShape?: Omit<ShaclCorePropertyShapeStatic.$Filter, "$identifier">;
+        };
+    }
+    type $Identifier = BlankNode | NamedNode;
     namespace $Identifier {
-        function fromString(identifier: string): purify.Either<Error, rdfjsResource.Resource.Identifier>;
-        const // biome-ignore lint/suspicious/noShadowRestrictedNames:
-        toString: typeof rdfjsResource.Resource.Identifier.toString;
+        const fromString: typeof $identifierFromString;
+        const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
     }
+    function isShaclCoreShape(object: $Object): object is ShaclCoreShape;
+    const $schema: {
+        readonly properties: {
+            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 flags: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "String";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#flags">;
+            };
+            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 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 xone: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "List";
+                        item: () => {
+                            kind: "Identifier";
+                        };
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#xone">;
+            };
+        };
+    };
+    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, ShaclCoreShape>;
     function $toRdf(_shaclCoreShape: ShaclCoreShape, _parameters?: {
-        mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet?: rdfjsResource.MutableResourceSet;
-    }): rdfjsResource.MutableResource;
+        graph?: Exclude<Quad_Graph, Variable>;
+        resourceSet?: ResourceSet;
+    }): Resource;
 }
 export type ShaclmateShape = ShaclmateNodeShape | ShaclCorePropertyShape;
 export declare namespace ShaclmateShape {
-    function $fromRdf(resource: rdfjsResource.Resource, options?: {
-        [_index: string]: any;
-        ignoreRdfType?: boolean;
-        objectSet?: $ObjectSet;
-        preferredLanguages?: readonly string[];
-    }): purify.Either<Error, ShaclmateShape>;
-    type $Identifier = rdfjs.BlankNode | rdfjs.NamedNode;
+    function $filter(filter: ShaclmateShape.$Filter, value: ShaclmateShape): boolean;
+    interface $Filter {
+        readonly $identifier?: $IdentifierFilter;
+        readonly on?: {
+            readonly ShaclmateNodeShape?: Omit<ShaclmateNodeShape.$Filter, "$identifier">;
+            readonly ShaclCorePropertyShape?: Omit<ShaclCorePropertyShapeStatic.$Filter, "$identifier">;
+        };
+    }
+    type $Identifier = BlankNode | NamedNode;
     namespace $Identifier {
-        function fromString(identifier: string): purify.Either<Error, rdfjsResource.Resource.Identifier>;
-        const // biome-ignore lint/suspicious/noShadowRestrictedNames:
-        toString: typeof rdfjsResource.Resource.Identifier.toString;
+        const fromString: typeof $identifierFromString;
+        const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
     }
+    function isShaclmateShape(object: $Object): object is ShaclmateShape;
+    const $schema: {
+        readonly properties: {
+            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 flags: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "String";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#flags">;
+            };
+            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 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 xone: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "List";
+                        item: () => {
+                            kind: "Identifier";
+                        };
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#xone">;
+            };
+        };
+    };
+    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, ShaclmateShape>;
     function $toRdf(_shaclmateShape: ShaclmateShape, _parameters?: {
-        mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet?: rdfjsResource.MutableResourceSet;
-    }): rdfjsResource.MutableResource;
+        graph?: Exclude<Quad_Graph, Variable>;
+        resourceSet?: ResourceSet;
+    }): Resource;
+}
+export type $Object = ShaclCorePropertyGroup | ShaclmateNodeShape | ShaclCoreNodeShape | ShaclmateOntology | OwlOntology | ShaclmatePropertyShape | ShaclCorePropertyShape | BaseShaclCoreShape;
+export declare namespace $Object {
+    function $filter(filter: $Object.$Filter, value: $Object): boolean;
+    interface $Filter {
+        readonly $identifier?: $IdentifierFilter;
+        readonly on?: {
+            readonly ShaclCorePropertyGroup?: Omit<ShaclCorePropertyGroup.$Filter, "$identifier">;
+            readonly ShaclmateNodeShape?: Omit<ShaclmateNodeShape.$Filter, "$identifier">;
+            readonly ShaclCoreNodeShape?: Omit<ShaclCoreNodeShapeStatic.$Filter, "$identifier">;
+            readonly ShaclmateOntology?: Omit<ShaclmateOntology.$Filter, "$identifier">;
+            readonly OwlOntology?: Omit<OwlOntologyStatic.$Filter, "$identifier">;
+            readonly ShaclmatePropertyShape?: Omit<ShaclmatePropertyShape.$Filter, "$identifier">;
+            readonly ShaclCorePropertyShape?: Omit<ShaclCorePropertyShapeStatic.$Filter, "$identifier">;
+            readonly BaseShaclCoreShape?: Omit<BaseShaclCoreShapeStatic.$Filter, "$identifier">;
+        };
+    }
+    type $Identifier = BlankNode | NamedNode;
+    namespace $Identifier {
+        const fromString: typeof $identifierFromString;
+        const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
+    }
+    const $schema: {
+        readonly properties: {
+            readonly labels: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "String";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
+            };
+        };
+    };
+    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, $Object>;
+    function $toRdf(_object: $Object, _parameters?: {
+        graph?: Exclude<Quad_Graph, Variable>;
+        resourceSet?: ResourceSet;
+    }): Resource;
 }
 export interface $ObjectSet {
-    owlOntology(identifier: OwlOntologyStatic.$Identifier): Promise<purify.Either<Error, OwlOntology>>;
-    owlOntologyIdentifiers(query?: $ObjectSet.Query<OwlOntologyStatic.$Identifier>): Promise<purify.Either<Error, readonly OwlOntologyStatic.$Identifier[]>>;
-    owlOntologies(query?: $ObjectSet.Query<OwlOntologyStatic.$Identifier>): Promise<purify.Either<Error, readonly OwlOntology[]>>;
-    owlOntologiesCount(query?: Pick<$ObjectSet.Query<OwlOntologyStatic.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclCoreNodeShape(identifier: ShaclCoreNodeShapeStatic.$Identifier): Promise<purify.Either<Error, ShaclCoreNodeShape>>;
-    shaclCoreNodeShapeIdentifiers(query?: $ObjectSet.Query<ShaclCoreNodeShapeStatic.$Identifier>): Promise<purify.Either<Error, readonly ShaclCoreNodeShapeStatic.$Identifier[]>>;
-    shaclCoreNodeShapes(query?: $ObjectSet.Query<ShaclCoreNodeShapeStatic.$Identifier>): Promise<purify.Either<Error, readonly ShaclCoreNodeShape[]>>;
-    shaclCoreNodeShapesCount(query?: Pick<$ObjectSet.Query<ShaclCoreNodeShapeStatic.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclCorePropertyGroup(identifier: ShaclCorePropertyGroup.$Identifier): Promise<purify.Either<Error, ShaclCorePropertyGroup>>;
-    shaclCorePropertyGroupIdentifiers(query?: $ObjectSet.Query<ShaclCorePropertyGroup.$Identifier>): Promise<purify.Either<Error, readonly ShaclCorePropertyGroup.$Identifier[]>>;
-    shaclCorePropertyGroups(query?: $ObjectSet.Query<ShaclCorePropertyGroup.$Identifier>): Promise<purify.Either<Error, readonly ShaclCorePropertyGroup[]>>;
-    shaclCorePropertyGroupsCount(query?: Pick<$ObjectSet.Query<ShaclCorePropertyGroup.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclCorePropertyShape(identifier: ShaclCorePropertyShapeStatic.$Identifier): Promise<purify.Either<Error, ShaclCorePropertyShape>>;
-    shaclCorePropertyShapeIdentifiers(query?: $ObjectSet.Query<ShaclCorePropertyShapeStatic.$Identifier>): Promise<purify.Either<Error, readonly ShaclCorePropertyShapeStatic.$Identifier[]>>;
-    shaclCorePropertyShapes(query?: $ObjectSet.Query<ShaclCorePropertyShapeStatic.$Identifier>): Promise<purify.Either<Error, readonly ShaclCorePropertyShape[]>>;
-    shaclCorePropertyShapesCount(query?: Pick<$ObjectSet.Query<ShaclCorePropertyShapeStatic.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclmateNodeShape(identifier: ShaclmateNodeShape.$Identifier): Promise<purify.Either<Error, ShaclmateNodeShape>>;
-    shaclmateNodeShapeIdentifiers(query?: $ObjectSet.Query<ShaclmateNodeShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateNodeShape.$Identifier[]>>;
-    shaclmateNodeShapes(query?: $ObjectSet.Query<ShaclmateNodeShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateNodeShape[]>>;
-    shaclmateNodeShapesCount(query?: Pick<$ObjectSet.Query<ShaclmateNodeShape.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclmateOntology(identifier: ShaclmateOntology.$Identifier): Promise<purify.Either<Error, ShaclmateOntology>>;
-    shaclmateOntologyIdentifiers(query?: $ObjectSet.Query<ShaclmateOntology.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateOntology.$Identifier[]>>;
-    shaclmateOntologies(query?: $ObjectSet.Query<ShaclmateOntology.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateOntology[]>>;
-    shaclmateOntologiesCount(query?: Pick<$ObjectSet.Query<ShaclmateOntology.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclmatePropertyShape(identifier: ShaclmatePropertyShape.$Identifier): Promise<purify.Either<Error, ShaclmatePropertyShape>>;
-    shaclmatePropertyShapeIdentifiers(query?: $ObjectSet.Query<ShaclmatePropertyShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmatePropertyShape.$Identifier[]>>;
-    shaclmatePropertyShapes(query?: $ObjectSet.Query<ShaclmatePropertyShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmatePropertyShape[]>>;
-    shaclmatePropertyShapesCount(query?: Pick<$ObjectSet.Query<ShaclmatePropertyShape.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclCoreShape(identifier: ShaclCoreShape.$Identifier): Promise<purify.Either<Error, ShaclCoreShape>>;
-    shaclCoreShapeIdentifiers(query?: $ObjectSet.Query<ShaclCoreShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclCoreShape.$Identifier[]>>;
-    shaclCoreShapes(query?: $ObjectSet.Query<ShaclCoreShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclCoreShape[]>>;
-    shaclCoreShapesCount(query?: Pick<$ObjectSet.Query<ShaclCoreShape.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclmateShape(identifier: ShaclmateShape.$Identifier): Promise<purify.Either<Error, ShaclmateShape>>;
-    shaclmateShapeIdentifiers(query?: $ObjectSet.Query<ShaclmateShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateShape.$Identifier[]>>;
-    shaclmateShapes(query?: $ObjectSet.Query<ShaclmateShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateShape[]>>;
-    shaclmateShapesCount(query?: Pick<$ObjectSet.Query<ShaclmateShape.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
+    owlOntology(identifier: OwlOntologyStatic.$Identifier): Promise<Either<Error, OwlOntology>>;
+    owlOntologyCount(query?: Pick<$ObjectSet.Query<OwlOntologyStatic.$Filter, OwlOntologyStatic.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    owlOntologyIdentifiers(query?: $ObjectSet.Query<OwlOntologyStatic.$Filter, OwlOntologyStatic.$Identifier>): Promise<Either<Error, readonly OwlOntologyStatic.$Identifier[]>>;
+    owlOntologies(query?: $ObjectSet.Query<OwlOntologyStatic.$Filter, OwlOntologyStatic.$Identifier>): Promise<Either<Error, readonly OwlOntology[]>>;
+    shaclCoreNodeShape(identifier: ShaclCoreNodeShapeStatic.$Identifier): Promise<Either<Error, ShaclCoreNodeShape>>;
+    shaclCoreNodeShapeCount(query?: Pick<$ObjectSet.Query<ShaclCoreNodeShapeStatic.$Filter, ShaclCoreNodeShapeStatic.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shaclCoreNodeShapeIdentifiers(query?: $ObjectSet.Query<ShaclCoreNodeShapeStatic.$Filter, ShaclCoreNodeShapeStatic.$Identifier>): Promise<Either<Error, readonly ShaclCoreNodeShapeStatic.$Identifier[]>>;
+    shaclCoreNodeShapes(query?: $ObjectSet.Query<ShaclCoreNodeShapeStatic.$Filter, ShaclCoreNodeShapeStatic.$Identifier>): Promise<Either<Error, readonly ShaclCoreNodeShape[]>>;
+    shaclCorePropertyGroup(identifier: ShaclCorePropertyGroup.$Identifier): Promise<Either<Error, ShaclCorePropertyGroup>>;
+    shaclCorePropertyGroupCount(query?: Pick<$ObjectSet.Query<ShaclCorePropertyGroup.$Filter, ShaclCorePropertyGroup.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shaclCorePropertyGroupIdentifiers(query?: $ObjectSet.Query<ShaclCorePropertyGroup.$Filter, ShaclCorePropertyGroup.$Identifier>): Promise<Either<Error, readonly ShaclCorePropertyGroup.$Identifier[]>>;
+    shaclCorePropertyGroups(query?: $ObjectSet.Query<ShaclCorePropertyGroup.$Filter, ShaclCorePropertyGroup.$Identifier>): Promise<Either<Error, readonly ShaclCorePropertyGroup[]>>;
+    shaclCorePropertyShape(identifier: ShaclCorePropertyShapeStatic.$Identifier): Promise<Either<Error, ShaclCorePropertyShape>>;
+    shaclCorePropertyShapeCount(query?: Pick<$ObjectSet.Query<ShaclCorePropertyShapeStatic.$Filter, ShaclCorePropertyShapeStatic.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shaclCorePropertyShapeIdentifiers(query?: $ObjectSet.Query<ShaclCorePropertyShapeStatic.$Filter, ShaclCorePropertyShapeStatic.$Identifier>): Promise<Either<Error, readonly ShaclCorePropertyShapeStatic.$Identifier[]>>;
+    shaclCorePropertyShapes(query?: $ObjectSet.Query<ShaclCorePropertyShapeStatic.$Filter, ShaclCorePropertyShapeStatic.$Identifier>): Promise<Either<Error, readonly ShaclCorePropertyShape[]>>;
+    shaclmateNodeShape(identifier: ShaclmateNodeShape.$Identifier): Promise<Either<Error, ShaclmateNodeShape>>;
+    shaclmateNodeShapeCount(query?: Pick<$ObjectSet.Query<ShaclmateNodeShape.$Filter, ShaclmateNodeShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shaclmateNodeShapeIdentifiers(query?: $ObjectSet.Query<ShaclmateNodeShape.$Filter, ShaclmateNodeShape.$Identifier>): Promise<Either<Error, readonly ShaclmateNodeShape.$Identifier[]>>;
+    shaclmateNodeShapes(query?: $ObjectSet.Query<ShaclmateNodeShape.$Filter, ShaclmateNodeShape.$Identifier>): Promise<Either<Error, readonly ShaclmateNodeShape[]>>;
+    shaclmateOntology(identifier: ShaclmateOntology.$Identifier): Promise<Either<Error, ShaclmateOntology>>;
+    shaclmateOntologyCount(query?: Pick<$ObjectSet.Query<ShaclmateOntology.$Filter, ShaclmateOntology.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shaclmateOntologyIdentifiers(query?: $ObjectSet.Query<ShaclmateOntology.$Filter, ShaclmateOntology.$Identifier>): Promise<Either<Error, readonly ShaclmateOntology.$Identifier[]>>;
+    shaclmateOntologies(query?: $ObjectSet.Query<ShaclmateOntology.$Filter, ShaclmateOntology.$Identifier>): Promise<Either<Error, readonly ShaclmateOntology[]>>;
+    shaclmatePropertyShape(identifier: ShaclmatePropertyShape.$Identifier): Promise<Either<Error, ShaclmatePropertyShape>>;
+    shaclmatePropertyShapeCount(query?: Pick<$ObjectSet.Query<ShaclmatePropertyShape.$Filter, ShaclmatePropertyShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shaclmatePropertyShapeIdentifiers(query?: $ObjectSet.Query<ShaclmatePropertyShape.$Filter, ShaclmatePropertyShape.$Identifier>): Promise<Either<Error, readonly ShaclmatePropertyShape.$Identifier[]>>;
+    shaclmatePropertyShapes(query?: $ObjectSet.Query<ShaclmatePropertyShape.$Filter, ShaclmatePropertyShape.$Identifier>): Promise<Either<Error, readonly ShaclmatePropertyShape[]>>;
+    shaclCoreShape(identifier: ShaclCoreShape.$Identifier): Promise<Either<Error, ShaclCoreShape>>;
+    shaclCoreShapeCount(query?: Pick<$ObjectSet.Query<ShaclCoreShape.$Filter, ShaclCoreShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shaclCoreShapeIdentifiers(query?: $ObjectSet.Query<ShaclCoreShape.$Filter, ShaclCoreShape.$Identifier>): Promise<Either<Error, readonly ShaclCoreShape.$Identifier[]>>;
+    shaclCoreShapes(query?: $ObjectSet.Query<ShaclCoreShape.$Filter, ShaclCoreShape.$Identifier>): Promise<Either<Error, readonly ShaclCoreShape[]>>;
+    shaclmateShape(identifier: ShaclmateShape.$Identifier): Promise<Either<Error, ShaclmateShape>>;
+    shaclmateShapeCount(query?: Pick<$ObjectSet.Query<ShaclmateShape.$Filter, ShaclmateShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shaclmateShapeIdentifiers(query?: $ObjectSet.Query<ShaclmateShape.$Filter, ShaclmateShape.$Identifier>): Promise<Either<Error, readonly ShaclmateShape.$Identifier[]>>;
+    shaclmateShapes(query?: $ObjectSet.Query<ShaclmateShape.$Filter, ShaclmateShape.$Identifier>): Promise<Either<Error, readonly ShaclmateShape[]>>;
+    object(identifier: $Object.$Identifier): Promise<Either<Error, $Object>>;
+    objectCount(query?: Pick<$ObjectSet.Query<$Object.$Filter, $Object.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    objectIdentifiers(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Promise<Either<Error, readonly $Object.$Identifier[]>>;
+    objects(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Promise<Either<Error, readonly $Object[]>>;
 }
 export declare namespace $ObjectSet {
-    type Query<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode> = {
+    interface Query<ObjectFilterT, ObjectIdentifierT extends BlankNode | NamedNode> {
+        readonly filter?: ObjectFilterT;
+        readonly graph?: Exclude<Quad_Graph, Variable>;
+        readonly identifiers?: readonly ObjectIdentifierT[];
         readonly limit?: number;
         readonly offset?: number;
-        readonly where?: Where<ObjectIdentifierT>;
-    };
-    type Where<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode> = {
-        readonly identifiers: readonly ObjectIdentifierT[];
-        readonly type: "identifiers";
-    } | {
-        readonly predicate: rdfjs.NamedNode;
-        readonly subject: rdfjs.BlankNode | rdfjs.NamedNode;
-        readonly type: "triple-objects";
-    };
-}
-export declare abstract class $ForwardingObjectSet implements $ObjectSet {
-    protected abstract get $delegate(): $ObjectSet;
-    owlOntology(identifier: OwlOntologyStatic.$Identifier): Promise<purify.Either<Error, OwlOntology>>;
-    owlOntologyIdentifiers(query?: $ObjectSet.Query<OwlOntologyStatic.$Identifier>): Promise<purify.Either<Error, readonly OwlOntologyStatic.$Identifier[]>>;
-    owlOntologies(query?: $ObjectSet.Query<OwlOntologyStatic.$Identifier>): Promise<purify.Either<Error, readonly OwlOntology[]>>;
-    owlOntologiesCount(query?: Pick<$ObjectSet.Query<OwlOntologyStatic.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclCoreNodeShape(identifier: ShaclCoreNodeShapeStatic.$Identifier): Promise<purify.Either<Error, ShaclCoreNodeShape>>;
-    shaclCoreNodeShapeIdentifiers(query?: $ObjectSet.Query<ShaclCoreNodeShapeStatic.$Identifier>): Promise<purify.Either<Error, readonly ShaclCoreNodeShapeStatic.$Identifier[]>>;
-    shaclCoreNodeShapes(query?: $ObjectSet.Query<ShaclCoreNodeShapeStatic.$Identifier>): Promise<purify.Either<Error, readonly ShaclCoreNodeShape[]>>;
-    shaclCoreNodeShapesCount(query?: Pick<$ObjectSet.Query<ShaclCoreNodeShapeStatic.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclCorePropertyGroup(identifier: ShaclCorePropertyGroup.$Identifier): Promise<purify.Either<Error, ShaclCorePropertyGroup>>;
-    shaclCorePropertyGroupIdentifiers(query?: $ObjectSet.Query<ShaclCorePropertyGroup.$Identifier>): Promise<purify.Either<Error, readonly ShaclCorePropertyGroup.$Identifier[]>>;
-    shaclCorePropertyGroups(query?: $ObjectSet.Query<ShaclCorePropertyGroup.$Identifier>): Promise<purify.Either<Error, readonly ShaclCorePropertyGroup[]>>;
-    shaclCorePropertyGroupsCount(query?: Pick<$ObjectSet.Query<ShaclCorePropertyGroup.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclCorePropertyShape(identifier: ShaclCorePropertyShapeStatic.$Identifier): Promise<purify.Either<Error, ShaclCorePropertyShape>>;
-    shaclCorePropertyShapeIdentifiers(query?: $ObjectSet.Query<ShaclCorePropertyShapeStatic.$Identifier>): Promise<purify.Either<Error, readonly ShaclCorePropertyShapeStatic.$Identifier[]>>;
-    shaclCorePropertyShapes(query?: $ObjectSet.Query<ShaclCorePropertyShapeStatic.$Identifier>): Promise<purify.Either<Error, readonly ShaclCorePropertyShape[]>>;
-    shaclCorePropertyShapesCount(query?: Pick<$ObjectSet.Query<ShaclCorePropertyShapeStatic.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclmateNodeShape(identifier: ShaclmateNodeShape.$Identifier): Promise<purify.Either<Error, ShaclmateNodeShape>>;
-    shaclmateNodeShapeIdentifiers(query?: $ObjectSet.Query<ShaclmateNodeShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateNodeShape.$Identifier[]>>;
-    shaclmateNodeShapes(query?: $ObjectSet.Query<ShaclmateNodeShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateNodeShape[]>>;
-    shaclmateNodeShapesCount(query?: Pick<$ObjectSet.Query<ShaclmateNodeShape.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclmateOntology(identifier: ShaclmateOntology.$Identifier): Promise<purify.Either<Error, ShaclmateOntology>>;
-    shaclmateOntologyIdentifiers(query?: $ObjectSet.Query<ShaclmateOntology.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateOntology.$Identifier[]>>;
-    shaclmateOntologies(query?: $ObjectSet.Query<ShaclmateOntology.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateOntology[]>>;
-    shaclmateOntologiesCount(query?: Pick<$ObjectSet.Query<ShaclmateOntology.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclmatePropertyShape(identifier: ShaclmatePropertyShape.$Identifier): Promise<purify.Either<Error, ShaclmatePropertyShape>>;
-    shaclmatePropertyShapeIdentifiers(query?: $ObjectSet.Query<ShaclmatePropertyShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmatePropertyShape.$Identifier[]>>;
-    shaclmatePropertyShapes(query?: $ObjectSet.Query<ShaclmatePropertyShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmatePropertyShape[]>>;
-    shaclmatePropertyShapesCount(query?: Pick<$ObjectSet.Query<ShaclmatePropertyShape.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclCoreShape(identifier: ShaclCoreShape.$Identifier): Promise<purify.Either<Error, ShaclCoreShape>>;
-    shaclCoreShapeIdentifiers(query?: $ObjectSet.Query<ShaclCoreShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclCoreShape.$Identifier[]>>;
-    shaclCoreShapes(query?: $ObjectSet.Query<ShaclCoreShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclCoreShape[]>>;
-    shaclCoreShapesCount(query?: Pick<$ObjectSet.Query<ShaclCoreShape.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclmateShape(identifier: ShaclmateShape.$Identifier): Promise<purify.Either<Error, ShaclmateShape>>;
-    shaclmateShapeIdentifiers(query?: $ObjectSet.Query<ShaclmateShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateShape.$Identifier[]>>;
-    shaclmateShapes(query?: $ObjectSet.Query<ShaclmateShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateShape[]>>;
-    shaclmateShapesCount(query?: Pick<$ObjectSet.Query<ShaclmateShape.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
+    }
 }
 export declare class $RdfjsDatasetObjectSet implements $ObjectSet {
-    readonly resourceSet: rdfjsResource.ResourceSet;
-    constructor({ dataset }: {
-        dataset: rdfjs.DatasetCore;
+    #private;
+    protected readonly $graph?: Exclude<Quad_Graph, Variable>;
+    constructor(dataset: DatasetCore | (() => DatasetCore), options?: {
+        graph?: Exclude<Quad_Graph, Variable>;
     });
-    owlOntology(identifier: OwlOntologyStatic.$Identifier): Promise<purify.Either<Error, OwlOntology>>;
-    owlOntologySync(identifier: OwlOntologyStatic.$Identifier): purify.Either<Error, OwlOntology>;
-    owlOntologyIdentifiers(query?: $ObjectSet.Query<OwlOntologyStatic.$Identifier>): Promise<purify.Either<Error, readonly OwlOntologyStatic.$Identifier[]>>;
-    owlOntologyIdentifiersSync(query?: $ObjectSet.Query<OwlOntologyStatic.$Identifier>): purify.Either<Error, readonly OwlOntologyStatic.$Identifier[]>;
-    owlOntologies(query?: $ObjectSet.Query<OwlOntologyStatic.$Identifier>): Promise<purify.Either<Error, readonly OwlOntology[]>>;
-    owlOntologiesSync(query?: $ObjectSet.Query<OwlOntologyStatic.$Identifier>): purify.Either<Error, readonly OwlOntology[]>;
-    owlOntologiesCount(query?: Pick<$ObjectSet.Query<OwlOntologyStatic.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    owlOntologiesCountSync(query?: Pick<$ObjectSet.Query<OwlOntologyStatic.$Identifier>, "where">): purify.Either<Error, number>;
-    shaclCoreNodeShape(identifier: ShaclCoreNodeShapeStatic.$Identifier): Promise<purify.Either<Error, ShaclCoreNodeShape>>;
-    shaclCoreNodeShapeSync(identifier: ShaclCoreNodeShapeStatic.$Identifier): purify.Either<Error, ShaclCoreNodeShape>;
-    shaclCoreNodeShapeIdentifiers(query?: $ObjectSet.Query<ShaclCoreNodeShapeStatic.$Identifier>): Promise<purify.Either<Error, readonly ShaclCoreNodeShapeStatic.$Identifier[]>>;
-    shaclCoreNodeShapeIdentifiersSync(query?: $ObjectSet.Query<ShaclCoreNodeShapeStatic.$Identifier>): purify.Either<Error, readonly ShaclCoreNodeShapeStatic.$Identifier[]>;
-    shaclCoreNodeShapes(query?: $ObjectSet.Query<ShaclCoreNodeShapeStatic.$Identifier>): Promise<purify.Either<Error, readonly ShaclCoreNodeShape[]>>;
-    shaclCoreNodeShapesSync(query?: $ObjectSet.Query<ShaclCoreNodeShapeStatic.$Identifier>): purify.Either<Error, readonly ShaclCoreNodeShape[]>;
-    shaclCoreNodeShapesCount(query?: Pick<$ObjectSet.Query<ShaclCoreNodeShapeStatic.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclCoreNodeShapesCountSync(query?: Pick<$ObjectSet.Query<ShaclCoreNodeShapeStatic.$Identifier>, "where">): purify.Either<Error, number>;
-    shaclCorePropertyGroup(identifier: ShaclCorePropertyGroup.$Identifier): Promise<purify.Either<Error, ShaclCorePropertyGroup>>;
-    shaclCorePropertyGroupSync(identifier: ShaclCorePropertyGroup.$Identifier): purify.Either<Error, ShaclCorePropertyGroup>;
-    shaclCorePropertyGroupIdentifiers(query?: $ObjectSet.Query<ShaclCorePropertyGroup.$Identifier>): Promise<purify.Either<Error, readonly ShaclCorePropertyGroup.$Identifier[]>>;
-    shaclCorePropertyGroupIdentifiersSync(query?: $ObjectSet.Query<ShaclCorePropertyGroup.$Identifier>): purify.Either<Error, readonly ShaclCorePropertyGroup.$Identifier[]>;
-    shaclCorePropertyGroups(query?: $ObjectSet.Query<ShaclCorePropertyGroup.$Identifier>): Promise<purify.Either<Error, readonly ShaclCorePropertyGroup[]>>;
-    shaclCorePropertyGroupsSync(query?: $ObjectSet.Query<ShaclCorePropertyGroup.$Identifier>): purify.Either<Error, readonly ShaclCorePropertyGroup[]>;
-    shaclCorePropertyGroupsCount(query?: Pick<$ObjectSet.Query<ShaclCorePropertyGroup.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclCorePropertyGroupsCountSync(query?: Pick<$ObjectSet.Query<ShaclCorePropertyGroup.$Identifier>, "where">): purify.Either<Error, number>;
-    shaclCorePropertyShape(identifier: ShaclCorePropertyShapeStatic.$Identifier): Promise<purify.Either<Error, ShaclCorePropertyShape>>;
-    shaclCorePropertyShapeSync(identifier: ShaclCorePropertyShapeStatic.$Identifier): purify.Either<Error, ShaclCorePropertyShape>;
-    shaclCorePropertyShapeIdentifiers(query?: $ObjectSet.Query<ShaclCorePropertyShapeStatic.$Identifier>): Promise<purify.Either<Error, readonly ShaclCorePropertyShapeStatic.$Identifier[]>>;
-    shaclCorePropertyShapeIdentifiersSync(query?: $ObjectSet.Query<ShaclCorePropertyShapeStatic.$Identifier>): purify.Either<Error, readonly ShaclCorePropertyShapeStatic.$Identifier[]>;
-    shaclCorePropertyShapes(query?: $ObjectSet.Query<ShaclCorePropertyShapeStatic.$Identifier>): Promise<purify.Either<Error, readonly ShaclCorePropertyShape[]>>;
-    shaclCorePropertyShapesSync(query?: $ObjectSet.Query<ShaclCorePropertyShapeStatic.$Identifier>): purify.Either<Error, readonly ShaclCorePropertyShape[]>;
-    shaclCorePropertyShapesCount(query?: Pick<$ObjectSet.Query<ShaclCorePropertyShapeStatic.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclCorePropertyShapesCountSync(query?: Pick<$ObjectSet.Query<ShaclCorePropertyShapeStatic.$Identifier>, "where">): purify.Either<Error, number>;
-    shaclmateNodeShape(identifier: ShaclmateNodeShape.$Identifier): Promise<purify.Either<Error, ShaclmateNodeShape>>;
-    shaclmateNodeShapeSync(identifier: ShaclmateNodeShape.$Identifier): purify.Either<Error, ShaclmateNodeShape>;
-    shaclmateNodeShapeIdentifiers(query?: $ObjectSet.Query<ShaclmateNodeShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateNodeShape.$Identifier[]>>;
-    shaclmateNodeShapeIdentifiersSync(query?: $ObjectSet.Query<ShaclmateNodeShape.$Identifier>): purify.Either<Error, readonly ShaclmateNodeShape.$Identifier[]>;
-    shaclmateNodeShapes(query?: $ObjectSet.Query<ShaclmateNodeShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateNodeShape[]>>;
-    shaclmateNodeShapesSync(query?: $ObjectSet.Query<ShaclmateNodeShape.$Identifier>): purify.Either<Error, readonly ShaclmateNodeShape[]>;
-    shaclmateNodeShapesCount(query?: Pick<$ObjectSet.Query<ShaclmateNodeShape.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclmateNodeShapesCountSync(query?: Pick<$ObjectSet.Query<ShaclmateNodeShape.$Identifier>, "where">): purify.Either<Error, number>;
-    shaclmateOntology(identifier: ShaclmateOntology.$Identifier): Promise<purify.Either<Error, ShaclmateOntology>>;
-    shaclmateOntologySync(identifier: ShaclmateOntology.$Identifier): purify.Either<Error, ShaclmateOntology>;
-    shaclmateOntologyIdentifiers(query?: $ObjectSet.Query<ShaclmateOntology.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateOntology.$Identifier[]>>;
-    shaclmateOntologyIdentifiersSync(query?: $ObjectSet.Query<ShaclmateOntology.$Identifier>): purify.Either<Error, readonly ShaclmateOntology.$Identifier[]>;
-    shaclmateOntologies(query?: $ObjectSet.Query<ShaclmateOntology.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateOntology[]>>;
-    shaclmateOntologiesSync(query?: $ObjectSet.Query<ShaclmateOntology.$Identifier>): purify.Either<Error, readonly ShaclmateOntology[]>;
-    shaclmateOntologiesCount(query?: Pick<$ObjectSet.Query<ShaclmateOntology.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclmateOntologiesCountSync(query?: Pick<$ObjectSet.Query<ShaclmateOntology.$Identifier>, "where">): purify.Either<Error, number>;
-    shaclmatePropertyShape(identifier: ShaclmatePropertyShape.$Identifier): Promise<purify.Either<Error, ShaclmatePropertyShape>>;
-    shaclmatePropertyShapeSync(identifier: ShaclmatePropertyShape.$Identifier): purify.Either<Error, ShaclmatePropertyShape>;
-    shaclmatePropertyShapeIdentifiers(query?: $ObjectSet.Query<ShaclmatePropertyShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmatePropertyShape.$Identifier[]>>;
-    shaclmatePropertyShapeIdentifiersSync(query?: $ObjectSet.Query<ShaclmatePropertyShape.$Identifier>): purify.Either<Error, readonly ShaclmatePropertyShape.$Identifier[]>;
-    shaclmatePropertyShapes(query?: $ObjectSet.Query<ShaclmatePropertyShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmatePropertyShape[]>>;
-    shaclmatePropertyShapesSync(query?: $ObjectSet.Query<ShaclmatePropertyShape.$Identifier>): purify.Either<Error, readonly ShaclmatePropertyShape[]>;
-    shaclmatePropertyShapesCount(query?: Pick<$ObjectSet.Query<ShaclmatePropertyShape.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclmatePropertyShapesCountSync(query?: Pick<$ObjectSet.Query<ShaclmatePropertyShape.$Identifier>, "where">): purify.Either<Error, number>;
-    shaclCoreShape(identifier: ShaclCoreShape.$Identifier): Promise<purify.Either<Error, ShaclCoreShape>>;
-    shaclCoreShapeSync(identifier: ShaclCoreShape.$Identifier): purify.Either<Error, ShaclCoreShape>;
-    shaclCoreShapeIdentifiers(query?: $ObjectSet.Query<ShaclCoreShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclCoreShape.$Identifier[]>>;
-    shaclCoreShapeIdentifiersSync(query?: $ObjectSet.Query<ShaclCoreShape.$Identifier>): purify.Either<Error, readonly ShaclCoreShape.$Identifier[]>;
-    shaclCoreShapes(query?: $ObjectSet.Query<ShaclCoreShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclCoreShape[]>>;
-    shaclCoreShapesSync(query?: $ObjectSet.Query<ShaclCoreShape.$Identifier>): purify.Either<Error, readonly ShaclCoreShape[]>;
-    shaclCoreShapesCount(query?: Pick<$ObjectSet.Query<ShaclCoreShape.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclCoreShapesCountSync(query?: Pick<$ObjectSet.Query<ShaclCoreShape.$Identifier>, "where">): purify.Either<Error, number>;
-    shaclmateShape(identifier: ShaclmateShape.$Identifier): Promise<purify.Either<Error, ShaclmateShape>>;
-    shaclmateShapeSync(identifier: ShaclmateShape.$Identifier): purify.Either<Error, ShaclmateShape>;
-    shaclmateShapeIdentifiers(query?: $ObjectSet.Query<ShaclmateShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateShape.$Identifier[]>>;
-    shaclmateShapeIdentifiersSync(query?: $ObjectSet.Query<ShaclmateShape.$Identifier>): purify.Either<Error, readonly ShaclmateShape.$Identifier[]>;
-    shaclmateShapes(query?: $ObjectSet.Query<ShaclmateShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateShape[]>>;
-    shaclmateShapesSync(query?: $ObjectSet.Query<ShaclmateShape.$Identifier>): purify.Either<Error, readonly ShaclmateShape[]>;
-    shaclmateShapesCount(query?: Pick<$ObjectSet.Query<ShaclmateShape.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
-    shaclmateShapesCountSync(query?: Pick<$ObjectSet.Query<ShaclmateShape.$Identifier>, "where">): purify.Either<Error, number>;
-    protected $objectIdentifiersSync<ObjectT extends {
-        readonly $identifier: ObjectIdentifierT;
-    }, ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode>(objectType: {
-        $fromRdf: (resource: rdfjsResource.Resource, options: {
-            objectSet: $ObjectSet;
-        }) => purify.Either<Error, ObjectT>;
-        $fromRdfTypes: readonly rdfjs.NamedNode[];
-    }, query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, readonly ObjectIdentifierT[]>;
+    protected $dataset(): DatasetCore;
+    protected $resourceSet(): ResourceSet;
+    owlOntology(identifier: OwlOntologyStatic.$Identifier): Promise<Either<Error, OwlOntology>>;
+    owlOntologySync(identifier: OwlOntologyStatic.$Identifier): Either<Error, OwlOntology>;
+    owlOntologyCount(query?: Pick<$ObjectSet.Query<OwlOntologyStatic.$Filter, OwlOntologyStatic.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    owlOntologyCountSync(query?: Pick<$ObjectSet.Query<OwlOntologyStatic.$Filter, OwlOntologyStatic.$Identifier>, "filter">): Either<Error, number>;
+    owlOntologyIdentifiers(query?: $ObjectSet.Query<OwlOntologyStatic.$Filter, OwlOntologyStatic.$Identifier>): Promise<Either<Error, readonly OwlOntologyStatic.$Identifier[]>>;
+    owlOntologyIdentifiersSync(query?: $ObjectSet.Query<OwlOntologyStatic.$Filter, OwlOntologyStatic.$Identifier>): Either<Error, readonly OwlOntologyStatic.$Identifier[]>;
+    owlOntologies(query?: $ObjectSet.Query<OwlOntologyStatic.$Filter, OwlOntologyStatic.$Identifier>): Promise<Either<Error, readonly OwlOntology[]>>;
+    owlOntologiesSync(query?: $ObjectSet.Query<OwlOntologyStatic.$Filter, OwlOntologyStatic.$Identifier>): Either<Error, readonly OwlOntology[]>;
+    shaclCoreNodeShape(identifier: ShaclCoreNodeShapeStatic.$Identifier): Promise<Either<Error, ShaclCoreNodeShape>>;
+    shaclCoreNodeShapeSync(identifier: ShaclCoreNodeShapeStatic.$Identifier): Either<Error, ShaclCoreNodeShape>;
+    shaclCoreNodeShapeCount(query?: Pick<$ObjectSet.Query<ShaclCoreNodeShapeStatic.$Filter, ShaclCoreNodeShapeStatic.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shaclCoreNodeShapeCountSync(query?: Pick<$ObjectSet.Query<ShaclCoreNodeShapeStatic.$Filter, ShaclCoreNodeShapeStatic.$Identifier>, "filter">): Either<Error, number>;
+    shaclCoreNodeShapeIdentifiers(query?: $ObjectSet.Query<ShaclCoreNodeShapeStatic.$Filter, ShaclCoreNodeShapeStatic.$Identifier>): Promise<Either<Error, readonly ShaclCoreNodeShapeStatic.$Identifier[]>>;
+    shaclCoreNodeShapeIdentifiersSync(query?: $ObjectSet.Query<ShaclCoreNodeShapeStatic.$Filter, ShaclCoreNodeShapeStatic.$Identifier>): Either<Error, readonly ShaclCoreNodeShapeStatic.$Identifier[]>;
+    shaclCoreNodeShapes(query?: $ObjectSet.Query<ShaclCoreNodeShapeStatic.$Filter, ShaclCoreNodeShapeStatic.$Identifier>): Promise<Either<Error, readonly ShaclCoreNodeShape[]>>;
+    shaclCoreNodeShapesSync(query?: $ObjectSet.Query<ShaclCoreNodeShapeStatic.$Filter, ShaclCoreNodeShapeStatic.$Identifier>): Either<Error, readonly ShaclCoreNodeShape[]>;
+    shaclCorePropertyGroup(identifier: ShaclCorePropertyGroup.$Identifier): Promise<Either<Error, ShaclCorePropertyGroup>>;
+    shaclCorePropertyGroupSync(identifier: ShaclCorePropertyGroup.$Identifier): Either<Error, ShaclCorePropertyGroup>;
+    shaclCorePropertyGroupCount(query?: Pick<$ObjectSet.Query<ShaclCorePropertyGroup.$Filter, ShaclCorePropertyGroup.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shaclCorePropertyGroupCountSync(query?: Pick<$ObjectSet.Query<ShaclCorePropertyGroup.$Filter, ShaclCorePropertyGroup.$Identifier>, "filter">): Either<Error, number>;
+    shaclCorePropertyGroupIdentifiers(query?: $ObjectSet.Query<ShaclCorePropertyGroup.$Filter, ShaclCorePropertyGroup.$Identifier>): Promise<Either<Error, readonly ShaclCorePropertyGroup.$Identifier[]>>;
+    shaclCorePropertyGroupIdentifiersSync(query?: $ObjectSet.Query<ShaclCorePropertyGroup.$Filter, ShaclCorePropertyGroup.$Identifier>): Either<Error, readonly ShaclCorePropertyGroup.$Identifier[]>;
+    shaclCorePropertyGroups(query?: $ObjectSet.Query<ShaclCorePropertyGroup.$Filter, ShaclCorePropertyGroup.$Identifier>): Promise<Either<Error, readonly ShaclCorePropertyGroup[]>>;
+    shaclCorePropertyGroupsSync(query?: $ObjectSet.Query<ShaclCorePropertyGroup.$Filter, ShaclCorePropertyGroup.$Identifier>): Either<Error, readonly ShaclCorePropertyGroup[]>;
+    shaclCorePropertyShape(identifier: ShaclCorePropertyShapeStatic.$Identifier): Promise<Either<Error, ShaclCorePropertyShape>>;
+    shaclCorePropertyShapeSync(identifier: ShaclCorePropertyShapeStatic.$Identifier): Either<Error, ShaclCorePropertyShape>;
+    shaclCorePropertyShapeCount(query?: Pick<$ObjectSet.Query<ShaclCorePropertyShapeStatic.$Filter, ShaclCorePropertyShapeStatic.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shaclCorePropertyShapeCountSync(query?: Pick<$ObjectSet.Query<ShaclCorePropertyShapeStatic.$Filter, ShaclCorePropertyShapeStatic.$Identifier>, "filter">): Either<Error, number>;
+    shaclCorePropertyShapeIdentifiers(query?: $ObjectSet.Query<ShaclCorePropertyShapeStatic.$Filter, ShaclCorePropertyShapeStatic.$Identifier>): Promise<Either<Error, readonly ShaclCorePropertyShapeStatic.$Identifier[]>>;
+    shaclCorePropertyShapeIdentifiersSync(query?: $ObjectSet.Query<ShaclCorePropertyShapeStatic.$Filter, ShaclCorePropertyShapeStatic.$Identifier>): Either<Error, readonly ShaclCorePropertyShapeStatic.$Identifier[]>;
+    shaclCorePropertyShapes(query?: $ObjectSet.Query<ShaclCorePropertyShapeStatic.$Filter, ShaclCorePropertyShapeStatic.$Identifier>): Promise<Either<Error, readonly ShaclCorePropertyShape[]>>;
+    shaclCorePropertyShapesSync(query?: $ObjectSet.Query<ShaclCorePropertyShapeStatic.$Filter, ShaclCorePropertyShapeStatic.$Identifier>): Either<Error, readonly ShaclCorePropertyShape[]>;
+    shaclmateNodeShape(identifier: ShaclmateNodeShape.$Identifier): Promise<Either<Error, ShaclmateNodeShape>>;
+    shaclmateNodeShapeSync(identifier: ShaclmateNodeShape.$Identifier): Either<Error, ShaclmateNodeShape>;
+    shaclmateNodeShapeCount(query?: Pick<$ObjectSet.Query<ShaclmateNodeShape.$Filter, ShaclmateNodeShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shaclmateNodeShapeCountSync(query?: Pick<$ObjectSet.Query<ShaclmateNodeShape.$Filter, ShaclmateNodeShape.$Identifier>, "filter">): Either<Error, number>;
+    shaclmateNodeShapeIdentifiers(query?: $ObjectSet.Query<ShaclmateNodeShape.$Filter, ShaclmateNodeShape.$Identifier>): Promise<Either<Error, readonly ShaclmateNodeShape.$Identifier[]>>;
+    shaclmateNodeShapeIdentifiersSync(query?: $ObjectSet.Query<ShaclmateNodeShape.$Filter, ShaclmateNodeShape.$Identifier>): Either<Error, readonly ShaclmateNodeShape.$Identifier[]>;
+    shaclmateNodeShapes(query?: $ObjectSet.Query<ShaclmateNodeShape.$Filter, ShaclmateNodeShape.$Identifier>): Promise<Either<Error, readonly ShaclmateNodeShape[]>>;
+    shaclmateNodeShapesSync(query?: $ObjectSet.Query<ShaclmateNodeShape.$Filter, ShaclmateNodeShape.$Identifier>): Either<Error, readonly ShaclmateNodeShape[]>;
+    shaclmateOntology(identifier: ShaclmateOntology.$Identifier): Promise<Either<Error, ShaclmateOntology>>;
+    shaclmateOntologySync(identifier: ShaclmateOntology.$Identifier): Either<Error, ShaclmateOntology>;
+    shaclmateOntologyCount(query?: Pick<$ObjectSet.Query<ShaclmateOntology.$Filter, ShaclmateOntology.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shaclmateOntologyCountSync(query?: Pick<$ObjectSet.Query<ShaclmateOntology.$Filter, ShaclmateOntology.$Identifier>, "filter">): Either<Error, number>;
+    shaclmateOntologyIdentifiers(query?: $ObjectSet.Query<ShaclmateOntology.$Filter, ShaclmateOntology.$Identifier>): Promise<Either<Error, readonly ShaclmateOntology.$Identifier[]>>;
+    shaclmateOntologyIdentifiersSync(query?: $ObjectSet.Query<ShaclmateOntology.$Filter, ShaclmateOntology.$Identifier>): Either<Error, readonly ShaclmateOntology.$Identifier[]>;
+    shaclmateOntologies(query?: $ObjectSet.Query<ShaclmateOntology.$Filter, ShaclmateOntology.$Identifier>): Promise<Either<Error, readonly ShaclmateOntology[]>>;
+    shaclmateOntologiesSync(query?: $ObjectSet.Query<ShaclmateOntology.$Filter, ShaclmateOntology.$Identifier>): Either<Error, readonly ShaclmateOntology[]>;
+    shaclmatePropertyShape(identifier: ShaclmatePropertyShape.$Identifier): Promise<Either<Error, ShaclmatePropertyShape>>;
+    shaclmatePropertyShapeSync(identifier: ShaclmatePropertyShape.$Identifier): Either<Error, ShaclmatePropertyShape>;
+    shaclmatePropertyShapeCount(query?: Pick<$ObjectSet.Query<ShaclmatePropertyShape.$Filter, ShaclmatePropertyShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shaclmatePropertyShapeCountSync(query?: Pick<$ObjectSet.Query<ShaclmatePropertyShape.$Filter, ShaclmatePropertyShape.$Identifier>, "filter">): Either<Error, number>;
+    shaclmatePropertyShapeIdentifiers(query?: $ObjectSet.Query<ShaclmatePropertyShape.$Filter, ShaclmatePropertyShape.$Identifier>): Promise<Either<Error, readonly ShaclmatePropertyShape.$Identifier[]>>;
+    shaclmatePropertyShapeIdentifiersSync(query?: $ObjectSet.Query<ShaclmatePropertyShape.$Filter, ShaclmatePropertyShape.$Identifier>): Either<Error, readonly ShaclmatePropertyShape.$Identifier[]>;
+    shaclmatePropertyShapes(query?: $ObjectSet.Query<ShaclmatePropertyShape.$Filter, ShaclmatePropertyShape.$Identifier>): Promise<Either<Error, readonly ShaclmatePropertyShape[]>>;
+    shaclmatePropertyShapesSync(query?: $ObjectSet.Query<ShaclmatePropertyShape.$Filter, ShaclmatePropertyShape.$Identifier>): Either<Error, readonly ShaclmatePropertyShape[]>;
+    shaclCoreShape(identifier: ShaclCoreShape.$Identifier): Promise<Either<Error, ShaclCoreShape>>;
+    shaclCoreShapeSync(identifier: ShaclCoreShape.$Identifier): Either<Error, ShaclCoreShape>;
+    shaclCoreShapeCount(query?: Pick<$ObjectSet.Query<ShaclCoreShape.$Filter, ShaclCoreShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shaclCoreShapeCountSync(query?: Pick<$ObjectSet.Query<ShaclCoreShape.$Filter, ShaclCoreShape.$Identifier>, "filter">): Either<Error, number>;
+    shaclCoreShapeIdentifiers(query?: $ObjectSet.Query<ShaclCoreShape.$Filter, ShaclCoreShape.$Identifier>): Promise<Either<Error, readonly ShaclCoreShape.$Identifier[]>>;
+    shaclCoreShapeIdentifiersSync(query?: $ObjectSet.Query<ShaclCoreShape.$Filter, ShaclCoreShape.$Identifier>): Either<Error, readonly ShaclCoreShape.$Identifier[]>;
+    shaclCoreShapes(query?: $ObjectSet.Query<ShaclCoreShape.$Filter, ShaclCoreShape.$Identifier>): Promise<Either<Error, readonly ShaclCoreShape[]>>;
+    shaclCoreShapesSync(query?: $ObjectSet.Query<ShaclCoreShape.$Filter, ShaclCoreShape.$Identifier>): Either<Error, readonly ShaclCoreShape[]>;
+    shaclmateShape(identifier: ShaclmateShape.$Identifier): Promise<Either<Error, ShaclmateShape>>;
+    shaclmateShapeSync(identifier: ShaclmateShape.$Identifier): Either<Error, ShaclmateShape>;
+    shaclmateShapeCount(query?: Pick<$ObjectSet.Query<ShaclmateShape.$Filter, ShaclmateShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shaclmateShapeCountSync(query?: Pick<$ObjectSet.Query<ShaclmateShape.$Filter, ShaclmateShape.$Identifier>, "filter">): Either<Error, number>;
+    shaclmateShapeIdentifiers(query?: $ObjectSet.Query<ShaclmateShape.$Filter, ShaclmateShape.$Identifier>): Promise<Either<Error, readonly ShaclmateShape.$Identifier[]>>;
+    shaclmateShapeIdentifiersSync(query?: $ObjectSet.Query<ShaclmateShape.$Filter, ShaclmateShape.$Identifier>): Either<Error, readonly ShaclmateShape.$Identifier[]>;
+    shaclmateShapes(query?: $ObjectSet.Query<ShaclmateShape.$Filter, ShaclmateShape.$Identifier>): Promise<Either<Error, readonly ShaclmateShape[]>>;
+    shaclmateShapesSync(query?: $ObjectSet.Query<ShaclmateShape.$Filter, ShaclmateShape.$Identifier>): Either<Error, readonly ShaclmateShape[]>;
+    object(identifier: $Object.$Identifier): Promise<Either<Error, $Object>>;
+    objectSync(identifier: $Object.$Identifier): Either<Error, $Object>;
+    objectCount(query?: Pick<$ObjectSet.Query<$Object.$Filter, $Object.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    objectCountSync(query?: Pick<$ObjectSet.Query<$Object.$Filter, $Object.$Identifier>, "filter">): Either<Error, number>;
+    objectIdentifiers(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Promise<Either<Error, readonly $Object.$Identifier[]>>;
+    objectIdentifiersSync(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Either<Error, readonly $Object.$Identifier[]>;
+    objects(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Promise<Either<Error, readonly $Object[]>>;
+    objectsSync(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Either<Error, readonly $Object[]>;
     protected $objectsSync<ObjectT extends {
         readonly $identifier: ObjectIdentifierT;
-    }, ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode>(objectType: {
-        $fromRdf: (resource: rdfjsResource.Resource, options: {
-            objectSet: $ObjectSet;
-        }) => purify.Either<Error, ObjectT>;
-        $fromRdfTypes: readonly rdfjs.NamedNode[];
-    }, query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, readonly ObjectT[]>;
-    protected $objectsCountSync<ObjectT extends {
-        readonly $identifier: ObjectIdentifierT;
-    }, ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode>(objectType: {
-        $fromRdf: (resource: rdfjsResource.Resource, options: {
+    }, ObjectFilterT, ObjectIdentifierT extends BlankNode | NamedNode>(objectType: {
+        $filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
+        $fromRdf: (resource: Resource, options: {
+            graph?: Exclude<Quad_Graph, Variable>;
             objectSet: $ObjectSet;
-        }) => purify.Either<Error, ObjectT>;
-        $fromRdfTypes: readonly rdfjs.NamedNode[];
-    }, query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, number>;
-    protected $objectUnionIdentifiersSync<ObjectT extends {
-        readonly $identifier: ObjectIdentifierT;
-    }, ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode>(objectTypes: readonly {
-        $fromRdf: (resource: rdfjsResource.Resource, options: {
-            objectSet: $ObjectSet;
-        }) => purify.Either<Error, ObjectT>;
-        $fromRdfTypes: readonly rdfjs.NamedNode[];
-    }[], query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, readonly ObjectIdentifierT[]>;
+        }) => Either<Error, ObjectT>;
+        $fromRdfTypes: readonly NamedNode[];
+    }, query?: $ObjectSet.Query<ObjectFilterT, ObjectIdentifierT>): Either<Error, readonly ObjectT[]>;
     protected $objectUnionsSync<ObjectT extends {
         readonly $identifier: ObjectIdentifierT;
-    }, ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode>(objectTypes: readonly {
-        $fromRdf: (resource: rdfjsResource.Resource, options: {
-            objectSet: $ObjectSet;
-        }) => purify.Either<Error, ObjectT>;
-        $fromRdfTypes: readonly rdfjs.NamedNode[];
-    }[], query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, readonly ObjectT[]>;
-    protected $objectUnionsCountSync<ObjectT extends {
-        readonly $identifier: ObjectIdentifierT;
-    }, ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode>(objectTypes: readonly {
-        $fromRdf: (resource: rdfjsResource.Resource, options: {
+    }, ObjectFilterT, ObjectIdentifierT extends BlankNode | NamedNode>(objectTypes: readonly {
+        $filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
+        $fromRdf: (resource: Resource, options: {
+            graph?: Exclude<Quad_Graph, Variable>;
             objectSet: $ObjectSet;
-        }) => purify.Either<Error, ObjectT>;
-        $fromRdfTypes: readonly rdfjs.NamedNode[];
-    }[], query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, number>;
+        }) => Either<Error, ObjectT>;
+        $fromRdfTypes: readonly NamedNode[];
+    }[], query?: $ObjectSet.Query<ObjectFilterT, ObjectIdentifierT>): Either<Error, readonly ObjectT[]>;
 }
 export {};
 //# sourceMappingURL=generated.d.ts.map