@shaclmate/compiler 2.0.15 → 2.0.16

package/_ShapesGraphToAstTransformer/transformNodeShapeToAstType.js

@@ -1,5 +1,5 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
-import { Either, Left } from "purify-ts";
+import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { TsFeature } from "../enums/index.js";
 import * as input from "../input/index.js";
@@ -125,6 +125,7 @@ export function transformNodeShapeToAstType(nodeShape) {
         }
         return Either.of(compositeType);
     }
+    const identifierIn = nodeShape.constraints.in_.filter((term) => term.termType === "NamedNode");
     // Put a placeholder in the cache to deal with cyclic references
     // If this node shape's properties (directly or indirectly) refer to the node shape itself,
     // we'll return this placeholder.
@@ -139,9 +140,10 @@ export function transformNodeShapeToAstType(nodeShape) {
         fromRdfType: nodeShape.fromRdfType,
         label: pickLiteral(nodeShape.labels).map((literal) => literal.value),
         kind: "ObjectType",
-        mintingStrategy: nodeShape.mintingStrategy,
+        identifierIn,
+        identifierMintingStrategy: identifierIn.length === 0 ? nodeShape.mintingStrategy : Maybe.empty(),
+        identifierKinds: identifierIn.length === 0 ? nodeShape.nodeKinds : new Set(["NamedNode"]),
         name: this.shapeAstName(nodeShape),
-        nodeKinds: nodeShape.nodeKinds,
         properties: [], // This is mutable, we'll populate it below.
         parentObjectTypes: [], // This is mutable, we'll populate it below
         toRdfTypes: nodeShape.toRdfTypes,

package/_ShapesGraphToAstTransformer/transformPropertyShapeToAstCompositeType.js

@@ -27,13 +27,13 @@ export function transformPropertyShapeToAstCompositeType(shape, inherited) {
                     nodeKinds.add(astType.identifierNodeKind);
                     break;
                 case "ObjectType":
-                    nodeKinds = astType.nodeKinds;
+                    nodeKinds = astType.identifierKinds;
                     break;
                 case "ObjectIntersectionType":
                 case "ObjectUnionType":
                     nodeKinds = new Set();
                     for (const memberType of astType.memberTypes) {
-                        for (const nodeKind of memberType.nodeKinds) {
+                        for (const nodeKind of memberType.identifierKinds) {
                             nodeKinds.add(nodeKind);
                         }
                     }

package/ast/ListType.d.ts

@@ -1,6 +1,6 @@
 import type { NamedNode } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
-import type { MintingStrategy } from "../enums/MintingStrategy.js";
+import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
 import type { Name } from "./Name.js";
 import type { Type } from "./Type.js";
 /**
@@ -33,7 +33,7 @@ export interface ListType {
     /**
      * Strategy for minting new list and sub-list identifiers.
      */
-    readonly mintingStrategy: Maybe<MintingStrategy>;
+    readonly mintingStrategy: Maybe<IdentifierMintingStrategy>;
     /**
      * The list should be mutable in generated code.
      */

package/ast/ObjectType.d.ts

@@ -1,7 +1,7 @@
 import type { NamedNode } from "@rdfjs/types";
-import type { PredicatePath } from "@shaclmate/shacl-ast";
+import type { NodeKind, PredicatePath } from "@shaclmate/shacl-ast";
 import type { Maybe } from "purify-ts";
-import type { MintingStrategy, PropertyVisibility, TsFeature, TsObjectDeclarationType } from "../enums/index.js";
+import type { IdentifierMintingStrategy, PropertyVisibility, TsFeature, TsObjectDeclarationType } from "../enums/index.js";
 import type { Name } from "./Name.js";
 import type { Type } from "./Type.js";
 export interface ObjectType {
@@ -52,6 +52,22 @@ export interface ObjectType {
      * class targets).
      */
     readonly fromRdfType: Maybe<NamedNode>;
+    /**
+     * Instances of this ObjectType must have explicit identifiers and the identifiers must be in this list of IRIs.
+     *
+     * Mutually exclusive with minting strategies
+     */
+    readonly identifierIn: readonly NamedNode[];
+    /**
+     * The RDF node kinds this ObjectType may be identified by.
+     *
+     * Used to associate instances with an RDF identifier.
+     */
+    readonly identifierKinds: Set<Exclude<NodeKind, "Literal">>;
+    /**
+     * Strategy for minting new object identifiers.
+     */
+    readonly identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
     /**
      * Type discriminator.
      */
@@ -60,20 +76,10 @@ export interface ObjectType {
      * Human-readable label from rdfs:label.
      */
     readonly label: Maybe<string>;
-    /**
-     * Strategy for minting new object identifiers.
-     */
-    readonly mintingStrategy: Maybe<MintingStrategy>;
     /**
      * Name of this type, usually derived from sh:name or shaclmate:name.
      */
     readonly name: Name;
-    /**
-     * The RDF node kinds this ObjectType may be identified by.
-     *
-     * Used to associate instances with an RDF identifier.
-     */
-    readonly nodeKinds: Set<"BlankNode" | "NamedNode">;
     /**
      * Immediate parent ObjectTypes of this Object types.
      *

package/enums/IdentifierMintingStrategy.d.ts

@@ -0,0 +1,5 @@
+/**
+ * TypeScript enum corresponding to shaclmate:mintingStrategy, for simpler manipulation.
+ */
+export type IdentifierMintingStrategy = "sha256" | "uuidv4";
+//# sourceMappingURL=IdentifierMintingStrategy.d.ts.map

package/enums/IdentifierMintingStrategy.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IdentifierMintingStrategy.js.map

package/enums/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./MintingStrategy.js";
+export * from "./IdentifierMintingStrategy.js";
 export * from "./PropertyVisibility.js";
 export * from "./TsFeature.js";
 export * from "./TsObjectDeclarationType.js";

package/enums/index.js

@@ -1,4 +1,4 @@
-export * from "./MintingStrategy.js";
+export * from "./IdentifierMintingStrategy.js";
 export * from "./PropertyVisibility.js";
 export * from "./TsFeature.js";
 export * from "./TsObjectDeclarationType.js";

package/generators/json/AstJsonGenerator.js

@@ -70,7 +70,11 @@ function typeToJson(type) {
                 parentObjectTypes: type.parentObjectTypes.length > 0
                     ? type.parentObjectTypes.map((type) => nameToJson(type.name))
                     : undefined,
-                nodeKinds: [...type.nodeKinds],
+                identifierIn: type.identifierIn.length > 0
+                    ? type.identifierIn.map(termToJson)
+                    : undefined,
+                identifierKinds: [...type.identifierKinds],
+                identifierMintingStrategy: type.identifierMintingStrategy.extract(),
                 toRdfTypes: type.toRdfTypes.length > 0
                     ? type.toRdfTypes.map(termToJson)
                     : undefined,

package/generators/ts/IdentifierType.d.ts

@@ -1,7 +1,9 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { TermType } from "./TermType.js";
+import type { Type } from "./Type.js";
 export declare class IdentifierType extends TermType<BlankNode | NamedNode> {
     readonly kind = "IdentifierType";
+    get conversions(): readonly Type.Conversion[];
     get isNamedNodeKind(): boolean;
     get jsonName(): string;
     get name(): string;

package/generators/ts/IdentifierType.js

@@ -11,6 +11,17 @@ export class IdentifierType extends TermType {
         super(...arguments);
         this.kind = "IdentifierType";
     }
+    get conversions() {
+        return super.conversions.concat([
+            {
+                conversionExpression: (value) => `${this.dataFactoryVariable}.namedNode(${value})`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "string"`,
+                sourceTypeName: this.in_.length > 0
+                    ? this.in_.map((iri) => `"${iri.value}"`).join(" | ")
+                    : "string",
+            },
+        ]);
+    }
     get isNamedNodeKind() {
         return this.nodeKinds.size === 1 && this.nodeKinds.has("NamedNode");
     }

package/generators/ts/ListType.d.ts

@@ -1,6 +1,6 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import type { MintingStrategy, TsFeature } from "../../enums/index.js";
+import type { IdentifierMintingStrategy, TsFeature } from "../../enums/index.js";
 import { Import } from "./Import.js";
 import { Type } from "./Type.js";
 export declare class ListType extends Type {
@@ -13,7 +13,7 @@ export declare class ListType extends Type {
     constructor({ identifierNodeKind, itemType, mintingStrategy, mutable, toRdfTypes, ...superParameters }: {
         identifierNodeKind: ListType["identifierNodeKind"];
         itemType: Type;
-        mintingStrategy: Maybe<MintingStrategy>;
+        mintingStrategy: Maybe<IdentifierMintingStrategy>;
         mutable: boolean;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof Type>[0]);

package/generators/ts/ListType.js

@@ -124,6 +124,10 @@ export class ListType extends Type {
         }
     }
     sparqlWherePatterns({ variables, context, }) {
+        // Need to handle two cases:
+        // (1) (?s, ?p, ?list) where ?list binds to rdf:nil
+        // (2) (?s, ?p, ?list) (?list, rdf:first, "element") (?list, rdf:rest, rdf:nil) etc. where list binds to the head of a list
+        // Case (2) is case (1) with OPTIONAL graph patterns to handle actual list elements.
         switch (context) {
             case "property":
                 return super.sparqlWherePatterns({ context, variables });
@@ -186,7 +190,8 @@ export class ListType extends Type {
                     object: variable("RestNBasic"),
                 })}] }`);
                 patterns.push(`{ type: "optional", patterns: [${optionalPatterns.join(", ")}] }`);
-                return patterns;
+                // Having an optional around everything handles the rdf:nil case
+                return [`{ type: "optional", patterns: [${patterns.join(", ")}] }`];
             }
         }
     }
@@ -236,12 +241,11 @@ export class ListType extends Type {
                 break;
             }
         }
-        return `${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 {
-      const newSubListResource = ${variables.resourceSet}.${resourceSetMethodName}(${objectInitializer({
-            identifier: subListIdentifier,
+      const newSubListResource = ${variables.resourceSet}.${resourceSetMethodName}(${subListIdentifier}, ${objectInitializer({
             mutateGraph: variables.mutateGraph,
         })});
       currentSubListResource!.add(dataFactory.namedNode("${rdf.rest.value}"), newSubListResource.identifier);
@@ -260,15 +264,14 @@ export class ListType extends Type {
   },
   {
     currentSubListResource: null,
-    listResource: resourceSet.${resourceSetMethodName}(${objectInitializer({
-            identifier: listIdentifier,
+    listResource: resourceSet.${resourceSetMethodName}(${listIdentifier}, ${objectInitializer({
             mutateGraph: variables.mutateGraph,
         })}),
   } as {
     currentSubListResource: ${mutableResourceTypeName} | null;
     listResource: ${mutableResourceTypeName};
   },
-).listResource.identifier`;
+).listResource.identifier : dataFactory.namedNode("${rdf.nil.value}")`;
     }
     useImports(features) {
         const imports = this.itemType.useImports(features).concat();

package/generators/ts/ObjectType.d.ts

@@ -1,7 +1,7 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { type ClassDeclarationStructure, type InterfaceDeclarationStructure, type ModuleDeclarationStructure } from "ts-morph";
-import type { MintingStrategy, TsFeature, TsObjectDeclarationType } from "../../enums/index.js";
+import type { IdentifierMintingStrategy, TsFeature, TsObjectDeclarationType } from "../../enums/index.js";
 import { DeclaredType } from "./DeclaredType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import { Import } from "./Import.js";
@@ -15,7 +15,7 @@ export declare class ObjectType extends DeclaredType {
     protected readonly extern: boolean;
     protected readonly fromRdfType: Maybe<NamedNode>;
     protected readonly label: Maybe<string>;
-    protected readonly mintingStrategy: Maybe<MintingStrategy>;
+    protected readonly mintingStrategy: Maybe<IdentifierMintingStrategy>;
     protected readonly toRdfTypes: readonly NamedNode[];
     private readonly imports;
     private readonly lazyAncestorObjectTypes;
@@ -34,7 +34,7 @@ export declare class ObjectType extends DeclaredType {
         lazyDescendantObjectTypes: () => readonly ObjectType[];
         lazyParentObjectTypes: () => readonly ObjectType[];
         lazyProperties: () => readonly ObjectType.Property[];
-        mintingStrategy: Maybe<MintingStrategy>;
+        mintingStrategy: Maybe<IdentifierMintingStrategy>;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof DeclaredType>[0]);
     get _discriminatorProperty(): Type.DiscriminatorProperty;

package/generators/ts/ObjectType.js

@@ -84,6 +84,7 @@ export class ObjectType extends DeclaredType {
             ..._ObjectType.equalsFunctionDeclaration.bind(this)().toList(),
             ..._ObjectType.fromJsonFunctionDeclarations.bind(this)(),
             ..._ObjectType.fromRdfFunctionDeclarations.bind(this)(),
+            ..._ObjectType.fromRdfTypeVariableDeclaration.bind(this)().toList(),
             ..._ObjectType.jsonSchemaFunctionDeclaration.bind(this)().toList(),
             ..._ObjectType.jsonUiSchemaFunctionDeclaration.bind(this)().toList(),
             ..._ObjectType.jsonZodSchemaFunctionDeclaration.bind(this)().toList(),

package/generators/ts/ObjectUnionType.js

@@ -170,14 +170,14 @@ return strictEquals(left.type, right.type).chain(() => {
             name: "fromRdf",
             parameters: [
                 {
-                    name: "parameters",
+                    name: "{ ignoreRdfType, resource, ...context }",
                     type: `{ [_index: string]: any; ignoreRdfType?: boolean; resource: ${this.rdfjsResourceType().name}; }`,
                 },
             ],
             returnType: `purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>`,
             statements: [
                 `return ${this.memberTypes.reduce((expression, memberType) => {
-                    const memberTypeExpression = `(${memberType.name}.fromRdf(parameters) as purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>)`;
+                    const memberTypeExpression = `(${memberType.name}.fromRdf({ ...context, resource }) as purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>)`;
                     return expression.length > 0
                         ? `${expression}.altLazy(() => ${memberTypeExpression})`
                         : memberTypeExpression;
@@ -249,6 +249,7 @@ return strictEquals(left.type, right.type).chain(() => {
                 isExported: true,
                 kind: StructureKind.Function,
                 name: "sparqlConstructTemplateTriples",
+                // Accept ignoreRdfType in order to reuse code but don't pass it through, since deserialization may depend on it
                 parameters: [
                     {
                         name: "parameters",
@@ -258,7 +259,7 @@ return strictEquals(left.type, right.type).chain(() => {
                 returnType: "readonly sparqljs.Triple[]",
                 statements: [
                     `return [${this.memberTypes
-                        .map((memberType) => `...${memberType.name}.sparqlConstructTemplateTriples({ ignoreRdfType: parameters?.ignoreRdfType, subject: parameters.subject ?? ${this.dataFactoryVariable}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`)
+                        .map((memberType) => `...${memberType.name}.sparqlConstructTemplateTriples({ subject: parameters.subject ?? ${this.dataFactoryVariable}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`)
                         .join(", ")}];`,
                 ],
             },
@@ -266,6 +267,7 @@ return strictEquals(left.type, right.type).chain(() => {
                 isExported: true,
                 kind: StructureKind.Function,
                 name: "sparqlWherePatterns",
+                // Accept ignoreRdfType in order to reuse code but don't pass it through, since deserialization may depend on it
                 parameters: [
                     {
                         name: "parameters",
@@ -276,7 +278,7 @@ return strictEquals(left.type, right.type).chain(() => {
                 statements: [
                     `return [{ patterns: [${this.memberTypes
                         .map((memberType) => objectInitializer({
-                        patterns: `${memberType.name}.sparqlWherePatterns({ ignoreRdfType: parameters?.ignoreRdfType, subject: parameters.subject ?? ${this.dataFactoryVariable}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`,
+                        patterns: `${memberType.name}.sparqlWherePatterns({ subject: parameters.subject ?? ${this.dataFactoryVariable}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`,
                         type: '"group"',
                     }))
                         .join(", ")}], type: "union" }];`,
@@ -363,7 +365,8 @@ return strictEquals(left.type, right.type).chain(() => {
         return `${this.name}.fromJson(${variables.value}).unsafeCoerce()`;
     }
     fromRdfExpression({ variables, }) {
-        return `${variables.resourceValues}.head().chain(value => value.to${this.rdfjsResourceType().named ? "Named" : ""}Resource()).chain(_resource => ${this.name}.fromRdf({ ...${variables.context}, resource: _resource }))`;
+        // Don't ignoreRdfType, we may need it to distinguish the union members
+        return `${variables.resourceValues}.head().chain(value => value.to${this.rdfjsResourceType().named ? "Named" : ""}Resource()).chain(_resource => ${this.name}.fromRdf({ ...${variables.context}, languageIn: ${variables.languageIn}, resource: _resource }))`;
     }
     hashStatements({ variables, }) {
         switch (this.memberTypes[0].declarationType) {
@@ -383,7 +386,6 @@ return strictEquals(left.type, right.type).chain(() => {
             case "type":
                 return [
                     `...${this.name}.sparqlConstructTemplateTriples(${objectInitializer({
-                        ignoreRdfType: true,
                         subject: variables.subject,
                         variablePrefix: variables.variablePrefix,
                     })})`,
@@ -397,7 +399,6 @@ return strictEquals(left.type, right.type).chain(() => {
             case "type":
                 return [
                     `...${this.name}.sparqlWherePatterns(${objectInitializer({
-                        ignoreRdfType: true,
                         subject: variables.subject,
                         variablePrefix: variables.variablePrefix,
                     })})`,

package/generators/ts/TypeFactory.js

@@ -214,8 +214,8 @@ export class TypeFactory {
             dataFactoryVariable: this.dataFactoryVariable,
             defaultValue: Maybe.empty(),
             hasValues: [],
-            in_: [],
-            nodeKinds: astType.nodeKinds,
+            in_: astType.identifierIn,
+            nodeKinds: astType.identifierKinds,
         });
         const objectType = new ObjectType({
             abstract: astType.abstract,
@@ -253,7 +253,7 @@ export class TypeFactory {
                     abstract: astType.abstract,
                     classDeclarationVisibility: identifierPropertyClassDeclarationVisibility,
                     dataFactoryVariable: this.dataFactoryVariable,
-                    mintingStrategy: astType.mintingStrategy,
+                    identifierMintingStrategy: astType.identifierMintingStrategy,
                     name: astType.tsIdentifierPropertyName,
                     lazyObjectTypeMutable: () => properties.some((property) => property.mutable || property.type.mutable),
                     objectType: {
@@ -295,7 +295,7 @@ export class TypeFactory {
                 }
                 return properties.sort((left, right) => left.name.localeCompare(right.name));
             },
-            mintingStrategy: astType.mintingStrategy,
+            mintingStrategy: astType.identifierMintingStrategy,
             name: tsName(astType.name),
             toRdfTypes: astType.toRdfTypes,
         });

package/generators/ts/_ObjectType/IdentifierProperty.d.ts

@@ -1,6 +1,6 @@
 import { Maybe } from "purify-ts";
 import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
-import type { MintingStrategy, PropertyVisibility } from "../../../enums/index.js";
+import type { IdentifierMintingStrategy, PropertyVisibility } from "../../../enums/index.js";
 import type { IdentifierType } from "../IdentifierType.js";
 import { Import } from "../Import.js";
 import { Property } from "./Property.js";
@@ -9,14 +9,14 @@ export declare class IdentifierProperty extends Property<IdentifierType> {
     readonly equalsFunction = "booleanEquals";
     readonly mutable = false;
     private readonly classDeclarationVisibility;
+    private readonly identifierMintingStrategy;
     private readonly lazyObjectTypeMutable;
-    private readonly mintingStrategy;
     private readonly override;
-    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, mintingStrategy, override, ...superParameters }: {
+    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, identifierMintingStrategy, override, ...superParameters }: {
         abstract: boolean;
         classDeclarationVisibility: Maybe<PropertyVisibility>;
         lazyObjectTypeMutable: () => boolean;
-        mintingStrategy: Maybe<MintingStrategy>;
+        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         override: boolean;
         type: IdentifierType;
     } & ConstructorParameters<typeof Property>[0]);
@@ -30,7 +30,7 @@ export declare class IdentifierProperty extends Property<IdentifierType> {
     classConstructorStatements({ variables, }: Parameters<Property<IdentifierType>["classConstructorStatements"]>[0]): readonly string[];
     fromJsonStatements({ variables, }: Parameters<Property<IdentifierType>["fromJsonStatements"]>[0]): readonly string[];
     fromRdfStatements({ variables, }: Parameters<Property<IdentifierType>["fromRdfStatements"]>[0]): readonly string[];
-    hashStatements(): readonly string[];
+    hashStatements({ variables, }: Parameters<Property<IdentifierType>["hashStatements"]>[0]): readonly string[];
     interfaceConstructorStatements({ variables, }: Parameters<Property<IdentifierType>["interfaceConstructorStatements"]>[0]): readonly string[];
     jsonUiSchemaElement({ variables, }: Parameters<Property<IdentifierType>["jsonUiSchemaElement"]>[0]): Maybe<string>;
     jsonZodSchema({ variables, }: Parameters<Property<IdentifierType>["jsonZodSchema"]>[0]): ReturnType<Property<IdentifierType>["jsonZodSchema"]>;

package/generators/ts/_ObjectType/IdentifierProperty.js

@@ -1,24 +1,25 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Import } from "../Import.js";
 import { SnippetDeclarations } from "../SnippetDeclarations.js";
 import { Property } from "./Property.js";
 export class IdentifierProperty extends Property {
-    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, mintingStrategy, override, ...superParameters }) {
+    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, identifierMintingStrategy, override, ...superParameters }) {
         super(superParameters);
         this.equalsFunction = "booleanEquals";
         this.mutable = false;
         invariant(this.visibility === "public");
         this.abstract = abstract;
         this.classDeclarationVisibility = classDeclarationVisibility;
-        if (mintingStrategy.isJust()) {
-            this.mintingStrategy = mintingStrategy.unsafeCoerce();
+        if (identifierMintingStrategy.isJust()) {
+            this.identifierMintingStrategy = identifierMintingStrategy.unsafeCoerce();
         }
         else if (this.type.nodeKinds.has("BlankNode")) {
-            this.mintingStrategy = "blankNode";
+            this.identifierMintingStrategy = "blankNode";
         }
         else {
-            this.mintingStrategy = "none";
+            this.identifierMintingStrategy = "none";
         }
         this.lazyObjectTypeMutable = lazyObjectTypeMutable;
         this.override = override;
@@ -28,7 +29,7 @@ export class IdentifierProperty extends Property {
             return Maybe.empty();
         }
         let mintIdentifier;
-        switch (this.mintingStrategy) {
+        switch (this.identifierMintingStrategy) {
             case "blankNode":
                 mintIdentifier = "dataFactory.blankNode()";
                 break;
@@ -72,7 +73,7 @@ export class IdentifierProperty extends Property {
         if (!this.classDeclarationVisibility.isJust()) {
             return Maybe.empty();
         }
-        switch (this.mintingStrategy) {
+        switch (this.identifierMintingStrategy) {
             case "none":
                 // Immutable, public identifier property, no getter
                 return Maybe.of({
@@ -95,19 +96,25 @@ export class IdentifierProperty extends Property {
         if (this.objectType.declarationType === "class" && this.abstract) {
             return Maybe.empty();
         }
+        const typeNames = new Set(); // Remove duplicates with a set
+        for (const conversion of this.type.conversions) {
+            if (conversion.sourceTypeName !== "undefined") {
+                typeNames.add(conversion.sourceTypeName);
+            }
+        }
         return Maybe.of({
             hasQuestionToken: this.objectType.declarationType === "class" &&
-                this.mintingStrategy !== "none",
+                this.identifierMintingStrategy !== "none",
             isReadonly: true,
             name: this.name,
-            type: this.type.name,
+            type: [...typeNames].sort().join(" | "),
         });
     }
     get declarationImports() {
         const imports = this.type.useImports().concat();
         if (this.objectType.features.has("hash") &&
             this.objectType.declarationType === "class") {
-            switch (this.mintingStrategy) {
+            switch (this.identifierMintingStrategy) {
                 case "sha256":
                     imports.push(Import.SHA256);
                     break;
@@ -143,11 +150,27 @@ export class IdentifierProperty extends Property {
         if (this.abstract) {
             return [];
         }
-        return this.classPropertyDeclaration
-            .map((classPropertyDeclaration) => [
-            `this.${classPropertyDeclaration.name} = ${variables.parameter};`,
-        ])
-            .orDefault([]);
+        if (this.classPropertyDeclaration.isNothing()) {
+            return [];
+        }
+        const classPropertyDeclaration = this.classPropertyDeclaration.unsafeCoerce();
+        const typeConversions = this.type.conversions;
+        if (typeConversions.length === 1) {
+            return [
+                `this.${classPropertyDeclaration.name} = ${variables.parameter};`,
+            ];
+        }
+        const statements = [];
+        for (const conversion of this.type.conversions) {
+            if (conversion.sourceTypeName !== "undefined") {
+                statements.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { this.${classPropertyDeclaration.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
+            }
+        }
+        if (!classPropertyDeclaration.hasQuestionToken) {
+            // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
+            statements.push(`{ this.${classPropertyDeclaration.name} =( ${variables.parameter}) as never;\n }`);
+        }
+        return [statements.join(" else ")];
     }
     fromJsonStatements({ variables, }) {
         return [
@@ -155,21 +178,63 @@ export class IdentifierProperty extends Property {
         ];
     }
     fromRdfStatements({ variables, }) {
+        if (this.type.in_.length > 0 && this.type.isNamedNodeKind) {
+            // Treat sh:in as a union of the IRIs
+            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
+            return [
+                `let ${this.name}: ${this.type.name};`,
+                `switch (${variables.resource}.identifier.value) { ${this.type.in_.map((iri) => `case "${iri.value}": ${this.name} = ${this.rdfjsTermExpression(iri)}; break;`).join(" ")} default: return purify.Left(new rdfjsResource.Resource.MistypedValueError({ actualValue: ${variables.resource}.identifier, expectedValueType: ${JSON.stringify(this.type.name)}, focusResource: ${variables.resource}, predicate: ${this.rdfjsTermExpression(rdf.subject)} })); }`,
+            ];
+        }
         return [`const ${this.name} = ${variables.resource}.identifier`];
     }
-    hashStatements() {
-        return [];
+    hashStatements({ variables, }) {
+        if (this.abstract) {
+            // Identifier will only be hashed by a concrete class.
+            return [];
+        }
+        switch (this.identifierMintingStrategy) {
+            case "blankNode":
+            case "none":
+            case "uuidv4":
+                // The identifier minting won't call hash, so we should hash the identifier.
+                return [`${variables.hasher}.update(${variables.value}.value);`];
+            case "sha256":
+                // The identifier minting will call hash, so we can't hash the identifier.
+                return [];
+        }
     }
     interfaceConstructorStatements({ variables, }) {
-        return [`const ${this.name} = ${variables.parameter}`];
+        const typeConversions = this.type.conversions;
+        if (typeConversions.length === 1) {
+            return [`const ${this.name} = ${variables.parameter};`];
+        }
+        const statements = [`let ${this.name}: ${this.type.name};`];
+        const conversionBranches = [];
+        for (const conversion of this.type.conversions) {
+            conversionBranches.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${this.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
+        }
+        // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
+        conversionBranches.push(`{ ${this.name} =( ${variables.parameter}) as never;\n }`);
+        statements.push(conversionBranches.join(" else "));
+        return statements;
     }
     jsonUiSchemaElement({ variables, }) {
         return Maybe.of(`{ label: "Identifier", scope: \`\${${variables.scopePrefix}}/properties/${this.jsonPropertySignature.name}\`, type: "Control" }`);
     }
     jsonZodSchema({ variables, }) {
+        let schema;
+        if (this.type.in_.length > 0 && this.type.isNamedNodeKind) {
+            // Treat sh:in as a union of the IRIs
+            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
+            schema = `${variables.zod}.enum(${JSON.stringify(this.type.in_.map((iri) => iri.value))})`;
+        }
+        else {
+            schema = `${variables.zod}.string().min(1)`;
+        }
         return {
             key: this.jsonPropertySignature.name,
-            schema: `${variables.zod}.string().min(1)`,
+            schema,
         };
     }
     sparqlConstructTemplateTriples() {

package/generators/ts/_ObjectType/fromRdfTypeVariableStatement.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import { type VariableStatementStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare function fromRdfTypeVariableDeclaration(this: ObjectType): Maybe<VariableStatementStructure>;
+//# sourceMappingURL=fromRdfTypeVariableStatement.d.ts.map

package/generators/ts/_ObjectType/fromRdfTypeVariableStatement.js

@@ -0,0 +1,25 @@
+import { Maybe } from "purify-ts";
+import { StructureKind } from "ts-morph";
+export function fromRdfTypeVariableDeclaration() {
+    if (!this.features.has("fromRdf")) {
+        return Maybe.empty();
+    }
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    if (this.fromRdfType.isNothing()) {
+        return Maybe.empty();
+    }
+    return Maybe.of({
+        kind: StructureKind.VariableStatement,
+        declarations: [
+            {
+                name: "fromRdfType",
+                initializer: this.rdfjsTermExpression(this.fromRdfType.unsafeCoerce()),
+                type: "rdfjs.NamedNode<string>",
+            },
+        ],
+        isExported: true,
+    });
+}
+//# sourceMappingURL=fromRdfTypeVariableStatement.js.map

package/generators/ts/_ObjectType/index.d.ts

@@ -3,6 +3,7 @@ export * from "./createFunctionDeclaration.js";
 export * from "./equalsFunctionDeclaration.js";
 export * from "./fromJsonFunctionDeclarations.js";
 export * from "./fromRdfFunctionDeclarations.js";
+export * from "./fromRdfTypeVariableStatement.js";
 export * from "./hashFunctionDeclaration.js";
 export * from "./IdentifierProperty.js";
 export * from "./interfaceDeclaration.js";

package/generators/ts/_ObjectType/index.js

@@ -3,6 +3,7 @@ export * from "./createFunctionDeclaration.js";
 export * from "./equalsFunctionDeclaration.js";
 export * from "./fromJsonFunctionDeclarations.js";
 export * from "./fromRdfFunctionDeclarations.js";
+export * from "./fromRdfTypeVariableStatement.js";
 export * from "./hashFunctionDeclaration.js";
 export * from "./IdentifierProperty.js";
 export * from "./interfaceDeclaration.js";

package/generators/ts/_ObjectType/toRdfFunctionOrMethodDeclaration.js

@@ -28,10 +28,10 @@ export function toRdfFunctionOrMethodDeclaration() {
         usedIgnoreRdfTypeVariable = !this.parentObjectTypes[0].abstract;
     }
     else if (this.identifierType.isNamedNodeKind) {
-        statements.push(`const ${variables.resource} = ${variables.resourceSet}.mutableNamedResource({ identifier: ${this.thisVariable}.${this.identifierProperty.name}, ${variables.mutateGraph} });`);
+        statements.push(`const ${variables.resource} = ${variables.resourceSet}.mutableNamedResource(${this.thisVariable}.${this.identifierProperty.name}, { ${variables.mutateGraph} });`);
     }
     else {
-        statements.push(`const ${variables.resource} = ${variables.resourceSet}.mutableResource({ identifier: ${this.thisVariable}.${this.identifierProperty.name}, ${variables.mutateGraph} });`);
+        statements.push(`const ${variables.resource} = ${variables.resourceSet}.mutableResource(${this.thisVariable}.${this.identifierProperty.name}, { ${variables.mutateGraph} });`);
     }
     if (this.toRdfTypes.length > 0) {
         statements.push(`if (!${variables.ignoreRdfType}) { ${this.toRdfTypes.map((toRdfType) => `${variables.resource}.add(${variables.resource}.dataFactory.namedNode("${rdf.type.value}"), ${variables.resource}.dataFactory.namedNode("${toRdfType.value}"));`).join(" ")} }`);
@@ -55,7 +55,7 @@ export function toRdfFunctionOrMethodDeclaration() {
     }
     parameters.push({
         name: `{ ${usedIgnoreRdfTypeVariable ? `${variables.ignoreRdfType}, ` : ""}${variables.mutateGraph}, ${variables.resourceSet} }`,
-        type: `{ ${variables.ignoreRdfType}?: boolean; ${variables.mutateGraph}: rdfjsResource.MutableResource.MutateGraph, ${variables.resourceSet}: rdfjsResource.MutableResourceSet }`,
+        type: `{ ${variables.ignoreRdfType}?: boolean; ${variables.mutateGraph}?: rdfjsResource.MutableResource.MutateGraph, ${variables.resourceSet}: rdfjsResource.MutableResourceSet }`,
     });
     return Maybe.of({
         name: "toRdf",

package/input/NodeShape.d.ts

@@ -1,7 +1,7 @@
 import type { NamedNode } from "@rdfjs/types";
 import { NodeShape as ShaclCoreNodeShape } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
-import type { MintingStrategy, TsFeature, TsObjectDeclarationType } from "../enums/index.js";
+import type { IdentifierMintingStrategy, TsFeature, TsObjectDeclarationType } from "../enums/index.js";
 import type { Shape } from "./Shape.js";
 import type * as generated from "./generated.js";
 import type { Ontology, PropertyGroup, PropertyShape, ShapesGraph } from "./index.js";
@@ -30,7 +30,7 @@ export declare class NodeShape extends ShaclCoreNodeShape<any, Ontology, Propert
     get export(): Maybe<boolean>;
     get extern(): Maybe<boolean>;
     get fromRdfType(): Maybe<NamedNode>;
-    get mintingStrategy(): Maybe<MintingStrategy>;
+    get mintingStrategy(): Maybe<IdentifierMintingStrategy>;
     get mutable(): Maybe<boolean>;
     get nodeKinds(): Set<"BlankNode" | "NamedNode">;
     get parentNodeShapes(): readonly NodeShape[];

package/input/generated.d.ts

@@ -96,6 +96,7 @@ export declare namespace ShaclCorePropertyShape {
         uniqueLang: purify.Maybe<boolean>;
     } & UnwrapR<ReturnType<typeof BaseShaclCoreShape.propertiesFromRdf>>>;
     function fromRdf(parameters: Parameters<typeof ShaclCorePropertyShape.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclCorePropertyShape>;
+    const fromRdfType: rdfjs.NamedNode<string>;
 }
 export interface ShaclmatePropertyShape extends ShaclCorePropertyShape {
     readonly extern: purify.Maybe<boolean>;
@@ -120,6 +121,7 @@ export declare namespace ShaclmatePropertyShape {
         visibility: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_Visibility_Private" | "http://minorg.github.io/shaclmate/ns#_Visibility_Protected" | "http://minorg.github.io/shaclmate/ns#_Visibility_Public">>;
     } & UnwrapR<ReturnType<typeof ShaclCorePropertyShape.propertiesFromRdf>>>;
     function fromRdf(parameters: Parameters<typeof ShaclmatePropertyShape.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclmatePropertyShape>;
+    const fromRdfType: rdfjs.NamedNode<string>;
 }
 export interface OwlOntology {
     readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
@@ -138,12 +140,13 @@ export declare namespace OwlOntology {
         type: "OwlOntology" | "ShaclmateOntology";
     }>;
     function fromRdf(parameters: Parameters<typeof OwlOntology.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, OwlOntology>;
+    const fromRdfType: rdfjs.NamedNode<string>;
 }
 export interface ShaclmateOntology extends OwlOntology {
     readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
     readonly tsDataFactoryVariable: purify.Maybe<string>;
-    readonly tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
-    readonly tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+    readonly tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_All" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_None" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+    readonly tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_All" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_None" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
     readonly tsImports: readonly string[];
     readonly tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class" | "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface">>;
     readonly tsObjectIdentifierPropertyName: purify.Maybe<string>;
@@ -159,8 +162,8 @@ export declare namespace ShaclmateOntology {
     }): purify.Either<rdfjsResource.Resource.ValueError, {
         identifier: rdfjs.BlankNode | rdfjs.NamedNode;
         tsDataFactoryVariable: purify.Maybe<string>;
-        tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
-        tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+        tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_All" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_None" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+        tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_All" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_None" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
         tsImports: readonly string[];
         tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class" | "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface">>;
         tsObjectIdentifierPropertyName: purify.Maybe<string>;
@@ -168,6 +171,7 @@ export declare namespace ShaclmateOntology {
         type: "ShaclmateOntology";
     } & UnwrapR<ReturnType<typeof OwlOntology.propertiesFromRdf>>>;
     function fromRdf(parameters: Parameters<typeof ShaclmateOntology.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclmateOntology>;
+    const fromRdfType: rdfjs.NamedNode<string>;
 }
 export interface ShaclCoreNodeShape extends BaseShaclCoreShape {
     readonly closed: purify.Maybe<boolean>;
@@ -190,6 +194,7 @@ export declare namespace ShaclCoreNodeShape {
         type: "ShaclCoreNodeShape" | "ShaclmateNodeShape";
     } & UnwrapR<ReturnType<typeof BaseShaclCoreShape.propertiesFromRdf>>>;
     function fromRdf(parameters: Parameters<typeof ShaclCoreNodeShape.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclCoreNodeShape>;
+    const fromRdfType: rdfjs.NamedNode<string>;
 }
 export interface ShaclmateNodeShape extends ShaclCoreNodeShape {
     readonly abstract: purify.Maybe<boolean>;
@@ -201,8 +206,8 @@ export interface ShaclmateNodeShape extends ShaclCoreNodeShape {
     readonly mutable: purify.Maybe<boolean>;
     readonly name: purify.Maybe<string>;
     readonly toRdfTypes: readonly rdfjs.NamedNode[];
-    readonly tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
-    readonly tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+    readonly tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_All" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_None" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+    readonly tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_All" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_None" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
     readonly tsImports: readonly string[];
     readonly tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class" | "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface">>;
     readonly tsObjectIdentifierPropertyName: purify.Maybe<string>;
@@ -225,8 +230,8 @@ export declare namespace ShaclmateNodeShape {
         mutable: purify.Maybe<boolean>;
         name: purify.Maybe<string>;
         toRdfTypes: readonly rdfjs.NamedNode[];
-        tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
-        tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+        tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_All" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_None" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+        tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_All" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_None" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
         tsImports: readonly string[];
         tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class" | "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface">>;
         tsObjectIdentifierPropertyName: purify.Maybe<string>;
@@ -234,6 +239,7 @@ export declare namespace ShaclmateNodeShape {
         type: "ShaclmateNodeShape";
     } & UnwrapR<ReturnType<typeof ShaclCoreNodeShape.propertiesFromRdf>>>;
     function fromRdf(parameters: Parameters<typeof ShaclmateNodeShape.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclmateNodeShape>;
+    const fromRdfType: rdfjs.NamedNode<string>;
 }
 export interface ShaclCorePropertyGroup {
     readonly comments: readonly rdfjs.Literal[];
@@ -254,10 +260,11 @@ export declare namespace ShaclCorePropertyGroup {
         type: "ShaclCorePropertyGroup";
     }>;
     function fromRdf(parameters: Parameters<typeof ShaclCorePropertyGroup.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclCorePropertyGroup>;
+    const fromRdfType: rdfjs.NamedNode<string>;
 }
 export type ShaclCoreShape = ShaclCoreNodeShape | ShaclCorePropertyShape;
 export declare namespace ShaclCoreShape {
-    function fromRdf(parameters: {
+    function fromRdf({ ignoreRdfType, resource, ...context }: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         resource: rdfjsResource.Resource;
@@ -265,7 +272,7 @@ export declare namespace ShaclCoreShape {
 }
 export type ShaclmateShape = ShaclmateNodeShape | ShaclCorePropertyShape;
 export declare namespace ShaclmateShape {
-    function fromRdf(parameters: {
+    function fromRdf({ ignoreRdfType, resource, ...context }: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         resource: rdfjsResource.Resource;

package/input/generated.js

@@ -625,6 +625,7 @@ export var ShaclCorePropertyShape;
         return ShaclCorePropertyShape.propertiesFromRdf(parameters);
     }
     ShaclCorePropertyShape.fromRdf = fromRdf;
+    ShaclCorePropertyShape.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
 })(ShaclCorePropertyShape || (ShaclCorePropertyShape = {}));
 export var ShaclmatePropertyShape;
 (function (ShaclmatePropertyShape) {
@@ -718,6 +719,7 @@ export var ShaclmatePropertyShape;
         return ShaclmatePropertyShape.propertiesFromRdf(parameters);
     }
     ShaclmatePropertyShape.fromRdf = fromRdf;
+    ShaclmatePropertyShape.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
 })(ShaclmatePropertyShape || (ShaclmatePropertyShape = {}));
 export var OwlOntology;
 (function (OwlOntology) {
@@ -766,6 +768,7 @@ export var OwlOntology;
         return OwlOntology.propertiesFromRdf(parameters);
     }
     OwlOntology.fromRdf = fromRdf;
+    OwlOntology.fromRdfType = dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology");
 })(OwlOntology || (OwlOntology = {}));
 export var ShaclmateOntology;
 (function (ShaclmateOntology) {
@@ -808,6 +811,8 @@ export var ShaclmateOntology;
                 .head()
                 .chain((_value) => _value.toIri().chain((iri) => {
                 switch (iri.value) {
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_All":
+                        return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Create":
                         return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals":
@@ -824,6 +829,8 @@ export var ShaclmateOntology;
                         return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema":
                         return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_None":
+                        return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf":
                         return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql":
@@ -835,7 +842,7 @@ export var ShaclmateOntology;
                     default:
                         return purify.Left(new rdfjsResource.Resource.MistypedValueError({
                             actualValue: iri,
-                            expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">',
+                            expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_All" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_None" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">',
                             focusResource: _resource,
                             predicate: dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsFeatureExclude"),
                         }));
@@ -856,6 +863,8 @@ export var ShaclmateOntology;
                 .head()
                 .chain((_value) => _value.toIri().chain((iri) => {
                 switch (iri.value) {
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_All":
+                        return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Create":
                         return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals":
@@ -864,14 +873,16 @@ export var ShaclmateOntology;
                         return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf":
                         return purify.Either.of(iri);
-                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Json":
-                        return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash":
                         return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Json":
+                        return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema":
                         return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema":
                         return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_None":
+                        return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf":
                         return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql":
@@ -883,7 +894,7 @@ export var ShaclmateOntology;
                     default:
                         return purify.Left(new rdfjsResource.Resource.MistypedValueError({
                             actualValue: iri,
-                            expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">',
+                            expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_All" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_None" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">',
                             focusResource: _resource,
                             predicate: dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsFeatureInclude"),
                         }));
@@ -970,6 +981,7 @@ export var ShaclmateOntology;
         return ShaclmateOntology.propertiesFromRdf(parameters);
     }
     ShaclmateOntology.fromRdf = fromRdf;
+    ShaclmateOntology.fromRdfType = dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology");
 })(ShaclmateOntology || (ShaclmateOntology = {}));
 export var ShaclCoreNodeShape;
 (function (ShaclCoreNodeShape) {
@@ -1052,6 +1064,7 @@ export var ShaclCoreNodeShape;
         return ShaclCoreNodeShape.propertiesFromRdf(parameters);
     }
     ShaclCoreNodeShape.fromRdf = fromRdf;
+    ShaclCoreNodeShape.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape");
 })(ShaclCoreNodeShape || (ShaclCoreNodeShape = {}));
 export var ShaclmateNodeShape;
 (function (ShaclmateNodeShape) {
@@ -1176,6 +1189,8 @@ export var ShaclmateNodeShape;
                 .head()
                 .chain((_value) => _value.toIri().chain((iri) => {
                 switch (iri.value) {
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_All":
+                        return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Create":
                         return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals":
@@ -1192,6 +1207,8 @@ export var ShaclmateNodeShape;
                         return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema":
                         return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_None":
+                        return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf":
                         return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql":
@@ -1203,7 +1220,7 @@ export var ShaclmateNodeShape;
                     default:
                         return purify.Left(new rdfjsResource.Resource.MistypedValueError({
                             actualValue: iri,
-                            expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">',
+                            expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_All" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_None" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">',
                             focusResource: _resource,
                             predicate: dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsFeatureExclude"),
                         }));
@@ -1224,6 +1241,8 @@ export var ShaclmateNodeShape;
                 .head()
                 .chain((_value) => _value.toIri().chain((iri) => {
                 switch (iri.value) {
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_All":
+                        return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Create":
                         return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals":
@@ -1232,14 +1251,16 @@ export var ShaclmateNodeShape;
                         return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf":
                         return purify.Either.of(iri);
-                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Json":
-                        return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash":
                         return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_Json":
+                        return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema":
                         return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema":
                         return purify.Either.of(iri);
+                    case "http://minorg.github.io/shaclmate/ns#_TsFeature_None":
+                        return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf":
                         return purify.Either.of(iri);
                     case "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql":
@@ -1251,7 +1272,7 @@ export var ShaclmateNodeShape;
                     default:
                         return purify.Left(new rdfjsResource.Resource.MistypedValueError({
                             actualValue: iri,
-                            expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">',
+                            expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_All" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_None" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">',
                             focusResource: _resource,
                             predicate: dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#tsFeatureInclude"),
                         }));
@@ -1345,6 +1366,7 @@ export var ShaclmateNodeShape;
         return ShaclmateNodeShape.propertiesFromRdf(parameters);
     }
     ShaclmateNodeShape.fromRdf = fromRdf;
+    ShaclmateNodeShape.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape");
 })(ShaclmateNodeShape || (ShaclmateNodeShape = {}));
 export var ShaclCorePropertyGroup;
 (function (ShaclCorePropertyGroup) {
@@ -1418,18 +1440,25 @@ export var ShaclCorePropertyGroup;
         return ShaclCorePropertyGroup.propertiesFromRdf(parameters);
     }
     ShaclCorePropertyGroup.fromRdf = fromRdf;
+    ShaclCorePropertyGroup.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup");
 })(ShaclCorePropertyGroup || (ShaclCorePropertyGroup = {}));
 export var ShaclCoreShape;
 (function (ShaclCoreShape) {
-    function fromRdf(parameters) {
-        return ShaclCoreNodeShape.fromRdf(parameters).altLazy(() => ShaclCorePropertyShape.fromRdf(parameters));
+    function fromRdf({ ignoreRdfType, resource, ...context }) {
+        return ShaclCoreNodeShape.fromRdf({ ...context, resource }).altLazy(() => ShaclCorePropertyShape.fromRdf({
+            ...context,
+            resource,
+        }));
     }
     ShaclCoreShape.fromRdf = fromRdf;
 })(ShaclCoreShape || (ShaclCoreShape = {}));
 export var ShaclmateShape;
 (function (ShaclmateShape) {
-    function fromRdf(parameters) {
-        return ShaclmateNodeShape.fromRdf(parameters).altLazy(() => ShaclCorePropertyShape.fromRdf(parameters));
+    function fromRdf({ ignoreRdfType, resource, ...context }) {
+        return ShaclmateNodeShape.fromRdf({ ...context, resource }).altLazy(() => ShaclCorePropertyShape.fromRdf({
+            ...context,
+            resource,
+        }));
     }
     ShaclmateShape.fromRdf = fromRdf;
 })(ShaclmateShape || (ShaclmateShape = {}));

package/input/tsFeatures.d.ts

@@ -1,7 +1,7 @@
 import type * as rdfjs from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { TsFeature } from "../enums/index.js";
-type TsFeatureIri = rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">;
+type TsFeatureIri = rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_All" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Json" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_None" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">;
 export declare function tsFeatures(generated: {
     readonly tsFeatureExcludes: readonly TsFeatureIri[];
     readonly tsFeatureIncludes: readonly TsFeatureIri[];

package/input/tsFeatures.js

@@ -2,6 +2,8 @@ import { Maybe } from "purify-ts";
 import { TsFeature } from "../enums/index.js";
 function iriToTsFeatures(iri) {
     switch (iri.value) {
+        case "http://minorg.github.io/shaclmate/ns#_TsFeature_All":
+            return TsFeature.MEMBERS;
         case "http://minorg.github.io/shaclmate/ns#_TsFeature_Create":
             return ["create"];
         case "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals":
@@ -18,6 +20,8 @@ function iriToTsFeatures(iri) {
             return ["jsonSchema"];
         case "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema":
             return ["jsonUiSchema"];
+        case "http://minorg.github.io/shaclmate/ns#_TsFeature_None":
+            return [];
         case "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql":
             return ["sparql"];
         case "http://minorg.github.io/shaclmate/ns#_TsFeature_Rdf":

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "2.0.15",
+    "@shaclmate/shacl-ast": "2.0.16",
     "@rdfjs/prefix-map": "^0.1.2",
     "@rdfjs/term-map": "^2.0.2",
     "@rdfjs/term-set": "^2.0.3",
@@ -20,7 +20,7 @@
     "typescript-memoize": "^1.1.1"
   },
   "devDependencies": {
-    "@shaclmate/runtime": "2.0.15",
+    "@shaclmate/runtime": "2.0.16",
     "oxigraph": "^0.4.0"
   },
   "files": [
@@ -73,5 +73,5 @@
   },
   "type": "module",
   "types": "index.d.ts",
-  "version": "2.0.15"
+  "version": "2.0.16"
 }

package/enums/MintingStrategy.d.ts

@@ -1,5 +0,0 @@
-/**
- * TypeScript enum corresponding to shaclmate:mintingStrategy, for simpler manipulation.
- */
-export type MintingStrategy = "sha256" | "uuidv4";
-//# sourceMappingURL=MintingStrategy.d.ts.map

package/enums/MintingStrategy.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=MintingStrategy.js.map