@shaclmate/compiler 3.0.2 → 3.0.3

package/dist/generators/ts/BooleanType.js

@@ -61,10 +61,10 @@ export class BooleanType extends PrimitiveType {
             .map((defaultValue) => {
             if (defaultValue) {
                 // If the default is true, only serialize the value if it's false
-                return `!${variables.value} ? false : undefined`;
+                return `(!${variables.value} ? [false] : [])`;
             }
             // If the default is false, only serialize the value if it's true
-            return `${variables.value} ? true : undefined`;
+            return `(${variables.value} ? [true] : [])`;
         })
             .orDefault(variables.value);
     }

package/dist/generators/ts/DateTimeType.js

@@ -80,8 +80,8 @@ export class DateTimeType extends PrimitiveType {
     toRdfExpression({ variables, }) {
         const valueToRdf = `rdfLiteral.toRdf(${variables.value}, ${objectInitializer({ dataFactory: "dataFactory", datatype: rdfjsTermExpression(this.xsdDatatype) })})`;
         return this.primitiveDefaultValue
-            .map((defaultValue) => `${variables.value}.getTime() !== ${defaultValue.getTime()} ? ${valueToRdf} : undefined`)
-            .orDefault(valueToRdf);
+            .map((defaultValue) => `(${variables.value}.getTime() !== ${defaultValue.getTime()} ? [${valueToRdf}] : [])`)
+            .orDefault(`[${valueToRdf}]`);
     }
 }
 __decorate([

package/dist/generators/ts/ListType.js

@@ -289,7 +289,7 @@ export class ListType extends Type {
                 break;
             }
         }
-        return `${variables.value}.length > 0 ? ${variables.value}.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+        return `[${variables.value}.length > 0 ? ${variables.value}.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
     if (itemIndex === 0) {
       currentSubListResource = listResource;
     } else {
@@ -302,7 +302,7 @@ export class ListType extends Type {
     
     ${this.toRdfTypes.map((rdfType) => `currentSubListResource.add(${rdfjsTermExpression(rdf.type)}, dataFactory.namedNode("${rdfType.value}"))`).join("\n")}
         
-    currentSubListResource.add(${rdfjsTermExpression(rdf.first)}, ${this.itemType.toRdfExpression({ variables: { mutateGraph: variables.mutateGraph, predicate: rdfjsTermExpression(rdf.first), resource: "currentSubListResource", resourceSet: variables.resourceSet, value: "item" } })});
+    currentSubListResource.add(${rdfjsTermExpression(rdf.first)}, ...${this.itemType.toRdfExpression({ variables: { mutateGraph: variables.mutateGraph, predicate: rdfjsTermExpression(rdf.first), resource: "currentSubListResource", resourceSet: variables.resourceSet, value: "item" } })});
 
     if (itemIndex + 1 === list.length) {
       currentSubListResource.add(${rdfjsTermExpression(rdf.rest)}, ${rdfjsTermExpression(rdf.nil)});
@@ -319,7 +319,7 @@ export class ListType extends Type {
     currentSubListResource: ${mutableResourceTypeName} | null;
     listResource: ${mutableResourceTypeName};
   },
-).listResource.identifier : ${rdfjsTermExpression(rdf.nil)}`;
+).listResource.identifier : ${rdfjsTermExpression(rdf.nil)}]`;
     }
     useImports(parameters) {
         const imports = this.itemType.useImports(parameters).concat();

package/dist/generators/ts/NumberType.js

@@ -58,8 +58,8 @@ export class NumberType extends PrimitiveType {
     }
     toRdfExpression({ variables, }) {
         return this.primitiveDefaultValue
-            .map((defaultValue) => `${variables.value} !== ${defaultValue} ? ${variables.value} : undefined`)
-            .orDefault(variables.value);
+            .map((defaultValue) => `(${variables.value} !== ${defaultValue} ? [${variables.value}] : [])`)
+            .orDefault(`[${variables.value}]`);
     }
 }
 __decorate([

package/dist/generators/ts/ObjectType.js

@@ -322,9 +322,9 @@ export class ObjectType extends DeclaredType {
     toRdfExpression({ variables, }) {
         switch (this.declarationType) {
             case "class":
-                return `${variables.value}.${syntheticNamePrefix}toRdf({ mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} })`;
+                return `[${variables.value}.${syntheticNamePrefix}toRdf({ mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} }).identifier]`;
             case "interface":
-                return `${this.staticModuleName}.${syntheticNamePrefix}toRdf(${variables.value}, { mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} })`;
+                return `[${this.staticModuleName}.${syntheticNamePrefix}toRdf(${variables.value}, { mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} }).identifier]`;
         }
     }
     useImports() {

package/dist/generators/ts/ObjectUnionType.js

@@ -621,9 +621,9 @@ return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right
         const options = `{ mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} }`;
         switch (this.memberTypes[0].declarationType) {
             case "class":
-                return `${variables.value}.${syntheticNamePrefix}toRdf(${options})`;
+                return `[${variables.value}.${syntheticNamePrefix}toRdf(${options}).identifier]`;
             case "interface":
-                return `${this.staticModuleName}.${syntheticNamePrefix}toRdf(${variables.value}, ${options})`;
+                return `[${this.staticModuleName}.${syntheticNamePrefix}toRdf(${variables.value}, ${options}).identifier]`;
         }
     }
     useImports() {

package/dist/generators/ts/OptionType.js

@@ -137,10 +137,11 @@ export class OptionType extends Type {
         const itemTypeToRdfExpression = this.itemType.toRdfExpression({
             variables: { ...variables, value: "value" },
         });
-        if (itemTypeToRdfExpression === "value") {
-            return variables.value;
+        let toRdfExpression = `${variables.value}.toList()`;
+        if (itemTypeToRdfExpression !== "[value]") {
+            toRdfExpression = `${toRdfExpression}.flatMap((value) => ${itemTypeToRdfExpression})`;
         }
-        return `${variables.value}.map((value) => ${itemTypeToRdfExpression})`;
+        return toRdfExpression;
     }
     useImports(parameters) {
         return [...this.itemType.useImports(parameters), Import.PURIFY];

package/dist/generators/ts/SetType.js

@@ -166,7 +166,7 @@ export class SetType extends Type {
         return `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: "item" } })}))`;
     }
     toRdfExpression({ variables, }) {
-        return `${variables.value}.map((item) => ${this.itemType.toRdfExpression({
+        return `${variables.value}.flatMap((item) => ${this.itemType.toRdfExpression({
             variables: { ...variables, value: "item" },
         })})`;
     }

package/dist/generators/ts/StringType.js

@@ -67,8 +67,8 @@ export class StringType extends PrimitiveType {
     }
     toRdfExpression({ variables, }) {
         return this.primitiveDefaultValue
-            .map((defaultValue) => `${variables.value} !== "${defaultValue}" ? ${variables.value} : undefined`)
-            .orDefault(variables.value);
+            .map((defaultValue) => `(${variables.value} !== "${defaultValue}" ? [${variables.value}] : [])`)
+            .orDefault(`[${variables.value}]`);
     }
 }
 __decorate([

package/dist/generators/ts/TermType.js

@@ -252,8 +252,8 @@ export class TermType extends Type {
     }
     toRdfExpression({ variables, }) {
         return this.defaultValue
-            .map((defaultValue) => `!${variables.value}.equals(${rdfjsTermExpression(defaultValue)}) ? ${variables.value} : undefined`)
-            .orDefault(variables.value);
+            .map((defaultValue) => `(!${variables.value}.equals(${rdfjsTermExpression(defaultValue)}) ? [${variables.value}] : [])`)
+            .orDefault(`[${variables.value}]`);
     }
     useImports() {
         const imports = [Import.RDFJS_TYPES];

package/dist/generators/ts/Type.d.ts

@@ -184,8 +184,8 @@ export declare abstract class Type {
         };
     }): string;
     /**
-     * An expression that converts a property value of this type to one that that can be .add'd to
-     * an rdfjsResource.Resource.
+     * An expression that converts a property value of this type to an array of values that can be .add'd to a rdfjsResource.MutableResource
+     * (BlankNode | Literal | NamedNode | boolean | number | string)[].
      */
     abstract toRdfExpression(parameters: {
         variables: {

package/dist/generators/ts/UnionType.js

@@ -374,12 +374,12 @@ ${this.memberTypes
     }
     toRdfExpression({ variables, }) {
         return this.ternaryExpression({
-            memberTypeExpression: (memberType) => memberType.toRdfExpression({
+            memberTypeExpression: (memberType) => `(${memberType.toRdfExpression({
                 variables: {
                     ...variables,
                     value: memberType.payload(variables.value),
                 },
-            }),
+            })} as readonly Parameters<rdfjsResource.MutableResource["add"]>[1][])`,
             variables,
         });
     }
@@ -400,9 +400,13 @@ ${this.memberTypes
             if (expression.length === 0) {
                 return memberTypeExpression(memberType);
             }
+            const memberTypeExpression_ = memberTypeExpression(memberType);
+            if (memberTypeExpression_ === expression) {
+                return expression;
+            }
             return `(${memberType.discriminatorValues
                 .map((value) => `${this.discriminatorVariable(variables.value)} === "${value}"`)
-                .join(" || ")}) ? ${memberTypeExpression(memberType)} : ${expression}`;
+                .join(" || ")}) ? ${memberTypeExpression_} : ${expression}`;
         }, "");
     }
 }

package/dist/generators/ts/_ObjectType/ShaclProperty.js

@@ -183,7 +183,7 @@ export class ShaclProperty extends Property {
     }
     toRdfStatements({ variables, }) {
         return [
-            `${variables.resource}.add(${this.predicate}, ${this.type.toRdfExpression({
+            `${variables.resource}.add(${this.predicate}, ...${this.type.toRdfExpression({
                 variables: { ...variables, predicate: this.predicate },
             })});`,
         ];

package/dist/generators/ts/_ObjectType/rdfFunctionDeclarations.js

@@ -71,6 +71,12 @@ function propertiesFromRdfFunctionDeclaration() {
     this.fromRdfType.ifJust((fromRdfType) => {
         const fromRdfTypeVariable = this.fromRdfTypeVariable.unsafeCoerce();
         const predicate = rdfjsTermExpression(rdf.type);
+        // Check the expected type and its known subtypes
+        const cases = new Set();
+        cases.add(fromRdfType.value);
+        for (const descendantFromRdfType of this.descendantFromRdfTypes) {
+            cases.add(descendantFromRdfType.value);
+        }
         statements.push(`\
 if (!${variables.ignoreRdfType}) {
   const ${syntheticNamePrefix}rdfTypeCheck: purify.Either<Error, true> = ${variables.resource}.value(${predicate})
@@ -78,7 +84,7 @@ if (!${variables.ignoreRdfType}) {
     .chain((actualRdfType) => {
       // Check the expected type and its known subtypes
       switch (actualRdfType.value) {
-        ${[`case "${fromRdfType.value}":`].concat(this.descendantFromRdfTypes.map((descendantFromRdfType) => `case "${descendantFromRdfType.value}":`)).join("\n")}
+        ${[...cases].map((fromRdfType) => `case "${fromRdfType}":`).join("\n")}
           return purify.Either.of(true);
       }
 

package/dist/input/generated.d.ts

@@ -1,6 +1,4 @@
-import type * as rdfjs from "@rdfjs/types";
-import * as purify from "purify-ts";
-import * as rdfjsResource from "rdfjs-resource";
+import { purify, type rdfjs, rdfjsResource } from "@shaclmate/runtime";
 import { PropertyPath } from "./PropertyPath.js";
 export declare namespace $RdfVocabularies {
     namespace rdf {
@@ -60,14 +58,14 @@ export declare namespace BaseShaclCoreShapeStatic {
     function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
-        languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+        preferredLanguages?: readonly string[];
     }): purify.Either<Error, BaseShaclCoreShape>;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, ...$context }: {
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, ...$context }: {
         [_index: string]: any;
         ignoreRdfType: boolean;
-        languageIn?: readonly string[];
         objectSet: $ObjectSet;
+        preferredLanguages?: readonly string[];
         resource: rdfjsResource.Resource;
     }): purify.Either<Error, {
         $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
@@ -198,14 +196,14 @@ export declare namespace ShaclCorePropertyShapeStatic {
     function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
-        languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+        preferredLanguages?: readonly string[];
     }): purify.Either<Error, ShaclCorePropertyShape>;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, ...$context }: {
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, ...$context }: {
         [_index: string]: any;
         ignoreRdfType: boolean;
-        languageIn?: readonly string[];
         objectSet: $ObjectSet;
+        preferredLanguages?: readonly string[];
         resource: rdfjsResource.Resource;
     }): purify.Either<Error, {
         $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
@@ -339,14 +337,14 @@ export declare namespace ShaclmatePropertyShape {
     function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
-        languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+        preferredLanguages?: readonly string[];
     }): purify.Either<Error, ShaclmatePropertyShape>;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, ...$context }: {
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, ...$context }: {
         [_index: string]: any;
         ignoreRdfType: boolean;
-        languageIn?: readonly string[];
         objectSet: $ObjectSet;
+        preferredLanguages?: readonly string[];
         resource: rdfjsResource.Resource;
     }): purify.Either<Error, {
         $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
@@ -496,14 +494,14 @@ export declare namespace OwlOntologyStatic {
     function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
-        languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+        preferredLanguages?: readonly string[];
     }): purify.Either<Error, OwlOntology>;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, ...$context }: {
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, ...$context }: {
         [_index: string]: any;
         ignoreRdfType: boolean;
-        languageIn?: readonly string[];
         objectSet: $ObjectSet;
+        preferredLanguages?: readonly string[];
         resource: rdfjsResource.Resource;
     }): purify.Either<Error, {
         $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
@@ -536,14 +534,14 @@ export declare namespace ShaclmateOntology {
     function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
-        languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+        preferredLanguages?: readonly string[];
     }): purify.Either<Error, ShaclmateOntology>;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, ...$context }: {
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, ...$context }: {
         [_index: string]: any;
         ignoreRdfType: boolean;
-        languageIn?: readonly string[];
         objectSet: $ObjectSet;
+        preferredLanguages?: readonly string[];
         resource: rdfjsResource.Resource;
     }): purify.Either<Error, {
         $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
@@ -590,14 +588,14 @@ export declare namespace ShaclCoreNodeShapeStatic {
     function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
-        languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+        preferredLanguages?: readonly string[];
     }): purify.Either<Error, ShaclCoreNodeShape>;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, ...$context }: {
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, ...$context }: {
         [_index: string]: any;
         ignoreRdfType: boolean;
-        languageIn?: readonly string[];
         objectSet: $ObjectSet;
+        preferredLanguages?: readonly string[];
         resource: rdfjsResource.Resource;
     }): purify.Either<Error, {
         $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
@@ -722,14 +720,14 @@ export declare namespace ShaclmateNodeShape {
     function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
-        languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+        preferredLanguages?: readonly string[];
     }): purify.Either<Error, ShaclmateNodeShape>;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, ...$context }: {
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, ...$context }: {
         [_index: string]: any;
         ignoreRdfType: boolean;
-        languageIn?: readonly string[];
         objectSet: $ObjectSet;
+        preferredLanguages?: readonly string[];
         resource: rdfjsResource.Resource;
     }): purify.Either<Error, {
         $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
@@ -896,14 +894,14 @@ export declare namespace ShaclCorePropertyGroup {
     function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
-        languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+        preferredLanguages?: readonly string[];
     }): purify.Either<Error, ShaclCorePropertyGroup>;
-    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, languageIn: $languageIn, objectSet: $objectSet, resource: $resource, ...$context }: {
+    function $propertiesFromRdf({ ignoreRdfType: $ignoreRdfType, objectSet: $objectSet, preferredLanguages: $preferredLanguages, resource: $resource, ...$context }: {
         [_index: string]: any;
         ignoreRdfType: boolean;
-        languageIn?: readonly string[];
         objectSet: $ObjectSet;
+        preferredLanguages?: readonly string[];
         resource: rdfjsResource.Resource;
     }): purify.Either<Error, {
         $identifier: rdfjs.BlankNode | rdfjs.NamedNode;
@@ -930,8 +928,8 @@ export declare namespace ShaclCoreShape {
     function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
-        languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+        preferredLanguages?: readonly string[];
     }): purify.Either<Error, ShaclCoreShape>;
     type $Identifier = rdfjs.BlankNode | rdfjs.NamedNode;
     namespace $Identifier {
@@ -949,8 +947,8 @@ export declare namespace ShaclmateShape {
     function $fromRdf(resource: rdfjsResource.Resource, options?: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
-        languageIn?: readonly string[];
         objectSet?: $ObjectSet;
+        preferredLanguages?: readonly string[];
     }): purify.Either<Error, ShaclmateShape>;
     type $Identifier = rdfjs.BlankNode | rdfjs.NamedNode;
     namespace $Identifier {
@@ -1016,6 +1014,45 @@ export declare namespace $ObjectSet {
         readonly type: "triple-objects";
     };
 }
+export declare abstract class $ForwardingObjectSet implements $ObjectSet {
+    protected abstract get $delegate(): $ObjectSet;
+    owlOntology(identifier: OwlOntologyStatic.$Identifier): Promise<purify.Either<Error, OwlOntology>>;
+    owlOntologyIdentifiers(query?: $ObjectSet.Query<OwlOntologyStatic.$Identifier>): Promise<purify.Either<Error, readonly OwlOntologyStatic.$Identifier[]>>;
+    owlOntologies(query?: $ObjectSet.Query<OwlOntologyStatic.$Identifier>): Promise<purify.Either<Error, readonly OwlOntology[]>>;
+    owlOntologiesCount(query?: Pick<$ObjectSet.Query<OwlOntologyStatic.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
+    shaclCoreNodeShape(identifier: ShaclCoreNodeShapeStatic.$Identifier): Promise<purify.Either<Error, ShaclCoreNodeShape>>;
+    shaclCoreNodeShapeIdentifiers(query?: $ObjectSet.Query<ShaclCoreNodeShapeStatic.$Identifier>): Promise<purify.Either<Error, readonly ShaclCoreNodeShapeStatic.$Identifier[]>>;
+    shaclCoreNodeShapes(query?: $ObjectSet.Query<ShaclCoreNodeShapeStatic.$Identifier>): Promise<purify.Either<Error, readonly ShaclCoreNodeShape[]>>;
+    shaclCoreNodeShapesCount(query?: Pick<$ObjectSet.Query<ShaclCoreNodeShapeStatic.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
+    shaclCorePropertyGroup(identifier: ShaclCorePropertyGroup.$Identifier): Promise<purify.Either<Error, ShaclCorePropertyGroup>>;
+    shaclCorePropertyGroupIdentifiers(query?: $ObjectSet.Query<ShaclCorePropertyGroup.$Identifier>): Promise<purify.Either<Error, readonly ShaclCorePropertyGroup.$Identifier[]>>;
+    shaclCorePropertyGroups(query?: $ObjectSet.Query<ShaclCorePropertyGroup.$Identifier>): Promise<purify.Either<Error, readonly ShaclCorePropertyGroup[]>>;
+    shaclCorePropertyGroupsCount(query?: Pick<$ObjectSet.Query<ShaclCorePropertyGroup.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
+    shaclCorePropertyShape(identifier: ShaclCorePropertyShapeStatic.$Identifier): Promise<purify.Either<Error, ShaclCorePropertyShape>>;
+    shaclCorePropertyShapeIdentifiers(query?: $ObjectSet.Query<ShaclCorePropertyShapeStatic.$Identifier>): Promise<purify.Either<Error, readonly ShaclCorePropertyShapeStatic.$Identifier[]>>;
+    shaclCorePropertyShapes(query?: $ObjectSet.Query<ShaclCorePropertyShapeStatic.$Identifier>): Promise<purify.Either<Error, readonly ShaclCorePropertyShape[]>>;
+    shaclCorePropertyShapesCount(query?: Pick<$ObjectSet.Query<ShaclCorePropertyShapeStatic.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
+    shaclmateNodeShape(identifier: ShaclmateNodeShape.$Identifier): Promise<purify.Either<Error, ShaclmateNodeShape>>;
+    shaclmateNodeShapeIdentifiers(query?: $ObjectSet.Query<ShaclmateNodeShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateNodeShape.$Identifier[]>>;
+    shaclmateNodeShapes(query?: $ObjectSet.Query<ShaclmateNodeShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateNodeShape[]>>;
+    shaclmateNodeShapesCount(query?: Pick<$ObjectSet.Query<ShaclmateNodeShape.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
+    shaclmateOntology(identifier: ShaclmateOntology.$Identifier): Promise<purify.Either<Error, ShaclmateOntology>>;
+    shaclmateOntologyIdentifiers(query?: $ObjectSet.Query<ShaclmateOntology.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateOntology.$Identifier[]>>;
+    shaclmateOntologies(query?: $ObjectSet.Query<ShaclmateOntology.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateOntology[]>>;
+    shaclmateOntologiesCount(query?: Pick<$ObjectSet.Query<ShaclmateOntology.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
+    shaclmatePropertyShape(identifier: ShaclmatePropertyShape.$Identifier): Promise<purify.Either<Error, ShaclmatePropertyShape>>;
+    shaclmatePropertyShapeIdentifiers(query?: $ObjectSet.Query<ShaclmatePropertyShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmatePropertyShape.$Identifier[]>>;
+    shaclmatePropertyShapes(query?: $ObjectSet.Query<ShaclmatePropertyShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmatePropertyShape[]>>;
+    shaclmatePropertyShapesCount(query?: Pick<$ObjectSet.Query<ShaclmatePropertyShape.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
+    shaclCoreShape(identifier: ShaclCoreShape.$Identifier): Promise<purify.Either<Error, ShaclCoreShape>>;
+    shaclCoreShapeIdentifiers(query?: $ObjectSet.Query<ShaclCoreShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclCoreShape.$Identifier[]>>;
+    shaclCoreShapes(query?: $ObjectSet.Query<ShaclCoreShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclCoreShape[]>>;
+    shaclCoreShapesCount(query?: Pick<$ObjectSet.Query<ShaclCoreShape.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
+    shaclmateShape(identifier: ShaclmateShape.$Identifier): Promise<purify.Either<Error, ShaclmateShape>>;
+    shaclmateShapeIdentifiers(query?: $ObjectSet.Query<ShaclmateShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateShape.$Identifier[]>>;
+    shaclmateShapes(query?: $ObjectSet.Query<ShaclmateShape.$Identifier>): Promise<purify.Either<Error, readonly ShaclmateShape[]>>;
+    shaclmateShapesCount(query?: Pick<$ObjectSet.Query<ShaclmateShape.$Identifier>, "where">): Promise<purify.Either<Error, number>>;
+}
 export declare class $RdfjsDatasetObjectSet implements $ObjectSet {
     readonly resourceSet: rdfjsResource.ResourceSet;
     constructor({ dataset }: {
@@ -1099,7 +1136,7 @@ export declare class $RdfjsDatasetObjectSet implements $ObjectSet {
         $fromRdf: (resource: rdfjsResource.Resource, options: {
             objectSet: $ObjectSet;
         }) => purify.Either<Error, ObjectT>;
-        $fromRdfType?: rdfjs.NamedNode;
+        $fromRdfTypes: readonly rdfjs.NamedNode[];
     }, query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, readonly ObjectIdentifierT[]>;
     protected $objectsSync<ObjectT extends {
         readonly $identifier: ObjectIdentifierT;
@@ -1107,7 +1144,7 @@ export declare class $RdfjsDatasetObjectSet implements $ObjectSet {
         $fromRdf: (resource: rdfjsResource.Resource, options: {
             objectSet: $ObjectSet;
         }) => purify.Either<Error, ObjectT>;
-        $fromRdfType?: rdfjs.NamedNode;
+        $fromRdfTypes: readonly rdfjs.NamedNode[];
     }, query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, readonly ObjectT[]>;
     protected $objectsCountSync<ObjectT extends {
         readonly $identifier: ObjectIdentifierT;
@@ -1115,7 +1152,7 @@ export declare class $RdfjsDatasetObjectSet implements $ObjectSet {
         $fromRdf: (resource: rdfjsResource.Resource, options: {
             objectSet: $ObjectSet;
         }) => purify.Either<Error, ObjectT>;
-        $fromRdfType?: rdfjs.NamedNode;
+        $fromRdfTypes: readonly rdfjs.NamedNode[];
     }, query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, number>;
     protected $objectUnionIdentifiersSync<ObjectT extends {
         readonly $identifier: ObjectIdentifierT;
@@ -1123,7 +1160,7 @@ export declare class $RdfjsDatasetObjectSet implements $ObjectSet {
         $fromRdf: (resource: rdfjsResource.Resource, options: {
             objectSet: $ObjectSet;
         }) => purify.Either<Error, ObjectT>;
-        $fromRdfType?: rdfjs.NamedNode;
+        $fromRdfTypes: readonly rdfjs.NamedNode[];
     }[], query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, readonly ObjectIdentifierT[]>;
     protected $objectUnionsSync<ObjectT extends {
         readonly $identifier: ObjectIdentifierT;
@@ -1131,7 +1168,7 @@ export declare class $RdfjsDatasetObjectSet implements $ObjectSet {
         $fromRdf: (resource: rdfjsResource.Resource, options: {
             objectSet: $ObjectSet;
         }) => purify.Either<Error, ObjectT>;
-        $fromRdfType?: rdfjs.NamedNode;
+        $fromRdfTypes: readonly rdfjs.NamedNode[];
     }[], query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, readonly ObjectT[]>;
     protected $objectUnionsCountSync<ObjectT extends {
         readonly $identifier: ObjectIdentifierT;
@@ -1139,7 +1176,7 @@ export declare class $RdfjsDatasetObjectSet implements $ObjectSet {
         $fromRdf: (resource: rdfjsResource.Resource, options: {
             objectSet: $ObjectSet;
         }) => purify.Either<Error, ObjectT>;
-        $fromRdfType?: rdfjs.NamedNode;
+        $fromRdfTypes: readonly rdfjs.NamedNode[];
     }[], query?: $ObjectSet.Query<ObjectIdentifierT>): purify.Either<Error, number>;
 }
 export {};