@shaclmate/shacl-ast 4.0.7 → 4.0.9

package/dist/generated.d.ts

@@ -1,6 +1,6 @@
 import type { BlankNode, DatasetCore, Literal, NamedNode, Quad_Graph, Variable } from "@rdfjs/types";
 import { Either, Maybe } from "purify-ts";
-import { PropertyPath, Resource, ResourceSet } from "rdfjs-resource";
+import { PropertyPath as RdfjsResourcePropertyPath, Resource, ResourceSet } from "rdfjs-resource";
 interface $BooleanFilter {
     readonly value?: boolean;
 }
@@ -8,13 +8,22 @@ type $CollectionFilter<ItemFilterT> = ItemFilterT & {
     readonly $maxCount?: number;
     readonly $minCount?: number;
 };
-type $FromRdfOptions = {
+export type $FromRdfResourceFunction<T> = (resource: Resource, options?: {
     context?: unknown;
     graph?: Exclude<Quad_Graph, Variable>;
     ignoreRdfType?: boolean;
     objectSet?: $ObjectSet;
     preferredLanguages?: readonly string[];
-};
+}) => Either<Error, T>;
+export type $FromRdfResourceValuesFunction<T> = (resourceValues: Either<Error, Resource.Values>, options: {
+    context?: unknown;
+    graph?: Exclude<Quad_Graph, Variable>;
+    ignoreRdfType?: boolean;
+    objectSet?: $ObjectSet;
+    preferredLanguages?: readonly string[];
+    propertyPath: $PropertyPath;
+    resource: Resource;
+}) => Either<Error, Resource.Values<T>>;
 interface $IdentifierFilter {
     readonly in?: readonly (BlankNode | NamedNode)[];
     readonly type?: "BlankNode" | "NamedNode";
@@ -34,17 +43,25 @@ interface $NumericFilter<T> {
     readonly minExclusive?: T;
     readonly minInclusive?: T;
 }
-type $PropertiesFromRdfParameters = {
-    context?: unknown;
-    graph?: Exclude<Quad_Graph, Variable>;
+type $PropertiesFromRdfResourceFunction<T> = (resource: Resource, options: {
+    context: undefined | unknown;
+    graph: Exclude<Quad_Graph, Variable> | undefined;
     ignoreRdfType: boolean;
     objectSet: $ObjectSet;
     preferredLanguages?: readonly string[];
-    resource: Resource;
-};
+}) => Either<Error, T>;
+export type $PropertyPath = RdfjsResourcePropertyPath;
+export declare namespace $PropertyPath {
+    type $Filter = object;
+    function $filter(_filter: $Filter, _value: $PropertyPath): boolean;
+    const $fromRdfResource: $FromRdfResourceFunction<$PropertyPath>;
+    const $fromRdfResourceValues: $FromRdfResourceValuesFunction<$PropertyPath>;
+    const $schema: Readonly<object>;
+    const $toRdfResource: $ToRdfResourceFunction<$PropertyPath>;
+}
 export interface $ShaclPropertySchema<TypeSchemaT = object> {
     readonly kind: "Shacl";
-    readonly path: PropertyPath;
+    readonly path: $PropertyPath;
     readonly type: () => TypeSchemaT;
 }
 interface $StringFilter {
@@ -58,16 +75,30 @@ interface $TermFilter {
     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";
+export type $ToRdfResourceFunction<T> = (value: T, options?: {
+    graph?: Exclude<Quad_Graph, Variable>;
+    ignoreRdfType?: boolean;
+    resourceSet?: ResourceSet;
+}) => Resource;
+export type $ToRdfResourceValuesFunction<T> = (value: T, options: {
+    graph?: Exclude<Quad_Graph, Variable>;
+    ignoreRdfType?: boolean;
+    propertyPath: $PropertyPath;
+    resource: Resource;
+    resourceSet: ResourceSet;
+}) => (bigint | boolean | number | string | BlankNode | Literal | NamedNode)[];
+export interface PropertyShape {
+    readonly $identifier: PropertyShape.$Identifier;
+    readonly $type: "PropertyShape";
     readonly and: readonly (readonly (BlankNode | NamedNode)[])[];
     readonly classes: readonly NamedNode[];
     readonly comments: readonly string[];
     readonly datatype: Maybe<NamedNode>;
     readonly deactivated: Maybe<boolean>;
+    readonly defaultValue: Maybe<NamedNode | Literal>;
+    readonly descriptions: readonly string[];
     readonly flags: readonly string[];
+    readonly groups: readonly (BlankNode | NamedNode)[];
     readonly hasValues: readonly (NamedNode | Literal)[];
     readonly in_: Maybe<readonly (NamedNode | Literal)[]>;
     readonly isDefinedBy: Maybe<BlankNode | NamedNode>;
@@ -81,15 +112,24 @@ export interface BaseShaclCoreShape {
     readonly minExclusive: Maybe<Literal>;
     readonly minInclusive: Maybe<Literal>;
     readonly minLength: Maybe<number>;
+    readonly names: readonly string[];
     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 order: Maybe<number>;
+    readonly path: $PropertyPath;
     readonly patterns: readonly string[];
+    readonly uniqueLang: Maybe<boolean>;
     readonly xone: readonly (readonly (BlankNode | NamedNode)[])[];
 }
-export declare namespace BaseShaclCoreShapeStatic {
-    function $filter(filter: BaseShaclCoreShapeStatic.$Filter, value: BaseShaclCoreShape): boolean;
+export declare namespace PropertyShape {
+    type $Identifier = BlankNode | NamedNode;
+    namespace $Identifier {
+        const fromString: typeof $identifierFromString;
+        const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
+    }
+    function $filter(filter: PropertyShape.$Filter, value: PropertyShape): boolean;
     type $Filter = {
         readonly $identifier?: $IdentifierFilter;
         readonly and?: $CollectionFilter<$CollectionFilter<$IdentifierFilter>>;
@@ -97,7 +137,10 @@ export declare namespace BaseShaclCoreShapeStatic {
         readonly comments?: $CollectionFilter<$StringFilter>;
         readonly datatype?: $MaybeFilter<$IriFilter>;
         readonly deactivated?: $MaybeFilter<$BooleanFilter>;
+        readonly defaultValue?: $MaybeFilter<$TermFilter>;
+        readonly descriptions?: $CollectionFilter<$StringFilter>;
         readonly flags?: $CollectionFilter<$StringFilter>;
+        readonly groups?: $CollectionFilter<$IdentifierFilter>;
         readonly hasValues?: $CollectionFilter<$TermFilter>;
         readonly in_?: $MaybeFilter<$CollectionFilter<$TermFilter>>;
         readonly isDefinedBy?: $MaybeFilter<$IdentifierFilter>;
@@ -111,27 +154,33 @@ export declare namespace BaseShaclCoreShapeStatic {
         readonly minExclusive?: $MaybeFilter<$LiteralFilter>;
         readonly minInclusive?: $MaybeFilter<$LiteralFilter>;
         readonly minLength?: $MaybeFilter<$NumericFilter<number>>;
+        readonly names?: $CollectionFilter<$StringFilter>;
         readonly nodeKind?: $MaybeFilter<$IriFilter>;
         readonly nodes?: $CollectionFilter<$IdentifierFilter>;
         readonly not?: $CollectionFilter<$IdentifierFilter>;
         readonly or?: $CollectionFilter<$CollectionFilter<$IdentifierFilter>>;
+        readonly order?: $MaybeFilter<$NumericFilter<number>>;
+        readonly path?: $PropertyPath.$Filter;
         readonly patterns?: $CollectionFilter<$StringFilter>;
+        readonly uniqueLang?: $MaybeFilter<$BooleanFilter>;
         readonly xone?: $CollectionFilter<$CollectionFilter<$IdentifierFilter>>;
     };
-    type $Identifier = BlankNode | NamedNode;
-    namespace $Identifier {
-        const fromString: typeof $identifierFromString;
-        const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
-    }
-    function isBaseShaclCoreShape(object: $Object): object is BaseShaclCoreShape;
-    function $propertiesFromRdf($parameters: $PropertiesFromRdfParameters): Either<Error, {
+    const $fromRdfResource: $FromRdfResourceFunction<PropertyShape>;
+    const $fromRdfResourceValues: $FromRdfResourceValuesFunction<PropertyShape>;
+    const $fromRdfType: NamedNode<string>;
+    function isPropertyShape(object: $Object): object is PropertyShape;
+    const $propertiesFromRdfResource: $PropertiesFromRdfResourceFunction<{
         $identifier: BlankNode | NamedNode;
+        $type: "PropertyShape";
         and: readonly (readonly (BlankNode | NamedNode)[])[];
         classes: readonly NamedNode[];
         comments: readonly string[];
         datatype: Maybe<NamedNode>;
         deactivated: Maybe<boolean>;
+        defaultValue: Maybe<NamedNode | Literal>;
+        descriptions: readonly string[];
         flags: readonly string[];
+        groups: readonly (BlankNode | NamedNode)[];
         hasValues: readonly (NamedNode | Literal)[];
         in_: Maybe<readonly (NamedNode | Literal)[]>;
         isDefinedBy: Maybe<BlankNode | NamedNode>;
@@ -145,18 +194,17 @@ export declare namespace BaseShaclCoreShapeStatic {
         minExclusive: Maybe<Literal>;
         minInclusive: Maybe<Literal>;
         minLength: Maybe<number>;
+        names: readonly string[];
         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)[])[];
+        order: Maybe<number>;
+        path: $PropertyPath;
         patterns: readonly string[];
+        uniqueLang: Maybe<boolean>;
         xone: readonly (readonly (BlankNode | NamedNode)[])[];
     }>;
-    function $toRdf(_baseShaclCoreShape: BaseShaclCoreShape, options?: {
-        ignoreRdfType?: boolean;
-        graph?: Exclude<Quad_Graph, Variable>;
-        resourceSet?: ResourceSet;
-    }): Resource;
     const $schema: {
         readonly properties: {
             readonly $identifier: {
@@ -166,10 +214,10 @@ export declare namespace BaseShaclCoreShapeStatic {
                 };
             };
             readonly $type: {
-                readonly kind: "TypeDiscriminant";
+                readonly kind: "Discriminant";
                 readonly type: () => {
-                    descendantValues: string[];
                     kind: "TypeDiscriminant";
+                    ownValues: string[];
                 };
             };
             readonly and: {
@@ -225,6 +273,26 @@ export declare namespace BaseShaclCoreShapeStatic {
                 };
                 readonly path: NamedNode<"http://www.w3.org/ns/shacl#deactivated">;
             };
+            readonly defaultValue: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Maybe";
+                    item: () => {
+                        kind: "Term";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#defaultValue">;
+            };
+            readonly descriptions: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "String";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#description">;
+            };
             readonly flags: {
                 readonly kind: "Shacl";
                 readonly type: () => {
@@ -235,6 +303,16 @@ export declare namespace BaseShaclCoreShapeStatic {
                 };
                 readonly path: NamedNode<"http://www.w3.org/ns/shacl#flags">;
             };
+            readonly groups: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "Identifier";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#group">;
+            };
             readonly hasValues: {
                 readonly kind: "Shacl";
                 readonly type: () => {
@@ -371,6 +449,16 @@ export declare namespace BaseShaclCoreShapeStatic {
                 };
                 readonly path: NamedNode<"http://www.w3.org/ns/shacl#minLength">;
             };
+            readonly names: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "String";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#name">;
+            };
             readonly nodeKind: {
                 readonly kind: "Shacl";
                 readonly type: () => {
@@ -415,6 +503,21 @@ export declare namespace BaseShaclCoreShapeStatic {
                 };
                 readonly path: NamedNode<"http://www.w3.org/ns/shacl#or">;
             };
+            readonly order: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Maybe";
+                    item: () => {
+                        kind: "Float";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#order">;
+            };
+            readonly path: {
+                readonly kind: "Shacl";
+                readonly type: () => object;
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#path">;
+            };
             readonly patterns: {
                 readonly kind: "Shacl";
                 readonly type: () => {
@@ -425,6 +528,16 @@ export declare namespace BaseShaclCoreShapeStatic {
                 };
                 readonly path: NamedNode<"http://www.w3.org/ns/shacl#pattern">;
             };
+            readonly uniqueLang: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Maybe";
+                    item: () => {
+                        kind: "Boolean";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#uniqueLang">;
+            };
             readonly xone: {
                 readonly kind: "Shacl";
                 readonly type: () => {
@@ -440,87 +553,62 @@ export declare namespace BaseShaclCoreShapeStatic {
             };
         };
     };
+    function $toRdfResource(_propertyShape: PropertyShape, options?: Parameters<$ToRdfResourceFunction<PropertyShape>>[1]): Resource;
 }
-export interface ShaclCorePropertyShape extends BaseShaclCoreShape {
-    readonly $identifier: ShaclCorePropertyShape.$Identifier;
-    readonly $type: "ShaclCorePropertyShape";
-    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: Maybe<boolean>;
+export interface PropertyGroup {
+    readonly $identifier: PropertyGroup.$Identifier;
+    readonly $type: "PropertyGroup";
+    readonly comments: readonly string[];
+    readonly labels: readonly string[];
 }
-export declare namespace ShaclCorePropertyShape {
-    function $filter(filter: ShaclCorePropertyShape.$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>;
+export declare namespace PropertyGroup {
     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, {
+    function $filter(filter: PropertyGroup.$Filter, value: PropertyGroup): boolean;
+    type $Filter = {
+        readonly $identifier?: $IdentifierFilter;
+        readonly comments?: $CollectionFilter<$StringFilter>;
+        readonly labels?: $CollectionFilter<$StringFilter>;
+    };
+    const $fromRdfResource: $FromRdfResourceFunction<PropertyGroup>;
+    const $fromRdfResourceValues: $FromRdfResourceValuesFunction<PropertyGroup>;
+    const $fromRdfType: NamedNode<string>;
+    function isPropertyGroup(object: $Object): object is PropertyGroup;
+    const $propertiesFromRdfResource: $PropertiesFromRdfResourceFunction<{
         $identifier: BlankNode | NamedNode;
-        $type: "ShaclCorePropertyShape";
-        defaultValue: Maybe<NamedNode | Literal>;
-        descriptions: readonly string[];
-        groups: readonly (BlankNode | NamedNode)[];
-        names: readonly string[];
-        order: Maybe<number>;
-        path: PropertyPath;
-        uniqueLang: Maybe<boolean>;
-    } & $UnwrapR<ReturnType<typeof BaseShaclCoreShapeStatic.$propertiesFromRdf>>>;
-    function $toRdf(_shaclCorePropertyShape: ShaclCorePropertyShape, options?: {
-        ignoreRdfType?: boolean;
-        graph?: Exclude<Quad_Graph, Variable>;
-        resourceSet?: ResourceSet;
-    }): Resource;
+        $type: "PropertyGroup";
+        comments: readonly string[];
+        labels: readonly string[];
+    }>;
     const $schema: {
         readonly properties: {
-            readonly defaultValue: {
-                readonly kind: "Shacl";
+            readonly $identifier: {
+                readonly kind: "Identifier";
                 readonly type: () => {
-                    kind: "Maybe";
-                    item: () => {
-                        kind: "Term";
-                    };
+                    kind: "Identifier";
                 };
-                readonly path: NamedNode<"http://www.w3.org/ns/shacl#defaultValue">;
             };
-            readonly descriptions: {
-                readonly kind: "Shacl";
+            readonly $type: {
+                readonly kind: "Discriminant";
                 readonly type: () => {
-                    kind: "Set";
-                    item: () => {
-                        kind: "String";
-                    };
+                    kind: "TypeDiscriminant";
+                    ownValues: string[];
                 };
-                readonly path: NamedNode<"http://www.w3.org/ns/shacl#description">;
             };
-            readonly groups: {
+            readonly comments: {
                 readonly kind: "Shacl";
                 readonly type: () => {
                     kind: "Set";
                     item: () => {
-                        kind: "Identifier";
+                        kind: "String";
                     };
                 };
-                readonly path: NamedNode<"http://www.w3.org/ns/shacl#group">;
+                readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#comment">;
             };
-            readonly names: {
+            readonly labels: {
                 readonly kind: "Shacl";
                 readonly type: () => {
                     kind: "Set";
@@ -528,33 +616,39 @@ export declare namespace ShaclCorePropertyShape {
                         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 path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
             };
+        };
+    };
+    function $toRdfResource(_propertyGroup: PropertyGroup, options?: Parameters<$ToRdfResourceFunction<PropertyGroup>>[1]): Resource;
+}
+export interface Ontology {
+    readonly $identifier: Ontology.$Identifier;
+    readonly $type: "Ontology";
+    readonly labels: readonly string[];
+}
+export declare namespace Ontology {
+    type $Identifier = BlankNode | NamedNode;
+    namespace $Identifier {
+        const fromString: typeof $identifierFromString;
+        const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
+    }
+    function $filter(filter: Ontology.$Filter, value: Ontology): boolean;
+    type $Filter = {
+        readonly $identifier?: $IdentifierFilter;
+        readonly labels?: $CollectionFilter<$StringFilter>;
+    };
+    const $fromRdfResource: $FromRdfResourceFunction<Ontology>;
+    const $fromRdfResourceValues: $FromRdfResourceValuesFunction<Ontology>;
+    const $fromRdfType: NamedNode<string>;
+    function isOntology(object: $Object): object is Ontology;
+    const $propertiesFromRdfResource: $PropertiesFromRdfResourceFunction<{
+        $identifier: BlankNode | NamedNode;
+        $type: "Ontology";
+        labels: readonly string[];
+    }>;
+    const $schema: {
+        readonly properties: {
             readonly $identifier: {
                 readonly kind: "Identifier";
                 readonly type: () => {
@@ -562,36 +656,13 @@ export declare namespace ShaclCorePropertyShape {
                 };
             };
             readonly $type: {
-                readonly kind: "TypeDiscriminant";
+                readonly kind: "Discriminant";
                 readonly type: () => {
-                    descendantValues: string[];
                     kind: "TypeDiscriminant";
+                    ownValues: string[];
                 };
             };
-            readonly and: {
-                readonly kind: "Shacl";
-                readonly type: () => {
-                    kind: "Set";
-                    item: () => {
-                        kind: "List";
-                        item: () => {
-                            kind: "Identifier";
-                        };
-                    };
-                };
-                readonly path: NamedNode<"http://www.w3.org/ns/shacl#and">;
-            };
-            readonly classes: {
-                readonly kind: "Shacl";
-                readonly type: () => {
-                    kind: "Set";
-                    item: () => {
-                        kind: "Iri";
-                    };
-                };
-                readonly path: NamedNode<"http://www.w3.org/ns/shacl#class">;
-            };
-            readonly comments: {
+            readonly labels: {
                 readonly kind: "Shacl";
                 readonly type: () => {
                     kind: "Set";
@@ -599,384 +670,120 @@ export declare namespace ShaclCorePropertyShape {
                         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">;
+                readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
             };
         };
     };
+    function $toRdfResource(_ontology: Ontology, options?: Parameters<$ToRdfResourceFunction<Ontology>>[1]): Resource;
 }
-export interface ShaclCorePropertyGroup {
-    readonly $identifier: ShaclCorePropertyGroup.$Identifier;
-    readonly $type: "ShaclCorePropertyGroup";
+export interface NodeShape {
+    readonly $identifier: NodeShape.$Identifier;
+    readonly $type: "NodeShape";
+    readonly and: readonly (readonly (BlankNode | NamedNode)[])[];
+    readonly classes: readonly NamedNode[];
+    readonly closed: Maybe<boolean>;
     readonly comments: readonly string[];
+    readonly datatype: Maybe<NamedNode>;
+    readonly deactivated: Maybe<boolean>;
+    readonly flags: readonly string[];
+    readonly hasValues: readonly (NamedNode | Literal)[];
+    readonly ignoredProperties: Maybe<readonly NamedNode[]>;
+    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 properties: readonly (BlankNode | NamedNode)[];
+    readonly xone: readonly (readonly (BlankNode | NamedNode)[])[];
 }
-export declare namespace ShaclCorePropertyGroup {
-    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>;
+export declare namespace NodeShape {
     type $Identifier = BlankNode | NamedNode;
     namespace $Identifier {
         const fromString: typeof $identifierFromString;
         const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
     }
-    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 string[];
-        labels: readonly string[];
-    }>;
-    function $toRdf(_shaclCorePropertyGroup: ShaclCorePropertyGroup, options?: {
-        ignoreRdfType?: boolean;
-        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 interface ShaclCoreNodeShape extends BaseShaclCoreShape {
-    readonly $identifier: ShaclCoreNodeShape.$Identifier;
-    readonly $type: "ShaclCoreNodeShape";
-    readonly closed: Maybe<boolean>;
-    readonly ignoredProperties: Maybe<readonly NamedNode[]>;
-    readonly properties: readonly (BlankNode | NamedNode)[];
-}
-export declare namespace ShaclCoreNodeShape {
-    function $filter(filter: ShaclCoreNodeShape.$Filter, value: ShaclCoreNodeShape): boolean;
+    function $filter(filter: NodeShape.$Filter, value: NodeShape): boolean;
     type $Filter = {
         readonly $identifier?: $IdentifierFilter;
+        readonly and?: $CollectionFilter<$CollectionFilter<$IdentifierFilter>>;
+        readonly classes?: $CollectionFilter<$IriFilter>;
         readonly closed?: $MaybeFilter<$BooleanFilter>;
+        readonly comments?: $CollectionFilter<$StringFilter>;
+        readonly datatype?: $MaybeFilter<$IriFilter>;
+        readonly deactivated?: $MaybeFilter<$BooleanFilter>;
+        readonly flags?: $CollectionFilter<$StringFilter>;
+        readonly hasValues?: $CollectionFilter<$TermFilter>;
         readonly ignoredProperties?: $MaybeFilter<$CollectionFilter<$IriFilter>>;
+        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 properties?: $CollectionFilter<$IdentifierFilter>;
-    } & BaseShaclCoreShapeStatic.$Filter;
+        readonly xone?: $CollectionFilter<$CollectionFilter<$IdentifierFilter>>;
+    };
+    const $fromRdfResource: $FromRdfResourceFunction<NodeShape>;
+    const $fromRdfResourceValues: $FromRdfResourceValuesFunction<NodeShape>;
     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, {
+    function isNodeShape(object: $Object): object is NodeShape;
+    const $propertiesFromRdfResource: $PropertiesFromRdfResourceFunction<{
         $identifier: BlankNode | NamedNode;
-        $type: "ShaclCoreNodeShape";
+        $type: "NodeShape";
+        and: readonly (readonly (BlankNode | NamedNode)[])[];
+        classes: readonly NamedNode[];
         closed: Maybe<boolean>;
-        ignoredProperties: Maybe<readonly NamedNode[]>;
-        properties: readonly (BlankNode | NamedNode)[];
-    } & $UnwrapR<ReturnType<typeof BaseShaclCoreShapeStatic.$propertiesFromRdf>>>;
-    function $toRdf(_shaclCoreNodeShape: ShaclCoreNodeShape, options?: {
-        ignoreRdfType?: boolean;
-        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">;
-            };
+        comments: readonly string[];
+        datatype: Maybe<NamedNode>;
+        deactivated: Maybe<boolean>;
+        flags: readonly string[];
+        hasValues: readonly (NamedNode | Literal)[];
+        ignoredProperties: Maybe<readonly NamedNode[]>;
+        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[];
+        properties: readonly (BlankNode | NamedNode)[];
+        xone: readonly (readonly (BlankNode | NamedNode)[])[];
+    }>;
+    const $schema: {
+        readonly properties: {
             readonly $identifier: {
                 readonly kind: "Identifier";
                 readonly type: () => {
@@ -984,10 +791,10 @@ export declare namespace ShaclCoreNodeShape {
                 };
             };
             readonly $type: {
-                readonly kind: "TypeDiscriminant";
+                readonly kind: "Discriminant";
                 readonly type: () => {
-                    descendantValues: string[];
                     kind: "TypeDiscriminant";
+                    ownValues: string[];
                 };
             };
             readonly and: {
@@ -1013,6 +820,16 @@ export declare namespace ShaclCoreNodeShape {
                 };
                 readonly path: NamedNode<"http://www.w3.org/ns/shacl#class">;
             };
+            readonly closed: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Maybe";
+                    item: () => {
+                        kind: "Boolean";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#closed">;
+            };
             readonly comments: {
                 readonly kind: "Shacl";
                 readonly type: () => {
@@ -1063,6 +880,19 @@ export declare namespace ShaclCoreNodeShape {
                 };
                 readonly path: NamedNode<"http://www.w3.org/ns/shacl#hasValue">;
             };
+            readonly ignoredProperties: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Maybe";
+                    item: () => {
+                        kind: "List";
+                        item: () => {
+                            kind: "Iri";
+                        };
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#ignoredProperties">;
+            };
             readonly in_: {
                 readonly kind: "Shacl";
                 readonly type: () => {
@@ -1243,6 +1073,16 @@ export declare namespace ShaclCoreNodeShape {
                 };
                 readonly path: NamedNode<"http://www.w3.org/ns/shacl#pattern">;
             };
+            readonly properties: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "Set";
+                    item: () => {
+                        kind: "Identifier";
+                    };
+                };
+                readonly path: NamedNode<"http://www.w3.org/ns/shacl#property">;
+            };
             readonly xone: {
                 readonly kind: "Shacl";
                 readonly type: () => {
@@ -1258,81 +1098,700 @@ export declare namespace ShaclCoreNodeShape {
             };
         };
     };
+    function $toRdfResource(_nodeShape: NodeShape, options?: Parameters<$ToRdfResourceFunction<NodeShape>>[1]): Resource;
 }
-export interface OwlOntology {
-    readonly $identifier: OwlOntology.$Identifier;
-    readonly $type: "OwlOntology";
-    readonly labels: readonly string[];
-}
-export declare namespace OwlOntology {
-    function $filter(filter: OwlOntology.$Filter, value: OwlOntology): boolean;
+export type Shape = NodeShape | PropertyShape;
+export declare namespace Shape {
+    const $toRdfResource: $ToRdfResourceFunction<Shape>;
+    const $filter: (filter: Shape.$Filter, value: Shape) => boolean;
     type $Filter = {
         readonly $identifier?: $IdentifierFilter;
-        readonly labels?: $CollectionFilter<$StringFilter>;
+        readonly on?: {
+            readonly NodeShape?: NodeShape.$Filter;
+            readonly PropertyShape?: PropertyShape.$Filter;
+        };
     };
-    const $fromRdfType: NamedNode<string>;
+    const $fromRdfResource: $FromRdfResourceFunction<Shape>;
+    const $fromRdfResourceValues: $FromRdfResourceValuesFunction<Shape>;
     type $Identifier = BlankNode | NamedNode;
     namespace $Identifier {
         const fromString: typeof $identifierFromString;
         const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
     }
-    function 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";
-        labels: readonly string[];
-    }>;
-    function $toRdf(_owlOntology: OwlOntology, options?: {
-        ignoreRdfType?: boolean;
-        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 kind: "NamedObjectUnion";
+        readonly members: {
+            readonly NodeShape: {
+                readonly discriminantValues: readonly ["NodeShape"];
+                readonly type: {
+                    readonly properties: {
+                        readonly $identifier: {
+                            readonly kind: "Identifier";
+                            readonly type: () => {
+                                kind: "Identifier";
+                            };
+                        };
+                        readonly $type: {
+                            readonly kind: "Discriminant";
+                            readonly type: () => {
+                                kind: "TypeDiscriminant";
+                                ownValues: string[];
+                            };
+                        };
+                        readonly and: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#and">;
+                        };
+                        readonly classes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#class">;
+                        };
+                        readonly closed: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#closed">;
+                        };
+                        readonly comments: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#comment">;
+                        };
+                        readonly datatype: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#datatype">;
+                        };
+                        readonly deactivated: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#deactivated">;
+                        };
+                        readonly 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 ignoredProperties: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Iri";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#ignoredProperties">;
+                        };
+                        readonly in_: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Term";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#in">;
+                        };
+                        readonly isDefinedBy: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#isDefinedBy">;
+                        };
+                        readonly labels: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
+                        };
+                        readonly languageIn: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "String";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#languageIn">;
+                        };
+                        readonly maxCount: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxCount">;
+                        };
+                        readonly maxExclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxExclusive">;
+                        };
+                        readonly maxInclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxInclusive">;
+                        };
+                        readonly maxLength: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxLength">;
+                        };
+                        readonly minCount: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minCount">;
+                        };
+                        readonly minExclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minExclusive">;
+                        };
+                        readonly minInclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minInclusive">;
+                        };
+                        readonly minLength: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minLength">;
+                        };
+                        readonly nodeKind: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | NamedNode<"http://www.w3.org/ns/shacl#IRI"> | NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
+                        };
+                        readonly nodes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#node">;
+                        };
+                        readonly not: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#not">;
+                        };
+                        readonly or: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#or">;
+                        };
+                        readonly patterns: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#pattern">;
+                        };
+                        readonly properties: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#property">;
+                        };
+                        readonly xone: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#xone">;
+                        };
+                    };
                 };
             };
-            readonly labels: {
-                readonly kind: "Shacl";
-                readonly type: () => {
-                    kind: "Set";
-                    item: () => {
-                        kind: "String";
+            readonly PropertyShape: {
+                readonly discriminantValues: readonly ["PropertyShape"];
+                readonly type: {
+                    readonly properties: {
+                        readonly $identifier: {
+                            readonly kind: "Identifier";
+                            readonly type: () => {
+                                kind: "Identifier";
+                            };
+                        };
+                        readonly $type: {
+                            readonly kind: "Discriminant";
+                            readonly type: () => {
+                                kind: "TypeDiscriminant";
+                                ownValues: string[];
+                            };
+                        };
+                        readonly and: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#and">;
+                        };
+                        readonly classes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#class">;
+                        };
+                        readonly comments: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#comment">;
+                        };
+                        readonly datatype: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#datatype">;
+                        };
+                        readonly deactivated: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#deactivated">;
+                        };
+                        readonly defaultValue: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Term";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#defaultValue">;
+                        };
+                        readonly descriptions: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#description">;
+                        };
+                        readonly flags: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#flags">;
+                        };
+                        readonly groups: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#group">;
+                        };
+                        readonly hasValues: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Term";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#hasValue">;
+                        };
+                        readonly in_: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Term";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#in">;
+                        };
+                        readonly isDefinedBy: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#isDefinedBy">;
+                        };
+                        readonly labels: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
+                        };
+                        readonly languageIn: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "String";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#languageIn">;
+                        };
+                        readonly maxCount: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxCount">;
+                        };
+                        readonly maxExclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxExclusive">;
+                        };
+                        readonly maxInclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxInclusive">;
+                        };
+                        readonly maxLength: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxLength">;
+                        };
+                        readonly minCount: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minCount">;
+                        };
+                        readonly minExclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minExclusive">;
+                        };
+                        readonly minInclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minInclusive">;
+                        };
+                        readonly minLength: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minLength">;
+                        };
+                        readonly names: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#name">;
+                        };
+                        readonly nodeKind: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | NamedNode<"http://www.w3.org/ns/shacl#IRI"> | NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
+                        };
+                        readonly nodes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#node">;
+                        };
+                        readonly not: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#not">;
+                        };
+                        readonly or: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#or">;
+                        };
+                        readonly order: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Float";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#order">;
+                        };
+                        readonly path: {
+                            readonly kind: "Shacl";
+                            readonly type: () => object;
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#path">;
+                        };
+                        readonly patterns: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#pattern">;
+                        };
+                        readonly uniqueLang: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#uniqueLang">;
+                        };
+                        readonly xone: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#xone">;
+                        };
                     };
                 };
-                readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
             };
         };
-    };
-}
-export type ShaclCoreShape = ShaclCoreNodeShape | ShaclCorePropertyShape;
-export declare namespace ShaclCoreShape {
-    function $filter(filter: ShaclCoreShape.$Filter, value: ShaclCoreShape): boolean;
-    interface $Filter {
-        readonly $identifier?: $IdentifierFilter;
-        readonly on?: {
-            readonly ShaclCoreNodeShape?: Omit<ShaclCoreNodeShape.$Filter, "$identifier">;
-            readonly ShaclCorePropertyShape?: Omit<ShaclCorePropertyShape.$Filter, "$identifier">;
-        };
-    }
-    type $Identifier = BlankNode | NamedNode;
-    namespace $Identifier {
-        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";
@@ -1602,31 +2061,773 @@ export declare namespace ShaclCoreShape {
             };
         };
     };
-    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, ShaclCoreShape>;
-    function $toRdf(_shaclCoreShape: ShaclCoreShape, _parameters?: {
-        graph?: Exclude<Quad_Graph, Variable>;
-        resourceSet?: ResourceSet;
-    }): Resource;
+    const $toRdfResourceValues: $ToRdfResourceValuesFunction<Shape>;
+    function isShape(object: $Object): object is Shape;
 }
-export type $Object = OwlOntology | ShaclCoreNodeShape | ShaclCorePropertyGroup | ShaclCorePropertyShape | BaseShaclCoreShape;
+export type $Object = NodeShape | Ontology | PropertyGroup | PropertyShape;
 export declare namespace $Object {
-    function $filter(filter: $Object.$Filter, value: $Object): boolean;
-    interface $Filter {
+    const $toRdfResource: $ToRdfResourceFunction<$Object>;
+    const $filter: (filter: $Object.$Filter, value: $Object) => boolean;
+    type $Filter = {
         readonly $identifier?: $IdentifierFilter;
         readonly on?: {
-            readonly OwlOntology?: Omit<OwlOntology.$Filter, "$identifier">;
-            readonly ShaclCoreNodeShape?: Omit<ShaclCoreNodeShape.$Filter, "$identifier">;
-            readonly ShaclCorePropertyGroup?: Omit<ShaclCorePropertyGroup.$Filter, "$identifier">;
-            readonly ShaclCorePropertyShape?: Omit<ShaclCorePropertyShape.$Filter, "$identifier">;
-            readonly BaseShaclCoreShape?: Omit<BaseShaclCoreShapeStatic.$Filter, "$identifier">;
+            readonly NodeShape?: NodeShape.$Filter;
+            readonly Ontology?: Ontology.$Filter;
+            readonly PropertyGroup?: PropertyGroup.$Filter;
+            readonly PropertyShape?: PropertyShape.$Filter;
         };
-    }
+    };
+    const $fromRdfResource: $FromRdfResourceFunction<$Object>;
+    const $fromRdfResourceValues: $FromRdfResourceValuesFunction<$Object>;
     type $Identifier = BlankNode | NamedNode;
     namespace $Identifier {
         const fromString: typeof $identifierFromString;
         const toString: typeof import("rdfjs-resource/dist/Identifier.js").Identifier.toString;
     }
     const $schema: {
+        readonly kind: "NamedObjectUnion";
+        readonly members: {
+            readonly NodeShape: {
+                readonly discriminantValues: readonly ["NodeShape"];
+                readonly type: {
+                    readonly properties: {
+                        readonly $identifier: {
+                            readonly kind: "Identifier";
+                            readonly type: () => {
+                                kind: "Identifier";
+                            };
+                        };
+                        readonly $type: {
+                            readonly kind: "Discriminant";
+                            readonly type: () => {
+                                kind: "TypeDiscriminant";
+                                ownValues: string[];
+                            };
+                        };
+                        readonly and: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#and">;
+                        };
+                        readonly classes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#class">;
+                        };
+                        readonly closed: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#closed">;
+                        };
+                        readonly comments: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#comment">;
+                        };
+                        readonly datatype: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#datatype">;
+                        };
+                        readonly deactivated: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#deactivated">;
+                        };
+                        readonly 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 ignoredProperties: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Iri";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#ignoredProperties">;
+                        };
+                        readonly in_: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Term";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#in">;
+                        };
+                        readonly isDefinedBy: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#isDefinedBy">;
+                        };
+                        readonly labels: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
+                        };
+                        readonly languageIn: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "String";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#languageIn">;
+                        };
+                        readonly maxCount: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxCount">;
+                        };
+                        readonly maxExclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxExclusive">;
+                        };
+                        readonly maxInclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxInclusive">;
+                        };
+                        readonly maxLength: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxLength">;
+                        };
+                        readonly minCount: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minCount">;
+                        };
+                        readonly minExclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minExclusive">;
+                        };
+                        readonly minInclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minInclusive">;
+                        };
+                        readonly minLength: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minLength">;
+                        };
+                        readonly nodeKind: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | NamedNode<"http://www.w3.org/ns/shacl#IRI"> | NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
+                        };
+                        readonly nodes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#node">;
+                        };
+                        readonly not: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#not">;
+                        };
+                        readonly or: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#or">;
+                        };
+                        readonly patterns: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#pattern">;
+                        };
+                        readonly properties: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#property">;
+                        };
+                        readonly xone: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#xone">;
+                        };
+                    };
+                };
+            };
+            readonly Ontology: {
+                readonly discriminantValues: readonly ["Ontology"];
+                readonly type: {
+                    readonly properties: {
+                        readonly $identifier: {
+                            readonly kind: "Identifier";
+                            readonly type: () => {
+                                kind: "Identifier";
+                            };
+                        };
+                        readonly $type: {
+                            readonly kind: "Discriminant";
+                            readonly type: () => {
+                                kind: "TypeDiscriminant";
+                                ownValues: string[];
+                            };
+                        };
+                        readonly labels: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
+                        };
+                    };
+                };
+            };
+            readonly PropertyGroup: {
+                readonly discriminantValues: readonly ["PropertyGroup"];
+                readonly type: {
+                    readonly properties: {
+                        readonly $identifier: {
+                            readonly kind: "Identifier";
+                            readonly type: () => {
+                                kind: "Identifier";
+                            };
+                        };
+                        readonly $type: {
+                            readonly kind: "Discriminant";
+                            readonly type: () => {
+                                kind: "TypeDiscriminant";
+                                ownValues: string[];
+                            };
+                        };
+                        readonly comments: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#comment">;
+                        };
+                        readonly labels: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
+                        };
+                    };
+                };
+            };
+            readonly PropertyShape: {
+                readonly discriminantValues: readonly ["PropertyShape"];
+                readonly type: {
+                    readonly properties: {
+                        readonly $identifier: {
+                            readonly kind: "Identifier";
+                            readonly type: () => {
+                                kind: "Identifier";
+                            };
+                        };
+                        readonly $type: {
+                            readonly kind: "Discriminant";
+                            readonly type: () => {
+                                kind: "TypeDiscriminant";
+                                ownValues: string[];
+                            };
+                        };
+                        readonly and: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#and">;
+                        };
+                        readonly classes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#class">;
+                        };
+                        readonly comments: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#comment">;
+                        };
+                        readonly datatype: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#datatype">;
+                        };
+                        readonly deactivated: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#deactivated">;
+                        };
+                        readonly defaultValue: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Term";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#defaultValue">;
+                        };
+                        readonly descriptions: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#description">;
+                        };
+                        readonly flags: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#flags">;
+                        };
+                        readonly groups: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#group">;
+                        };
+                        readonly hasValues: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Term";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#hasValue">;
+                        };
+                        readonly in_: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Term";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#in">;
+                        };
+                        readonly isDefinedBy: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#isDefinedBy">;
+                        };
+                        readonly labels: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/2000/01/rdf-schema#label">;
+                        };
+                        readonly languageIn: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "String";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#languageIn">;
+                        };
+                        readonly maxCount: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxCount">;
+                        };
+                        readonly maxExclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxExclusive">;
+                        };
+                        readonly maxInclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxInclusive">;
+                        };
+                        readonly maxLength: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#maxLength">;
+                        };
+                        readonly minCount: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minCount">;
+                        };
+                        readonly minExclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minExclusive">;
+                        };
+                        readonly minInclusive: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Literal";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minInclusive">;
+                        };
+                        readonly minLength: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Int";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#minLength">;
+                        };
+                        readonly names: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#name">;
+                        };
+                        readonly nodeKind: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Iri";
+                                    in: (NamedNode<"http://www.w3.org/ns/shacl#BlankNode"> | NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrIRI"> | NamedNode<"http://www.w3.org/ns/shacl#BlankNodeOrLiteral"> | NamedNode<"http://www.w3.org/ns/shacl#IRI"> | NamedNode<"http://www.w3.org/ns/shacl#IRIOrLiteral"> | NamedNode<"http://www.w3.org/ns/shacl#Literal">)[];
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#nodeKind">;
+                        };
+                        readonly nodes: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#node">;
+                        };
+                        readonly not: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "Identifier";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#not">;
+                        };
+                        readonly or: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#or">;
+                        };
+                        readonly order: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Float";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#order">;
+                        };
+                        readonly path: {
+                            readonly kind: "Shacl";
+                            readonly type: () => object;
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#path">;
+                        };
+                        readonly patterns: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "String";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#pattern">;
+                        };
+                        readonly uniqueLang: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Maybe";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#uniqueLang">;
+                        };
+                        readonly xone: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "Set";
+                                item: () => {
+                                    kind: "List";
+                                    item: () => {
+                                        kind: "Identifier";
+                                    };
+                                };
+                            };
+                            readonly path: NamedNode<"http://www.w3.org/ns/shacl#xone">;
+                        };
+                    };
+                };
+            };
+        };
         readonly properties: {
             readonly labels: {
                 readonly kind: "Shacl";
@@ -1640,34 +2841,42 @@ export declare namespace $Object {
             };
         };
     };
-    function $fromRdf(resource: Resource, options?: $FromRdfOptions): Either<Error, $Object>;
-    function $toRdf(_object: $Object, _parameters?: {
-        graph?: Exclude<Quad_Graph, Variable>;
-        resourceSet?: ResourceSet;
-    }): Resource;
+    const $toRdfResourceValues: $ToRdfResourceValuesFunction<$Object>;
 }
 export interface $ObjectSet {
-    owlOntology(identifier: OwlOntology.$Identifier): Promise<Either<Error, OwlOntology>>;
-    owlOntologyCount(query?: Pick<$ObjectSet.Query<OwlOntology.$Filter, OwlOntology.$Identifier>, "filter">): Promise<Either<Error, number>>;
-    owlOntologyIdentifiers(query?: $ObjectSet.Query<OwlOntology.$Filter, OwlOntology.$Identifier>): Promise<Either<Error, readonly OwlOntology.$Identifier[]>>;
-    owlOntologies(query?: $ObjectSet.Query<OwlOntology.$Filter, OwlOntology.$Identifier>): Promise<Either<Error, readonly OwlOntology[]>>;
-    shaclCoreNodeShape(identifier: ShaclCoreNodeShape.$Identifier): Promise<Either<Error, ShaclCoreNodeShape>>;
-    shaclCoreNodeShapeCount(query?: Pick<$ObjectSet.Query<ShaclCoreNodeShape.$Filter, ShaclCoreNodeShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
-    shaclCoreNodeShapeIdentifiers(query?: $ObjectSet.Query<ShaclCoreNodeShape.$Filter, ShaclCoreNodeShape.$Identifier>): Promise<Either<Error, readonly ShaclCoreNodeShape.$Identifier[]>>;
-    shaclCoreNodeShapes(query?: $ObjectSet.Query<ShaclCoreNodeShape.$Filter, ShaclCoreNodeShape.$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: ShaclCorePropertyShape.$Identifier): Promise<Either<Error, ShaclCorePropertyShape>>;
-    shaclCorePropertyShapeCount(query?: Pick<$ObjectSet.Query<ShaclCorePropertyShape.$Filter, ShaclCorePropertyShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
-    shaclCorePropertyShapeIdentifiers(query?: $ObjectSet.Query<ShaclCorePropertyShape.$Filter, ShaclCorePropertyShape.$Identifier>): Promise<Either<Error, readonly ShaclCorePropertyShape.$Identifier[]>>;
-    shaclCorePropertyShapes(query?: $ObjectSet.Query<ShaclCorePropertyShape.$Filter, ShaclCorePropertyShape.$Identifier>): Promise<Either<Error, readonly ShaclCorePropertyShape[]>>;
-    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[]>>;
-    object(identifier: $Object.$Identifier): Promise<Either<Error, $Object>>;
+    nodeShape(identifier: NodeShape.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): Promise<Either<Error, NodeShape>>;
+    nodeShapeCount(query?: Pick<$ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    nodeShapeIdentifiers(query?: $ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>): Promise<Either<Error, readonly NodeShape.$Identifier[]>>;
+    nodeShapes(query?: $ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>): Promise<Either<Error, readonly NodeShape[]>>;
+    ontology(identifier: Ontology.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): Promise<Either<Error, Ontology>>;
+    ontologyCount(query?: Pick<$ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    ontologyIdentifiers(query?: $ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>): Promise<Either<Error, readonly Ontology.$Identifier[]>>;
+    ontologies(query?: $ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>): Promise<Either<Error, readonly Ontology[]>>;
+    propertyGroup(identifier: PropertyGroup.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): Promise<Either<Error, PropertyGroup>>;
+    propertyGroupCount(query?: Pick<$ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    propertyGroupIdentifiers(query?: $ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>): Promise<Either<Error, readonly PropertyGroup.$Identifier[]>>;
+    propertyGroups(query?: $ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>): Promise<Either<Error, readonly PropertyGroup[]>>;
+    propertyShape(identifier: PropertyShape.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): Promise<Either<Error, PropertyShape>>;
+    propertyShapeCount(query?: Pick<$ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    propertyShapeIdentifiers(query?: $ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>): Promise<Either<Error, readonly PropertyShape.$Identifier[]>>;
+    propertyShapes(query?: $ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>): Promise<Either<Error, readonly PropertyShape[]>>;
+    shape(identifier: Shape.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): Promise<Either<Error, Shape>>;
+    shapeCount(query?: Pick<$ObjectSet.Query<Shape.$Filter, Shape.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shapeIdentifiers(query?: $ObjectSet.Query<Shape.$Filter, Shape.$Identifier>): Promise<Either<Error, readonly Shape.$Identifier[]>>;
+    shapes(query?: $ObjectSet.Query<Shape.$Filter, Shape.$Identifier>): Promise<Either<Error, readonly Shape[]>>;
+    object(identifier: $Object.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): 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[]>>;
@@ -1679,6 +2888,7 @@ export declare namespace $ObjectSet {
         readonly identifiers?: readonly ObjectIdentifierT[];
         readonly limit?: number;
         readonly offset?: number;
+        readonly preferredLanguages?: readonly string[];
     }
 }
 export declare class $RdfjsDatasetObjectSet implements $ObjectSet {
@@ -1689,48 +2899,72 @@ export declare class $RdfjsDatasetObjectSet implements $ObjectSet {
     });
     protected $dataset(): DatasetCore;
     protected $resourceSet(): ResourceSet;
-    owlOntology(identifier: OwlOntology.$Identifier): Promise<Either<Error, OwlOntology>>;
-    owlOntologySync(identifier: OwlOntology.$Identifier): Either<Error, OwlOntology>;
-    owlOntologyCount(query?: Pick<$ObjectSet.Query<OwlOntology.$Filter, OwlOntology.$Identifier>, "filter">): Promise<Either<Error, number>>;
-    owlOntologyCountSync(query?: Pick<$ObjectSet.Query<OwlOntology.$Filter, OwlOntology.$Identifier>, "filter">): Either<Error, number>;
-    owlOntologyIdentifiers(query?: $ObjectSet.Query<OwlOntology.$Filter, OwlOntology.$Identifier>): Promise<Either<Error, readonly OwlOntology.$Identifier[]>>;
-    owlOntologyIdentifiersSync(query?: $ObjectSet.Query<OwlOntology.$Filter, OwlOntology.$Identifier>): Either<Error, readonly OwlOntology.$Identifier[]>;
-    owlOntologies(query?: $ObjectSet.Query<OwlOntology.$Filter, OwlOntology.$Identifier>): Promise<Either<Error, readonly OwlOntology[]>>;
-    owlOntologiesSync(query?: $ObjectSet.Query<OwlOntology.$Filter, OwlOntology.$Identifier>): Either<Error, readonly OwlOntology[]>;
-    shaclCoreNodeShape(identifier: ShaclCoreNodeShape.$Identifier): Promise<Either<Error, ShaclCoreNodeShape>>;
-    shaclCoreNodeShapeSync(identifier: ShaclCoreNodeShape.$Identifier): Either<Error, ShaclCoreNodeShape>;
-    shaclCoreNodeShapeCount(query?: Pick<$ObjectSet.Query<ShaclCoreNodeShape.$Filter, ShaclCoreNodeShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
-    shaclCoreNodeShapeCountSync(query?: Pick<$ObjectSet.Query<ShaclCoreNodeShape.$Filter, ShaclCoreNodeShape.$Identifier>, "filter">): Either<Error, number>;
-    shaclCoreNodeShapeIdentifiers(query?: $ObjectSet.Query<ShaclCoreNodeShape.$Filter, ShaclCoreNodeShape.$Identifier>): Promise<Either<Error, readonly ShaclCoreNodeShape.$Identifier[]>>;
-    shaclCoreNodeShapeIdentifiersSync(query?: $ObjectSet.Query<ShaclCoreNodeShape.$Filter, ShaclCoreNodeShape.$Identifier>): Either<Error, readonly ShaclCoreNodeShape.$Identifier[]>;
-    shaclCoreNodeShapes(query?: $ObjectSet.Query<ShaclCoreNodeShape.$Filter, ShaclCoreNodeShape.$Identifier>): Promise<Either<Error, readonly ShaclCoreNodeShape[]>>;
-    shaclCoreNodeShapesSync(query?: $ObjectSet.Query<ShaclCoreNodeShape.$Filter, ShaclCoreNodeShape.$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: ShaclCorePropertyShape.$Identifier): Promise<Either<Error, ShaclCorePropertyShape>>;
-    shaclCorePropertyShapeSync(identifier: ShaclCorePropertyShape.$Identifier): Either<Error, ShaclCorePropertyShape>;
-    shaclCorePropertyShapeCount(query?: Pick<$ObjectSet.Query<ShaclCorePropertyShape.$Filter, ShaclCorePropertyShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
-    shaclCorePropertyShapeCountSync(query?: Pick<$ObjectSet.Query<ShaclCorePropertyShape.$Filter, ShaclCorePropertyShape.$Identifier>, "filter">): Either<Error, number>;
-    shaclCorePropertyShapeIdentifiers(query?: $ObjectSet.Query<ShaclCorePropertyShape.$Filter, ShaclCorePropertyShape.$Identifier>): Promise<Either<Error, readonly ShaclCorePropertyShape.$Identifier[]>>;
-    shaclCorePropertyShapeIdentifiersSync(query?: $ObjectSet.Query<ShaclCorePropertyShape.$Filter, ShaclCorePropertyShape.$Identifier>): Either<Error, readonly ShaclCorePropertyShape.$Identifier[]>;
-    shaclCorePropertyShapes(query?: $ObjectSet.Query<ShaclCorePropertyShape.$Filter, ShaclCorePropertyShape.$Identifier>): Promise<Either<Error, readonly ShaclCorePropertyShape[]>>;
-    shaclCorePropertyShapesSync(query?: $ObjectSet.Query<ShaclCorePropertyShape.$Filter, ShaclCorePropertyShape.$Identifier>): Either<Error, readonly ShaclCorePropertyShape[]>;
-    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[]>;
-    object(identifier: $Object.$Identifier): Promise<Either<Error, $Object>>;
-    objectSync(identifier: $Object.$Identifier): Either<Error, $Object>;
+    nodeShape(identifier: NodeShape.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): Promise<Either<Error, NodeShape>>;
+    nodeShapeSync(identifier: NodeShape.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): Either<Error, NodeShape>;
+    nodeShapeCount(query?: Pick<$ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    nodeShapeCountSync(query?: Pick<$ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>, "filter">): Either<Error, number>;
+    nodeShapeIdentifiers(query?: $ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>): Promise<Either<Error, readonly NodeShape.$Identifier[]>>;
+    nodeShapeIdentifiersSync(query?: $ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>): Either<Error, readonly NodeShape.$Identifier[]>;
+    nodeShapes(query?: $ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>): Promise<Either<Error, readonly NodeShape[]>>;
+    nodeShapesSync(query?: $ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>): Either<Error, readonly NodeShape[]>;
+    ontology(identifier: Ontology.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): Promise<Either<Error, Ontology>>;
+    ontologySync(identifier: Ontology.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): Either<Error, Ontology>;
+    ontologyCount(query?: Pick<$ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    ontologyCountSync(query?: Pick<$ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>, "filter">): Either<Error, number>;
+    ontologyIdentifiers(query?: $ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>): Promise<Either<Error, readonly Ontology.$Identifier[]>>;
+    ontologyIdentifiersSync(query?: $ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>): Either<Error, readonly Ontology.$Identifier[]>;
+    ontologies(query?: $ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>): Promise<Either<Error, readonly Ontology[]>>;
+    ontologiesSync(query?: $ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>): Either<Error, readonly Ontology[]>;
+    propertyGroup(identifier: PropertyGroup.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): Promise<Either<Error, PropertyGroup>>;
+    propertyGroupSync(identifier: PropertyGroup.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): Either<Error, PropertyGroup>;
+    propertyGroupCount(query?: Pick<$ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    propertyGroupCountSync(query?: Pick<$ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>, "filter">): Either<Error, number>;
+    propertyGroupIdentifiers(query?: $ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>): Promise<Either<Error, readonly PropertyGroup.$Identifier[]>>;
+    propertyGroupIdentifiersSync(query?: $ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>): Either<Error, readonly PropertyGroup.$Identifier[]>;
+    propertyGroups(query?: $ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>): Promise<Either<Error, readonly PropertyGroup[]>>;
+    propertyGroupsSync(query?: $ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>): Either<Error, readonly PropertyGroup[]>;
+    propertyShape(identifier: PropertyShape.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): Promise<Either<Error, PropertyShape>>;
+    propertyShapeSync(identifier: PropertyShape.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): Either<Error, PropertyShape>;
+    propertyShapeCount(query?: Pick<$ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    propertyShapeCountSync(query?: Pick<$ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>, "filter">): Either<Error, number>;
+    propertyShapeIdentifiers(query?: $ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>): Promise<Either<Error, readonly PropertyShape.$Identifier[]>>;
+    propertyShapeIdentifiersSync(query?: $ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>): Either<Error, readonly PropertyShape.$Identifier[]>;
+    propertyShapes(query?: $ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>): Promise<Either<Error, readonly PropertyShape[]>>;
+    propertyShapesSync(query?: $ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>): Either<Error, readonly PropertyShape[]>;
+    shape(identifier: Shape.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): Promise<Either<Error, Shape>>;
+    shapeSync(identifier: Shape.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): Either<Error, Shape>;
+    shapeCount(query?: Pick<$ObjectSet.Query<Shape.$Filter, Shape.$Identifier>, "filter">): Promise<Either<Error, number>>;
+    shapeCountSync(query?: Pick<$ObjectSet.Query<Shape.$Filter, Shape.$Identifier>, "filter">): Either<Error, number>;
+    shapeIdentifiers(query?: $ObjectSet.Query<Shape.$Filter, Shape.$Identifier>): Promise<Either<Error, readonly Shape.$Identifier[]>>;
+    shapeIdentifiersSync(query?: $ObjectSet.Query<Shape.$Filter, Shape.$Identifier>): Either<Error, readonly Shape.$Identifier[]>;
+    shapes(query?: $ObjectSet.Query<Shape.$Filter, Shape.$Identifier>): Promise<Either<Error, readonly Shape[]>>;
+    shapesSync(query?: $ObjectSet.Query<Shape.$Filter, Shape.$Identifier>): Either<Error, readonly Shape[]>;
+    object(identifier: $Object.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): Promise<Either<Error, $Object>>;
+    objectSync(identifier: $Object.$Identifier, options?: {
+        preferredLanguages?: readonly string[];
+    }): 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[]>>;
@@ -1741,20 +2975,14 @@ export declare class $RdfjsDatasetObjectSet implements $ObjectSet {
         readonly $identifier: ObjectIdentifierT;
     }, ObjectFilterT, ObjectIdentifierT extends BlankNode | NamedNode>(objectType: {
         $filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
-        $fromRdf: (resource: Resource, options: {
-            graph?: Exclude<Quad_Graph, Variable>;
-            objectSet: $ObjectSet;
-        }) => Either<Error, ObjectT>;
+        $fromRdfResource: $FromRdfResourceFunction<ObjectT>;
         $fromRdfTypes: readonly NamedNode[];
     }, query?: $ObjectSet.Query<ObjectFilterT, ObjectIdentifierT>): Either<Error, readonly ObjectT[]>;
     protected $objectUnionsSync<ObjectT extends {
         readonly $identifier: ObjectIdentifierT;
     }, ObjectFilterT, ObjectIdentifierT extends BlankNode | NamedNode>(objectTypes: readonly {
         $filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
-        $fromRdf: (resource: Resource, options: {
-            graph?: Exclude<Quad_Graph, Variable>;
-            objectSet: $ObjectSet;
-        }) => Either<Error, ObjectT>;
+        $fromRdfResource: $FromRdfResourceFunction<ObjectT>;
         $fromRdfTypes: readonly NamedNode[];
     }[], query?: $ObjectSet.Query<ObjectFilterT, ObjectIdentifierT>): Either<Error, readonly ObjectT[]>;
 }