@shaclmate/compiler 2.0.14 → 2.0.16

package/generators/ts/_ObjectType/TypeDiscriminatorProperty.js

@@ -7,15 +7,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
+import { SnippetDeclarations } from "../SnippetDeclarations.js";
 import { Property } from "./Property.js";
 export class TypeDiscriminatorProperty extends Property {
-    constructor({ abstract, objectTypeDeclarationType, override, type, value, ...superParameters }) {
+    constructor({ abstract, override, type, value, ...superParameters }) {
         super({ ...superParameters, type });
-        this.equalsFunction = "purifyHelpers.Equatable.strictEquals";
+        this.equalsFunction = "strictEquals";
         this.mutable = false;
         invariant(this.visibility === "public");
         this.abstract = abstract;
-        this.objectTypeDeclarationType = objectTypeDeclarationType;
         this.override = override;
         this.value = value;
     }
@@ -53,6 +53,13 @@ export class TypeDiscriminatorProperty extends Property {
             type: this.type.name,
         };
     }
+    get snippetDeclarations() {
+        const snippetDeclarations = [];
+        if (this.objectType.features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.strictEquals);
+        }
+        return snippetDeclarations;
+    }
     classConstructorStatements() {
         return [];
     }
@@ -60,7 +67,7 @@ export class TypeDiscriminatorProperty extends Property {
         return this.fromRdfStatements();
     }
     fromRdfStatements() {
-        return !this.abstract && this.objectTypeDeclarationType === "interface"
+        return !this.abstract && this.objectType.declarationType === "interface"
             ? [`const ${this.name} = "${this.value}" as const`]
             : [];
     }

package/generators/ts/_ObjectType/equalsFunctionOrMethodDeclaration.js

@@ -59,7 +59,7 @@ export function equalsFunctionOrMethodDeclaration() {
                     type: this.name,
                 },
             ],
-        returnType: "purifyHelpers.Equatable.EqualsResult",
+        returnType: "EqualsResult",
         statements: [
             `return ${chain
                 .map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : `chain(() => ${chainPart})`)

package/generators/ts/_ObjectType/fromJsonFunctionDeclarations.js

@@ -17,7 +17,7 @@ export function fromJsonFunctionDeclarations() {
     this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
         propertiesFromJsonFunctionStatements.push(`const _super${parentObjectTypeI}Either = ${parentObjectType.name}.propertiesFromJson(${variables.jsonObject});`, `if (_super${parentObjectTypeI}Either.isLeft()) { return _super${parentObjectTypeI}Either; }`, `const _super${parentObjectTypeI} = _super${parentObjectTypeI}Either.unsafeCoerce()`);
         initializers.push(`..._super${parentObjectTypeI}`);
-        propertiesFromJsonFunctionReturnType.push(`purifyHelpers.Eithers.UnwrapR<ReturnType<typeof ${parentObjectType.name}.propertiesFromJson>>`);
+        propertiesFromJsonFunctionReturnType.push(`UnwrapR<ReturnType<typeof ${parentObjectType.name}.propertiesFromJson>>`);
     });
     for (const property of this.properties) {
         const propertyFromJsonStatements = property.fromJsonStatements({

package/generators/ts/_ObjectType/fromRdfFunctionDeclarations.js

@@ -20,7 +20,7 @@ export function fromRdfFunctionDeclarations() {
     this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
         propertiesFromRdfFunctionStatements.push(`const _super${parentObjectTypeI}Either = ${parentObjectType.name}.propertiesFromRdf({ ...${variables.context}, ignoreRdfType: true, languageIn: ${variables.languageIn}, resource: ${variables.resource} });`, `if (_super${parentObjectTypeI}Either.isLeft()) { return _super${parentObjectTypeI}Either; }`, `const _super${parentObjectTypeI} = _super${parentObjectTypeI}Either.unsafeCoerce()`);
         initializers.push(`..._super${parentObjectTypeI}`);
-        propertiesFromRdfFunctionReturnType.push(`purifyHelpers.Eithers.UnwrapR<ReturnType<typeof ${parentObjectType.name}.propertiesFromRdf>>`);
+        propertiesFromRdfFunctionReturnType.push(`UnwrapR<ReturnType<typeof ${parentObjectType.name}.propertiesFromRdf>>`);
     });
     this.fromRdfType.ifJust((rdfType) => {
         propertiesFromRdfFunctionStatements.push(`if (!${variables.ignoreRdfType} && !${variables.resource}.isInstanceOf(${this.rdfjsTermExpression(rdfType)})) { return purify.Left(new rdfjsResource.Resource.ValueError(${objectInitializer({ focusResource: variables.resource, message: `\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} has unexpected RDF type\``, predicate: this.rdfjsTermExpression(rdfType) })})); }`);

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/sparqlConstructQueryFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionDeclarationStructure } from "ts-morph";
+export declare function sparqlConstructQueryFunctionDeclaration(this: {
+    readonly name: string;
+}): FunctionDeclarationStructure;
+//# sourceMappingURL=sparqlConstructQueryFunctionDeclaration.d.ts.map

package/generators/ts/_ObjectType/sparqlConstructQueryFunctionDeclaration.js

@@ -0,0 +1,21 @@
+import { StructureKind } from "ts-morph";
+export function sparqlConstructQueryFunctionDeclaration() {
+    return {
+        isExported: true,
+        kind: StructureKind.Function,
+        name: "sparqlConstructQuery",
+        parameters: [
+            {
+                hasQuestionToken: true,
+                name: "parameters",
+                type: '{ ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; subject?: sparqljs.Triple["subject"]; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type">',
+            },
+        ],
+        returnType: "sparqljs.ConstructQuery",
+        statements: [
+            "const { ignoreRdfType, subject, ...queryParameters } = parameters ?? {}",
+            `return { ...queryParameters, prefixes: parameters?.prefixes ?? {}, queryType: "CONSTRUCT", template: (queryParameters.template ?? []).concat(${this.name}.sparqlConstructTemplateTriples({ ignoreRdfType, subject })), type: "query", where: (queryParameters.where ?? []).concat(${this.name}.sparqlWherePatterns({ ignoreRdfType, subject })) };`,
+        ],
+    };
+}
+//# sourceMappingURL=sparqlConstructQueryFunctionDeclaration.js.map

package/generators/ts/_ObjectType/sparqlConstructQueryStringFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionDeclarationStructure } from "ts-morph";
+export declare function sparqlConstructQueryStringFunctionDeclaration(this: {
+    readonly name: string;
+}): FunctionDeclarationStructure;
+//# sourceMappingURL=sparqlConstructQueryStringFunctionDeclaration.d.ts.map

package/generators/ts/_ObjectType/sparqlConstructQueryStringFunctionDeclaration.js

@@ -0,0 +1,20 @@
+import { StructureKind } from "ts-morph";
+export function sparqlConstructQueryStringFunctionDeclaration() {
+    return {
+        isExported: true,
+        kind: StructureKind.Function,
+        name: "sparqlConstructQueryString",
+        parameters: [
+            {
+                hasQuestionToken: true,
+                name: "parameters",
+                type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"]; variablePrefix?: string; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type"> & sparqljs.GeneratorOptions',
+            },
+        ],
+        returnType: "string",
+        statements: [
+            `return new sparqljs.Generator(parameters).stringify(${this.name}.sparqlConstructQuery(parameters));`,
+        ],
+    };
+}
+//# sourceMappingURL=sparqlConstructQueryStringFunctionDeclaration.js.map

package/generators/ts/_ObjectType/sparqlFunctionDeclarations.js

@@ -1,6 +1,8 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { camelCase } from "change-case";
 import { StructureKind } from "ts-morph";
+import { sparqlConstructQueryFunctionDeclaration } from "./sparqlConstructQueryFunctionDeclaration.js";
+import { sparqlConstructQueryStringFunctionDeclaration } from "./sparqlConstructQueryStringFunctionDeclaration.js";
 export function sparqlFunctionDeclarations() {
     if (!this.features.has("sparql")) {
         return [];
@@ -8,43 +10,34 @@ export function sparqlFunctionDeclarations() {
     if (this.extern) {
         return [];
     }
-    const subjectDefault = camelCase(this.name);
     const variables = { subject: "subject", variablePrefix: "variablePrefix" };
     const rdfTypeVariable = `${this.dataFactoryVariable}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
+    const subjectDefault = camelCase(this.name);
+    const preambleStatements = [
+        `const subject = parameters?.subject ?? ${this.dataFactoryVariable}.variable!("${subjectDefault}");`,
+        `const variablePrefix = parameters?.variablePrefix ?? (subject.termType === "Variable" ? subject.value : "${subjectDefault}");`,
+    ];
+    const sparqlConstructTemplateTriples = [
+        ...this.parentObjectTypes.map((parentObjectType) => `...${parentObjectType.name}.sparqlConstructTemplateTriples({ ignoreRdfType: true, subject, variablePrefix })`),
+        ...(this.fromRdfType.isJust()
+            ? [
+                `...(parameters?.ignoreRdfType ? [] : [{ subject, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} }])`,
+            ]
+            : []),
+        ...this.ownProperties.flatMap((property) => property.sparqlConstructTemplateTriples({ variables })),
+    ];
+    const sparqlWherePatterns = [
+        ...this.parentObjectTypes.map((parentObjectType) => `...${parentObjectType.name}.sparqlWherePatterns({ ignoreRdfType: true, subject, variablePrefix })`),
+        ...(this.fromRdfType.isJust()
+            ? [
+                `...(parameters?.ignoreRdfType ? [] : [{ triples: [{ subject, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${this.rdfjsTermExpression(this.fromRdfType.unsafeCoerce())} }], type: "bgp" as const }, { triples: [{ subject, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} }], type: "bgp" as const }])`,
+            ]
+            : []),
+        ...this.ownProperties.flatMap((property) => property.sparqlWherePatterns({ variables })),
+    ];
     return [
-        {
-            isExported: true,
-            kind: StructureKind.Function,
-            name: "sparqlConstructQuery",
-            parameters: [
-                {
-                    hasQuestionToken: true,
-                    name: "parameters",
-                    type: '{ ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; subject?: sparqljs.Triple["subject"]; variablePrefix?: string; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type">',
-                },
-            ],
-            returnType: "sparqljs.ConstructQuery",
-            statements: [
-                "const { ignoreRdfType, subject, variablePrefix, ...queryParameters } = parameters ?? {}",
-                `return { ...queryParameters, prefixes: parameters?.prefixes ?? {}, queryType: "CONSTRUCT", template: (queryParameters.template ?? []).concat(${this.name}.sparqlConstructTemplateTriples({ ignoreRdfType, subject })), type: "query", where: (queryParameters.where ?? []).concat(${this.name}.sparqlWherePatterns({ ignoreRdfType, subject, variablePrefix })) };`,
-            ],
-        },
-        {
-            isExported: true,
-            kind: StructureKind.Function,
-            name: "sparqlConstructQueryString",
-            parameters: [
-                {
-                    hasQuestionToken: true,
-                    name: "parameters",
-                    type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"]; variablePrefix?: string; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type"> & sparqljs.GeneratorOptions',
-                },
-            ],
-            returnType: "string",
-            statements: [
-                `return new sparqljs.Generator(parameters).stringify(${this.name}.sparqlConstructQuery(parameters));`,
-            ],
-        },
+        sparqlConstructQueryFunctionDeclaration.bind(this)(),
+        sparqlConstructQueryStringFunctionDeclaration.bind(this)(),
         {
             isExported: true,
             kind: StructureKind.Function,
@@ -52,23 +45,16 @@ export function sparqlFunctionDeclarations() {
             parameters: [
                 {
                     hasQuestionToken: true,
-                    name: "parameters",
+                    name: `${sparqlConstructTemplateTriples.length === 0 ? "_" : ""}parameters`,
                     type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
                 },
             ],
             returnType: "readonly sparqljs.Triple[]",
             statements: [
-                `const subject = parameters?.subject ?? ${this.dataFactoryVariable}.variable!("${subjectDefault}");`,
-                `const variablePrefix = parameters?.variablePrefix ?? (subject.termType === "Variable" ? subject.value : "${subjectDefault}");`,
-                `return [${[
-                    ...this.parentObjectTypes.map((parentObjectType) => `...${parentObjectType.name}.sparqlConstructTemplateTriples({ ignoreRdfType: true, subject, variablePrefix })`),
-                    ...(this.fromRdfType.isJust()
-                        ? [
-                            `...(parameters?.ignoreRdfType ? [] : [{ subject, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} }])`,
-                        ]
-                        : []),
-                    this.ownProperties.flatMap((property) => property.sparqlConstructTemplateTriples({ variables })),
-                ].join(", ")}];`,
+                ...(sparqlConstructTemplateTriples.length > 0
+                    ? preambleStatements
+                    : []),
+                `return [${sparqlConstructTemplateTriples.join(", ")}];`,
             ],
         },
         {
@@ -77,23 +63,14 @@ export function sparqlFunctionDeclarations() {
             name: "sparqlWherePatterns",
             parameters: [
                 {
-                    name: "parameters",
+                    name: `${sparqlWherePatterns.length === 0 ? "_" : ""}parameters`,
                     type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
                 },
             ],
             returnType: "readonly sparqljs.Pattern[]",
             statements: [
-                `const subject = parameters?.subject ?? ${this.dataFactoryVariable}.variable!("${subjectDefault}");`,
-                `const variablePrefix = parameters?.variablePrefix ?? (subject.termType === "Variable" ? subject.value : "${subjectDefault}");`,
-                `return [${[
-                    ...this.parentObjectTypes.map((parentObjectType) => `...${parentObjectType.name}.sparqlWherePatterns({ ignoreRdfType: true, subject, variablePrefix })`),
-                    ...(this.fromRdfType.isJust()
-                        ? [
-                            `...(parameters?.ignoreRdfType ? [] : [{ triples: [{ subject, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${this.rdfjsTermExpression(this.fromRdfType.unsafeCoerce())} }], type: "bgp" as const }, { triples: [{ subject, predicate: ${this.rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} }], type: "bgp" as const }])`,
-                        ]
-                        : []),
-                    this.ownProperties.flatMap((property) => property.sparqlWherePatterns({ variables })),
-                ].join(", ")}];`,
+                ...(sparqlWherePatterns.length > 0 ? preambleStatements : []),
+                `return [${sparqlWherePatterns.join(", ")}];`,
             ],
         },
     ];

package/generators/ts/_ObjectType/toJsonFunctionOrMethodDeclaration.js

@@ -19,7 +19,7 @@ export function toJsonFunctionOrMethodDeclaration() {
             break;
         case "interface":
             for (const parentObjectType of this.parentObjectTypes) {
-                jsonObjectMembers.push(`...${parentObjectType.name}.toJson(${this.thisVariable});`);
+                jsonObjectMembers.push(`...${parentObjectType.name}.toJson(${this.thisVariable})`);
             }
             parameters.push({
                 name: this.thisVariable,

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

@@ -1,8 +1,8 @@
 import type * as rdfjs from "@rdfjs/types";
 import { PropertyPath } from "@shaclmate/shacl-ast/PropertyPath.js";
 import * as purify from "purify-ts";
-import type * as purifyHelpers from "purify-ts-helpers";
 import * as rdfjsResource from "rdfjs-resource";
+type UnwrapR<T> = T extends purify.Either<any, infer R> ? R : never;
 export interface BaseShaclCoreShape {
     readonly and: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
     readonly classes: readonly rdfjs.NamedNode[];
@@ -94,8 +94,9 @@ export declare namespace ShaclCorePropertyShape {
         path: PropertyPath;
         type: "ShaclCorePropertyShape" | "ShaclmatePropertyShape";
         uniqueLang: purify.Maybe<boolean>;
-    } & purifyHelpers.Eithers.UnwrapR<ReturnType<typeof BaseShaclCoreShape.propertiesFromRdf>>>;
+    } & 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>;
@@ -118,8 +119,9 @@ export declare namespace ShaclmatePropertyShape {
         name: purify.Maybe<string>;
         type: "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">>;
-    } & purifyHelpers.Eithers.UnwrapR<ReturnType<typeof ShaclCorePropertyShape.propertiesFromRdf>>>;
+    } & 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_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "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_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "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,15 +162,16 @@ 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_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "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_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "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>;
         tsObjectTypeDiscriminatorPropertyName: purify.Maybe<string>;
         type: "ShaclmateOntology";
-    } & purifyHelpers.Eithers.UnwrapR<ReturnType<typeof OwlOntology.propertiesFromRdf>>>;
+    } & 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>;
@@ -188,8 +192,9 @@ export declare namespace ShaclCoreNodeShape {
         ignoredProperties: purify.Maybe<readonly rdfjs.NamedNode[]>;
         properties: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
         type: "ShaclCoreNodeShape" | "ShaclmateNodeShape";
-    } & purifyHelpers.Eithers.UnwrapR<ReturnType<typeof BaseShaclCoreShape.propertiesFromRdf>>>;
+    } & 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_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "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_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "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,15 +230,16 @@ 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_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "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_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "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>;
         tsObjectTypeDiscriminatorPropertyName: purify.Maybe<string>;
         type: "ShaclmateNodeShape";
-    } & purifyHelpers.Eithers.UnwrapR<ReturnType<typeof ShaclCoreNodeShape.propertiesFromRdf>>>;
+    } & 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,10 +272,11 @@ 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;
     }): purify.Either<rdfjsResource.Resource.ValueError, ShaclmateShape>;
 }
+export {};
 //# sourceMappingURL=generated.d.ts.map