@shaclmate/compiler 2.0.23 → 3.0.0

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -17,7 +17,7 @@ export function sparqlObjectSetClassDeclaration({ objectTypes, objectUnionTypes,
         constructObjectType: {
             name: "objectType",
             type: `{\
-  ${syntheticNamePrefix}fromRdf: (parameters: { objectSet: ${syntheticNamePrefix}ObjectSet, resource: rdfjsResource.Resource }) => purify.Either<Error, ${typeParameters.ObjectT.name}>;
+  ${syntheticNamePrefix}fromRdf: (resource: rdfjsResource.Resource, options: { objectSet: ${syntheticNamePrefix}ObjectSet }) => purify.Either<Error, ${typeParameters.ObjectT.name}>;
   ${syntheticNamePrefix}sparqlConstructQueryString: (parameters?: { subject?: sparqljs.Triple["subject"]; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type"> & sparqljs.GeneratorOptions) => string;
   ${syntheticNamePrefix}sparqlWherePatterns: ${sparqlWherePatternsFunctionType};
 }`,
@@ -248,13 +248,13 @@ try {
   return purify.Left(e as Error);
 }
 
-const dataset: rdfjs.DatasetCore = new N3.Store(quads.concat());
+const dataset = datasetFactory.dataset(quads.concat());
 const objects: ${typeParameters.ObjectT.name}[] = [];
 for (const identifier of identifiers) {
-  const objectEither = objectType.${syntheticNamePrefix}fromRdf({
-    objectSet: this,
-    resource: new rdfjsResource.Resource<rdfjs.NamedNode>({ dataset, identifier: identifier as rdfjs.NamedNode })
-  });
+  const objectEither = objectType.${syntheticNamePrefix}fromRdf(
+    new rdfjsResource.Resource<rdfjs.NamedNode>({ dataset, identifier: identifier as rdfjs.NamedNode }),
+    { objectSet: this }
+  );
   if (objectEither.isLeft()) {
     return objectEither;
   }

package/dist/input/PropertyPath.d.ts

@@ -31,11 +31,10 @@ export interface ZeroOrOnePath {
 }
 export type PropertyPath = AlternativePath | InversePath | OneOrMorePath | PredicatePath | SequencePath | ZeroOrMorePath | ZeroOrOnePath;
 export declare namespace PropertyPath {
-    function $fromRdf({ resource, }: {
+    function $fromRdf(resource: Resource, _?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
-        languageIn?: readonly string[];
-        resource: Resource;
+        preferredLanguages?: readonly string[];
     }): Either<Error, PropertyPath>;
     function $toRdf(_propertyPath: PropertyPath, _options?: any): Resource;
 }

package/dist/input/PropertyPath.js

@@ -3,7 +3,7 @@ import { Either, Left } from "purify-ts";
 import { Resource } from "rdfjs-resource";
 export var PropertyPath;
 (function (PropertyPath) {
-    function $fromRdf({ resource, }) {
+    function $fromRdf(resource, _) {
         // Predicate path
         // sh:path ex:parent
         if (resource.identifier.termType === "NamedNode") {
@@ -18,9 +18,7 @@ export var PropertyPath;
                     if (memberResource.isNothing()) {
                         return Left(new Error(`non-identifier in property path list ${Resource.Identifier.toString(listResource.identifier)}`));
                     }
-                    const member = PropertyPath.$fromRdf({
-                        resource: memberResource.unsafeCoerce(),
-                    });
+                    const member = PropertyPath.$fromRdf(memberResource.unsafeCoerce());
                     if (member.isLeft()) {
                         return member;
                     }
@@ -52,14 +50,14 @@ export var PropertyPath;
             // Inverse path
             // sh:path: [ sh:inversePath ex:parent ]
             if (quad.predicate.equals(sh.inversePath)) {
-                return PropertyPath.$fromRdf({ resource: objectResource }).map((path) => ({
+                return PropertyPath.$fromRdf(objectResource).map((path) => ({
                     kind: "InversePath",
                     path,
                 }));
             }
             // One or more path
             if (quad.predicate.equals(sh.oneOrMorePath)) {
-                return PropertyPath.$fromRdf({ resource: objectResource }).map((path) => ({
+                return PropertyPath.$fromRdf(objectResource).map((path) => ({
                     kind: "OneOrMorePath",
                     path,
                 }));
@@ -74,13 +72,13 @@ export var PropertyPath;
             }
             // Zero or more path
             if (quad.predicate.equals(sh.zeroOrMorePath)) {
-                return PropertyPath.$fromRdf({ resource: objectResource }).map((path) => ({
+                return PropertyPath.$fromRdf(objectResource).map((path) => ({
                     kind: "ZeroOrMorePath",
                     path,
                 }));
             }
             if (quad.predicate.equals(sh.zeroOrOnePath)) {
-                return PropertyPath.$fromRdf({ resource: objectResource }).map((path) => ({
+                return PropertyPath.$fromRdf(objectResource).map((path) => ({
                     kind: "ZeroOrOnePath",
                     path,
                 }));

package/dist/input/ShapesGraph.js

@@ -10,9 +10,8 @@ export class ShapesGraph extends RdfjsShapesGraph {
             dataset,
             factory: {
                 nodeShapeFromRdf({ resource, shapesGraph, }) {
-                    return generated.ShaclmateNodeShape.$fromRdf({
+                    return generated.ShaclmateNodeShape.$fromRdf(resource, {
                         ignoreRdfType: true,
-                        resource,
                     }).map((generatedShape) => new NodeShape({
                         ancestorClassIris: ancestorClassIris(resource, Number.MAX_SAFE_INTEGER),
                         childClassIris: descendantClassIris(resource, 1),
@@ -26,21 +25,18 @@ export class ShapesGraph extends RdfjsShapesGraph {
                     }));
                 },
                 ontologyFromRdf({ resource, }) {
-                    return generated.ShaclmateOntology.$fromRdf({
+                    return generated.ShaclmateOntology.$fromRdf(resource, {
                         ignoreRdfType: true,
-                        resource,
                     }).map((generatedOntology) => new Ontology(generatedOntology));
                 },
                 propertyGroupFromRdf({ resource, }) {
-                    return generated.ShaclCorePropertyGroup.$fromRdf({
+                    return generated.ShaclCorePropertyGroup.$fromRdf(resource, {
                         ignoreRdfType: true,
-                        resource,
                     }).map((generatedPropertyGroup) => new PropertyGroup(generatedPropertyGroup));
                 },
                 propertyShapeFromRdf({ resource, shapesGraph, }) {
-                    return generated.ShaclmatePropertyShape.$fromRdf({
+                    return generated.ShaclmatePropertyShape.$fromRdf(resource, {
                         ignoreRdfType: true,
-                        resource,
                     }).map((generatedShape) => new PropertyShape(generatedShape, shapesGraph));
                 },
             },

package/dist/input/generated.d.ts

@@ -57,11 +57,17 @@ export declare namespace BaseShaclCoreShapeStatic {
         const // biome-ignore lint/suspicious/noShadowRestrictedNames:
         toString: typeof rdfjsResource.Resource.Identifier.toString;
     }
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, ...$context }: {
+    function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+    }): purify.Either<Error, BaseShaclCoreShape>;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, ...$context }: {
+        [_index: string]: any;
+        ignoreRdfType: boolean;
+        languageIn?: readonly string[];
+        objectSet: $ObjectSet;
         resource: rdfjsResource.Resource;
     }): purify.Either<Error, {
         $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
@@ -91,11 +97,10 @@ export declare namespace BaseShaclCoreShapeStatic {
         patterns: readonly string[];
         xone: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
     }>;
-    function $fromRdf(parameters: Parameters<typeof BaseShaclCoreShapeStatic.$propertiesFromRdf>[0]): purify.Either<Error, BaseShaclCoreShape>;
-    function $toRdf(_baseShaclCoreShape: BaseShaclCoreShape, { mutateGraph, resourceSet, }: {
+    function $toRdf(_baseShaclCoreShape: BaseShaclCoreShape, options?: {
         ignoreRdfType?: boolean;
         mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet: rdfjsResource.MutableResourceSet;
+        resourceSet?: rdfjsResource.MutableResourceSet;
     }): rdfjsResource.MutableResource;
     const $properties: {
         and: {
@@ -190,11 +195,17 @@ export declare namespace ShaclCorePropertyShapeStatic {
     const $fromRdfType: rdfjs.NamedNode<string>;
     type $Identifier = BaseShaclCoreShapeStatic.$Identifier;
     const $Identifier: typeof BaseShaclCoreShapeStatic.$Identifier;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, ...$context }: {
+    function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+    }): purify.Either<Error, ShaclCorePropertyShape>;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, ...$context }: {
+        [_index: string]: any;
+        ignoreRdfType: boolean;
+        languageIn?: readonly string[];
+        objectSet: $ObjectSet;
         resource: rdfjsResource.Resource;
     }): purify.Either<Error, {
         $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
@@ -207,11 +218,10 @@ export declare namespace ShaclCorePropertyShapeStatic {
         path: PropertyPath;
         uniqueLang: purify.Maybe<boolean>;
     } & $UnwrapR<ReturnType<typeof BaseShaclCoreShapeStatic.$propertiesFromRdf>>>;
-    function $fromRdf(parameters: Parameters<typeof ShaclCorePropertyShapeStatic.$propertiesFromRdf>[0]): purify.Either<Error, ShaclCorePropertyShape>;
-    function $toRdf(_shaclCorePropertyShape: ShaclCorePropertyShape, { ignoreRdfType, mutateGraph, resourceSet, }: {
+    function $toRdf(_shaclCorePropertyShape: ShaclCorePropertyShape, options?: {
         ignoreRdfType?: boolean;
         mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet: rdfjsResource.MutableResourceSet;
+        resourceSet?: rdfjsResource.MutableResourceSet;
     }): rdfjsResource.MutableResource;
     const $properties: {
         defaultValue: {
@@ -326,11 +336,17 @@ export declare namespace ShaclmatePropertyShape {
     const $fromRdfType: rdfjs.NamedNode<string>;
     type $Identifier = ShaclCorePropertyShapeStatic.$Identifier;
     const $Identifier: typeof BaseShaclCoreShapeStatic.$Identifier;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, ...$context }: {
+    function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+    }): purify.Either<Error, ShaclmatePropertyShape>;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, ...$context }: {
+        [_index: string]: any;
+        ignoreRdfType: boolean;
+        languageIn?: readonly string[];
+        objectSet: $ObjectSet;
         resource: rdfjsResource.Resource;
     }): purify.Either<Error, {
         $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
@@ -342,11 +358,10 @@ export declare namespace ShaclmatePropertyShape {
         visibility: purify.Maybe<rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_Visibility_Private" | "http://purl.org/shaclmate/ontology#_Visibility_Protected" | "http://purl.org/shaclmate/ontology#_Visibility_Public">>;
         widen: purify.Maybe<boolean>;
     } & $UnwrapR<ReturnType<typeof ShaclCorePropertyShapeStatic.$propertiesFromRdf>>>;
-    function $fromRdf(parameters: Parameters<typeof ShaclmatePropertyShape.$propertiesFromRdf>[0]): purify.Either<Error, ShaclmatePropertyShape>;
-    function $toRdf(_shaclmatePropertyShape: ShaclmatePropertyShape, { ignoreRdfType, mutateGraph, resourceSet, }: {
+    function $toRdf(_shaclmatePropertyShape: ShaclmatePropertyShape, options?: {
         ignoreRdfType?: boolean;
         mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet: rdfjsResource.MutableResourceSet;
+        resourceSet?: rdfjsResource.MutableResourceSet;
     }): rdfjsResource.MutableResource;
     const $properties: {
         lazy: {
@@ -478,22 +493,27 @@ export declare namespace OwlOntologyStatic {
         const // biome-ignore lint/suspicious/noShadowRestrictedNames:
         toString: typeof rdfjsResource.Resource.Identifier.toString;
     }
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, ...$context }: {
+    function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+    }): purify.Either<Error, OwlOntology>;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, ...$context }: {
+        [_index: string]: any;
+        ignoreRdfType: boolean;
+        languageIn?: readonly string[];
+        objectSet: $ObjectSet;
         resource: rdfjsResource.Resource;
     }): purify.Either<Error, {
         $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
         $type: "OwlOntology" | "ShaclmateOntology";
         labels: readonly rdfjs.Literal[];
     }>;
-    function $fromRdf(parameters: Parameters<typeof OwlOntologyStatic.$propertiesFromRdf>[0]): purify.Either<Error, OwlOntology>;
-    function $toRdf(_owlOntology: OwlOntology, { ignoreRdfType, mutateGraph, resourceSet, }: {
+    function $toRdf(_owlOntology: OwlOntology, options?: {
         ignoreRdfType?: boolean;
         mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet: rdfjsResource.MutableResourceSet;
+        resourceSet?: rdfjsResource.MutableResourceSet;
     }): rdfjsResource.MutableResource;
     const $properties: {
         labels: {
@@ -513,11 +533,17 @@ export declare namespace ShaclmateOntology {
     const $fromRdfType: rdfjs.NamedNode<string>;
     type $Identifier = OwlOntologyStatic.$Identifier;
     const $Identifier: typeof OwlOntologyStatic.$Identifier;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, ...$context }: {
+    function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+    }): purify.Either<Error, ShaclmateOntology>;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, ...$context }: {
+        [_index: string]: any;
+        ignoreRdfType: boolean;
+        languageIn?: readonly string[];
+        objectSet: $ObjectSet;
         resource: rdfjsResource.Resource;
     }): purify.Either<Error, {
         $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
@@ -527,11 +553,10 @@ export declare namespace ShaclmateOntology {
         tsImports: readonly string[];
         tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class" | "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface">>;
     } & $UnwrapR<ReturnType<typeof OwlOntologyStatic.$propertiesFromRdf>>>;
-    function $fromRdf(parameters: Parameters<typeof ShaclmateOntology.$propertiesFromRdf>[0]): purify.Either<Error, ShaclmateOntology>;
-    function $toRdf(_shaclmateOntology: ShaclmateOntology, { ignoreRdfType, mutateGraph, resourceSet, }: {
+    function $toRdf(_shaclmateOntology: ShaclmateOntology, options?: {
         ignoreRdfType?: boolean;
         mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet: rdfjsResource.MutableResourceSet;
+        resourceSet?: rdfjsResource.MutableResourceSet;
     }): rdfjsResource.MutableResource;
     const $properties: {
         tsFeatureExcludes: {
@@ -562,11 +587,17 @@ export declare namespace ShaclCoreNodeShapeStatic {
     const $fromRdfType: rdfjs.NamedNode<string>;
     type $Identifier = BaseShaclCoreShapeStatic.$Identifier;
     const $Identifier: typeof BaseShaclCoreShapeStatic.$Identifier;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, ...$context }: {
+    function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+    }): purify.Either<Error, ShaclCoreNodeShape>;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, ...$context }: {
+        [_index: string]: any;
+        ignoreRdfType: boolean;
+        languageIn?: readonly string[];
+        objectSet: $ObjectSet;
         resource: rdfjsResource.Resource;
     }): purify.Either<Error, {
         $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
@@ -575,11 +606,10 @@ export declare namespace ShaclCoreNodeShapeStatic {
         ignoredProperties: purify.Maybe<readonly rdfjs.NamedNode[]>;
         properties: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
     } & $UnwrapR<ReturnType<typeof BaseShaclCoreShapeStatic.$propertiesFromRdf>>>;
-    function $fromRdf(parameters: Parameters<typeof ShaclCoreNodeShapeStatic.$propertiesFromRdf>[0]): purify.Either<Error, ShaclCoreNodeShape>;
-    function $toRdf(_shaclCoreNodeShape: ShaclCoreNodeShape, { ignoreRdfType, mutateGraph, resourceSet, }: {
+    function $toRdf(_shaclCoreNodeShape: ShaclCoreNodeShape, options?: {
         ignoreRdfType?: boolean;
         mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet: rdfjsResource.MutableResourceSet;
+        resourceSet?: rdfjsResource.MutableResourceSet;
     }): rdfjsResource.MutableResource;
     const $properties: {
         closed: {
@@ -689,11 +719,17 @@ export declare namespace ShaclmateNodeShape {
     const $fromRdfType: rdfjs.NamedNode<string>;
     type $Identifier = ShaclCoreNodeShapeStatic.$Identifier;
     const $Identifier: typeof BaseShaclCoreShapeStatic.$Identifier;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, ...$context }: {
+    function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+    }): purify.Either<Error, ShaclmateNodeShape>;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, ...$context }: {
+        [_index: string]: any;
+        ignoreRdfType: boolean;
+        languageIn?: readonly string[];
+        objectSet: $ObjectSet;
         resource: rdfjsResource.Resource;
     }): purify.Either<Error, {
         $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
@@ -712,11 +748,10 @@ export declare namespace ShaclmateNodeShape {
         tsImports: readonly string[];
         tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class" | "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface">>;
     } & $UnwrapR<ReturnType<typeof ShaclCoreNodeShapeStatic.$propertiesFromRdf>>>;
-    function $fromRdf(parameters: Parameters<typeof ShaclmateNodeShape.$propertiesFromRdf>[0]): purify.Either<Error, ShaclmateNodeShape>;
-    function $toRdf(_shaclmateNodeShape: ShaclmateNodeShape, { ignoreRdfType, mutateGraph, resourceSet, }: {
+    function $toRdf(_shaclmateNodeShape: ShaclmateNodeShape, options?: {
         ignoreRdfType?: boolean;
         mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet: rdfjsResource.MutableResourceSet;
+        resourceSet?: rdfjsResource.MutableResourceSet;
     }): rdfjsResource.MutableResource;
     const $properties: {
         abstract: {
@@ -858,11 +893,17 @@ export declare namespace ShaclCorePropertyGroup {
         const // biome-ignore lint/suspicious/noShadowRestrictedNames:
         toString: typeof rdfjsResource.Resource.Identifier.toString;
     }
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSetParameter, resource: $resource, ...$context }: {
+    function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+    }): purify.Either<Error, ShaclCorePropertyGroup>;
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, ...$context }: {
+        [_index: string]: any;
+        ignoreRdfType: boolean;
+        languageIn?: readonly string[];
+        objectSet: $ObjectSet;
         resource: rdfjsResource.Resource;
     }): purify.Either<Error, {
         $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
@@ -870,11 +911,10 @@ export declare namespace ShaclCorePropertyGroup {
         comments: readonly rdfjs.Literal[];
         labels: readonly rdfjs.Literal[];
     }>;
-    function $fromRdf(parameters: Parameters<typeof ShaclCorePropertyGroup.$propertiesFromRdf>[0]): purify.Either<Error, ShaclCorePropertyGroup>;
-    function $toRdf(_shaclCorePropertyGroup: ShaclCorePropertyGroup, { ignoreRdfType, mutateGraph, resourceSet, }: {
+    function $toRdf(_shaclCorePropertyGroup: ShaclCorePropertyGroup, options?: {
         ignoreRdfType?: boolean;
         mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet: rdfjsResource.MutableResourceSet;
+        resourceSet?: rdfjsResource.MutableResourceSet;
     }): rdfjsResource.MutableResource;
     const $properties: {
         comments: {
@@ -887,10 +927,11 @@ export declare namespace ShaclCorePropertyGroup {
 }
 export type ShaclCoreShape = ShaclCoreNodeShape | ShaclCorePropertyShape;
 export declare namespace ShaclCoreShape {
-    function $fromRdf({ ignoreRdfType, resource, ...context }: {
+    function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
-        resource: rdfjsResource.Resource;
+        languageIn?: readonly string[];
+        objectSet?: $ObjectSet;
     }): purify.Either<Error, ShaclCoreShape>;
     type $Identifier = rdfjs.BlankNode | rdfjs.NamedNode;
     namespace $Identifier {
@@ -898,17 +939,18 @@ export declare namespace ShaclCoreShape {
         const // biome-ignore lint/suspicious/noShadowRestrictedNames:
         toString: typeof rdfjsResource.Resource.Identifier.toString;
     }
-    function $toRdf(_shaclCoreShape: ShaclCoreShape, _parameters: {
-        mutateGraph: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet: rdfjsResource.MutableResourceSet;
+    function $toRdf(_shaclCoreShape: ShaclCoreShape, _parameters?: {
+        mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
+        resourceSet?: rdfjsResource.MutableResourceSet;
     }): rdfjsResource.MutableResource;
 }
 export type ShaclmateShape = ShaclmateNodeShape | ShaclCorePropertyShape;
 export declare namespace ShaclmateShape {
-    function $fromRdf({ ignoreRdfType, resource, ...context }: {
+    function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
-        resource: rdfjsResource.Resource;
+        languageIn?: readonly string[];
+        objectSet?: $ObjectSet;
     }): purify.Either<Error, ShaclmateShape>;
     type $Identifier = rdfjs.BlankNode | rdfjs.NamedNode;
     namespace $Identifier {
@@ -916,9 +958,9 @@ export declare namespace ShaclmateShape {
         const // biome-ignore lint/suspicious/noShadowRestrictedNames:
         toString: typeof rdfjsResource.Resource.Identifier.toString;
     }
-    function $toRdf(_shaclmateShape: ShaclmateShape, _parameters: {
-        mutateGraph: rdfjsResource.MutableResource.MutateGraph;
-        resourceSet: rdfjsResource.MutableResourceSet;
+    function $toRdf(_shaclmateShape: ShaclmateShape, _parameters?: {
+        mutateGraph?: rdfjsResource.MutableResource.MutateGraph;
+        resourceSet?: rdfjsResource.MutableResourceSet;
     }): rdfjsResource.MutableResource;
 }
 export interface $ObjectSet {
@@ -1054,48 +1096,48 @@ export declare class $RdfjsDatasetObjectSet implements $ObjectSet {
     protected $objectIdentifiersSync<ObjectT extends {
         readonly $identifier: ObjectIdentifierT;
     }, ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode>(objectType: {
-        $fromRdf: (parameters: {
-            resource: rdfjsResource.Resource;
+        $fromRdf: (resource: rdfjsResource.Resource, options: {
+            objectSet: $ObjectSet;
         }) => purify.Either<Error, ObjectT>;
         $fromRdfType?: rdfjs.NamedNode;
     }, query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, readonly ObjectIdentifierT[]>;
     protected $objectsSync<ObjectT extends {
         readonly $identifier: ObjectIdentifierT;
     }, ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode>(objectType: {
-        $fromRdf: (parameters: {
-            resource: rdfjsResource.Resource;
+        $fromRdf: (resource: rdfjsResource.Resource, options: {
+            objectSet: $ObjectSet;
         }) => purify.Either<Error, ObjectT>;
         $fromRdfType?: rdfjs.NamedNode;
     }, query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, readonly ObjectT[]>;
     protected $objectsCountSync<ObjectT extends {
         readonly $identifier: ObjectIdentifierT;
     }, ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode>(objectType: {
-        $fromRdf: (parameters: {
-            resource: rdfjsResource.Resource;
+        $fromRdf: (resource: rdfjsResource.Resource, options: {
+            objectSet: $ObjectSet;
         }) => purify.Either<Error, ObjectT>;
         $fromRdfType?: rdfjs.NamedNode;
     }, query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, number>;
     protected $objectUnionIdentifiersSync<ObjectT extends {
         readonly $identifier: ObjectIdentifierT;
     }, ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode>(objectTypes: readonly {
-        $fromRdf: (parameters: {
-            resource: rdfjsResource.Resource;
+        $fromRdf: (resource: rdfjsResource.Resource, options: {
+            objectSet: $ObjectSet;
         }) => purify.Either<Error, ObjectT>;
         $fromRdfType?: rdfjs.NamedNode;
     }[], query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, readonly ObjectIdentifierT[]>;
     protected $objectUnionsSync<ObjectT extends {
         readonly $identifier: ObjectIdentifierT;
     }, ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode>(objectTypes: readonly {
-        $fromRdf: (parameters: {
-            resource: rdfjsResource.Resource;
+        $fromRdf: (resource: rdfjsResource.Resource, options: {
+            objectSet: $ObjectSet;
         }) => purify.Either<Error, ObjectT>;
         $fromRdfType?: rdfjs.NamedNode;
     }[], query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, readonly ObjectT[]>;
     protected $objectUnionsCountSync<ObjectT extends {
         readonly $identifier: ObjectIdentifierT;
     }, ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode>(objectTypes: readonly {
-        $fromRdf: (parameters: {
-            resource: rdfjsResource.Resource;
+        $fromRdf: (resource: rdfjsResource.Resource, options: {
+            objectSet: $ObjectSet;
         }) => purify.Either<Error, ObjectT>;
         $fromRdfType?: rdfjs.NamedNode;
     }[], query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, number>;