@shaclmate/compiler 4.0.6 → 4.0.8

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

@@ -0,0 +1,106 @@
+import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+const variables = {
+    filter: code `parameters.filter`,
+    preferredLanguages: code `parameters.preferredLanguages`,
+    focusIdentifier: code `parameters.focusIdentifier`,
+    variablePrefix: code `parameters.variablePrefix`,
+};
+export function ObjectType_sparqlWherePatternsFunctionDeclaration() {
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    const rdfClassVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
+    const rdfTypeVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
+    let patternsVariableDeclarationKeyword = "const";
+    const statements = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        statements.push(code `\
+patterns = patterns.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
+        patternsVariableDeclarationKeyword = "let";
+    }
+    if (this.fromRdfType.isJust()) {
+        const fromRdfTypeVariables = this.fromRdfTypeVariable
+            .toList()
+            .concat(this.descendantFromRdfTypeVariables);
+        statements.push(code `const rdfTypeVariable = ${rdfTypeVariable};`, code `\
+if (!parameters?.ignoreRdfType) {
+  patterns.push(
+    ${fromRdfTypeVariables.length > 1
+            ? code `\
+    {
+      type: "values" as const,
+      values: [${joinCode(fromRdfTypeVariables, { on: "," })}].map((identifier) => {
+        const valuePatternRow: ${imports.sparqljs}.ValuePatternRow = {};
+        valuePatternRow[\`?\${${variables.variablePrefix}}FromRdfType\`] = identifier as ${imports.NamedNode};
+        return valuePatternRow;
+      }),
+    },
+    ${snippets.sparqlInstancesOfPattern}({ rdfType: ${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}FromRdfType\`), subject: ${variables.focusIdentifier} }),`
+            : code `${snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariables[0]}, subject: ${variables.focusIdentifier} }),`}
+    {
+      triples: [
+        {
+          subject: ${variables.focusIdentifier},
+          predicate: ${rdfjsTermExpression(rdf.type)},
+          object: rdfTypeVariable
+        }
+      ],
+      type: "bgp" as const
+    },
+    {
+      patterns: [
+        {
+          triples: [
+            {
+              subject: rdfTypeVariable,
+              predicate: {
+                items: [${rdfjsTermExpression(rdfs.subClassOf)}],
+                pathType: "+" as const,
+                type: "path" as const
+              },
+              object: ${rdfClassVariable}
+            }
+          ],
+          type: "bgp" as const
+        }
+      ],
+      type: "optional" as const
+    }
+  );
+}`);
+    }
+    for (const property of this.ownProperties) {
+        if (property.recursive) {
+            continue;
+        }
+        property
+            .sparqlWherePatternsExpression({ variables })
+            .ifJust(({ condition, patterns }) => {
+            const concatStatement = code `patterns = patterns.concat(${patterns});`;
+            if (condition) {
+                statements.push(code `if (${condition}) { ${concatStatement} }`);
+            }
+            else {
+                statements.push(concatStatement);
+            }
+            patternsVariableDeclarationKeyword = "let";
+        });
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}sparqlWherePatterns(${statements.length === 0 ? "_" : ""}parameters: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${snippets.SparqlPattern}[] {
+${statements.length > 0
+        ? joinCode([
+            code `${patternsVariableDeclarationKeyword} patterns: ${snippets.SparqlPattern}[] = [];`,
+            ...statements,
+            code `return patterns;`,
+        ])
+        : "return [];"}
+}`);
+}
+//# sourceMappingURL=ObjectType_sparqlWherePatternsFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_fromJsonFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import { type Code } from "ts-poet";
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+export declare function ObjectUnionType_fromJsonFunctionDeclaration(this: ObjectUnionType): Maybe<Code>;
+//# sourceMappingURL=ObjectUnionType_fromJsonFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_fromJsonFunctionDeclaration.js

@@ -0,0 +1,19 @@
+import { Maybe } from "purify-ts";
+import { code } from "ts-poet";
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+export function ObjectUnionType_fromJsonFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}fromJson(json: unknown): ${imports.Either}<${imports.z}.ZodError, ${this.name}> {
+  return ${this.concreteMemberTypes.reduce((expression, memberType) => {
+        const memberTypeExpression = code `(${memberType.staticModuleName}.${syntheticNamePrefix}fromJson(json) as ${imports.Either}<${imports.z}.ZodError, ${this.name}>)`;
+        return expression !== null
+            ? code `${expression}.altLazy(() => ${memberTypeExpression})`
+            : memberTypeExpression;
+    }, null)};
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_fromJsonFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_fromRdfFunctionDeclarations.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectUnionType_fromRdfFunctionDeclaration(this: ObjectUnionType): Maybe<Code>;
+//# sourceMappingURL=ObjectUnionType_fromRdfFunctionDeclarations.d.ts.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_fromRdfFunctionDeclarations.js

@@ -0,0 +1,20 @@
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectUnionType_fromRdfFunctionDeclaration() {
+    if (!this.features.has("rdf")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}fromRdf(resource: ${imports.Resource}, options?: ${snippets.FromRdfOptions}): ${imports.Either}<Error, ${this.name}> {
+  return ${this.concreteMemberTypes.reduce((expression, memberType) => {
+        const memberTypeExpression = code `(${memberType.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...options, ignoreRdfType: false }) as ${imports.Either}<Error, ${this.name}>)`;
+        return expression !== null
+            ? code `${expression}.altLazy(() => ${memberTypeExpression})`
+            : memberTypeExpression;
+    }, null)};
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_fromRdfFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_jsonZodSchemaFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import { type Code } from "ts-poet";
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+export declare function ObjectUnionType_jsonZodSchemaFunctionDeclaration(this: ObjectUnionType): Maybe<Code>;
+//# sourceMappingURL=ObjectUnionType_jsonZodSchemaFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_jsonZodSchemaFunctionDeclaration.js

@@ -0,0 +1,14 @@
+import { Maybe } from "purify-ts";
+import { code, joinCode } from "ts-poet";
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+export function ObjectUnionType_jsonZodSchemaFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}jsonZodSchema() {
+  return ${imports.z}.discriminatedUnion("${this._discriminantProperty.name}", [${joinCode(this.concreteMemberTypes.map((memberType) => memberType.jsonZodSchema({ context: "type" })), { on: ", " })}]);
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_jsonZodSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_sparqlConstructTriplesFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectUnionType_sparqlConstructTriplesFunctionDeclaration(this: ObjectUnionType): Maybe<Code>;
+//# sourceMappingURL=ObjectUnionType_sparqlConstructTriplesFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_sparqlConstructTriplesFunctionDeclaration.js

@@ -0,0 +1,15 @@
+import { pascalCase } from "change-case";
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectUnionType_sparqlConstructTriplesFunctionDeclaration() {
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}sparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${imports.sparqljs}.Triple[] {
+  return [${joinCode(this.concreteMemberTypes.map((memberType) => code `...${memberType.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ filter: filter?.on?.${memberType.name}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(memberType.name)}\` }).concat()`), { on: ", " })}];
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_sparqlConstructTriplesFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_sparqlWherePatternsFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectUnionType_sparqlWherePatternsFunctionDeclaration(this: ObjectUnionType): Maybe<Code>;
+//# sourceMappingURL=ObjectUnionType_sparqlWherePatternsFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_sparqlWherePatternsFunctionDeclaration.js

@@ -0,0 +1,35 @@
+import { pascalCase } from "change-case";
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectUnionType_sparqlWherePatternsFunctionDeclaration() {
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}sparqlWherePatterns({ filter, focusIdentifier, preferredLanguages, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${snippets.SparqlPattern}[] {
+${joinCode([
+        code `let patterns: ${snippets.SparqlPattern}[] = [];`,
+        code `\
+if (focusIdentifier.termType === "Variable") {
+  patterns = patterns.concat(${this.identifierType.sparqlWherePatternsFunction}({
+      filter: filter?.${syntheticNamePrefix}identifier,
+      ignoreRdfType: false,
+      preferredLanguages,
+      propertyPatterns: [],
+      schema: ${this.identifierType.schema},
+      valueVariable: focusIdentifier,
+      variablePrefix,
+  }));
+}`,
+        code `patterns.push({ patterns: [${joinCode(this.concreteMemberTypes.map((memberType) => code `${{
+            patterns: code `${memberType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ filter: filter?.on?.${memberType.name}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(memberType.name)}\` }).concat()`,
+            type: literalOf("group"),
+        }}`), { on: ", " })}], type: "union" });`,
+        code `return patterns;`,
+    ])}
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_sparqlWherePatternsFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_toJsonFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import { type Code } from "ts-poet";
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+export declare function ObjectUnionType_toJsonFunctionDeclaration(this: ObjectUnionType): Maybe<Code>;
+//# sourceMappingURL=ObjectUnionType_toJsonFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_toJsonFunctionDeclaration.js

@@ -0,0 +1,26 @@
+import { Maybe } from "purify-ts";
+import { code, joinCode } from "ts-poet";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+export function ObjectUnionType_toJsonFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}toJson(${this.thisVariable}: ${this.name}): ${this.jsonType().name} {
+${joinCode(this.concreteMemberTypes
+        .map((memberType) => {
+        let returnExpression;
+        switch (memberType.declarationType) {
+            case "class":
+                returnExpression = code `${this.thisVariable}.${syntheticNamePrefix}toJson()`;
+                break;
+            case "interface":
+                returnExpression = code `${memberType.staticModuleName}.${syntheticNamePrefix}toJson(${this.thisVariable})`;
+                break;
+        }
+        return code `if (${memberType.staticModuleName}.is${memberType.name}(${this.thisVariable})) { return ${returnExpression}; }`;
+    })
+        .concat(code `throw new Error("unrecognized type");`))}
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_toJsonFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_toRdfFunctionDeclarations.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectUnionType_toRdfFunctionDeclaration(this: ObjectUnionType): Maybe<Code>;
+//# sourceMappingURL=ObjectUnionType_toRdfFunctionDeclarations.d.ts.map

package/dist/generators/ts/_ObjectUnionType/{ObjectUnionType_rdfFunctionDeclarations.js → ObjectUnionType_toRdfFunctionDeclarations.js}

@@ -1,29 +1,12 @@
+import { Maybe } from "purify-ts";
 import { codeEquals } from "../codeEquals.js";
 import { imports } from "../imports.js";
-import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-function ObjectUnionType_fromRdfFunctionDeclaration() {
-    return code `\
-export function ${syntheticNamePrefix}fromRdf(resource: ${imports.Resource}, options?: ${snippets.FromRdfOptions}): ${imports.Either}<Error, ${this.name}> {
-  return ${this.concreteMemberTypes.reduce((expression, memberType) => {
-        const memberTypeExpression = code `(${memberType.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...options, ignoreRdfType: false }) as ${imports.Either}<Error, ${this.name}>)`;
-        return expression !== null
-            ? code `${expression}.altLazy(() => ${memberTypeExpression})`
-            : memberTypeExpression;
-    }, null)};
-}`;
-}
-export function rdfFunctionDeclarations() {
+export function ObjectUnionType_toRdfFunctionDeclaration() {
     if (!this.features.has("rdf")) {
-        return [];
+        return Maybe.empty();
     }
-    return [
-        ObjectUnionType_fromRdfFunctionDeclaration.bind(this)(),
-        ObjectUnionType_toRdfFunctionDeclaration.bind(this)(),
-    ];
-}
-function ObjectUnionType_toRdfFunctionDeclaration() {
     const parametersVariable = "_parameters";
     const returnType = () => {
         let returnType;
@@ -39,7 +22,7 @@ function ObjectUnionType_toRdfFunctionDeclaration() {
         // The types agree
         return returnType;
     };
-    return code `\
+    return Maybe.of(code `\
 export function ${syntheticNamePrefix}toRdf(${this.thisVariable}: ${this.name}, ${parametersVariable}?: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>, resourceSet?: ${imports.ResourceSet} }): ${returnType()} {
 ${joinCode(this.concreteMemberTypes
         .map((memberType) => {
@@ -55,6 +38,6 @@ ${joinCode(this.concreteMemberTypes
         return code `if (${memberType.staticModuleName}.is${memberType.name}(${this.thisVariable})) { return ${returnExpression}; }`;
     })
         .concat(code `throw new Error("unrecognized type");`))}
-}`;
+}`);
 }
-//# sourceMappingURL=ObjectUnionType_rdfFunctionDeclarations.js.map
+//# sourceMappingURL=ObjectUnionType_toRdfFunctionDeclarations.js.map

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from "./Compiler.js";
 export type { Generator } from "./generators/Generator.js";
 export { AstJsonGenerator } from "./generators/json/AstJsonGenerator.js";
 export { TsGenerator } from "./generators/ts/TsGenerator.js";
+export { ZodGenerator } from "./generators/ts/ZodGenerator.js";
 export * from "./input/ShapesGraph.js";
 export * from "./ShapesGraphToAstTransformer.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -2,6 +2,7 @@ export * as ast from "./ast/index.js";
 export * from "./Compiler.js";
 export { AstJsonGenerator } from "./generators/json/AstJsonGenerator.js";
 export { TsGenerator } from "./generators/ts/TsGenerator.js";
+export { ZodGenerator } from "./generators/ts/ZodGenerator.js";
 export * from "./input/ShapesGraph.js";
 export * from "./ShapesGraphToAstTransformer.js";
 //# sourceMappingURL=index.js.map

package/dist/input/NodeShape.d.ts

@@ -1,23 +1,23 @@
 import type { NamedNode } from "@rdfjs/types";
-import { NodeShape as ShaclCoreNodeShape } from "@shaclmate/shacl-ast";
+import { NodeShape as ShaclAstNodeShape } from "@shaclmate/shacl-ast";
 import { Either, type Maybe } from "purify-ts";
 import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
 import type { TsObjectDeclarationType } from "../enums/TsObjectDeclarationType.js";
 import type * as generated from "./generated.js";
 import type { Ontology, PropertyGroup, PropertyShape, ShapesGraph } from "./index.js";
 import type { Shape } from "./Shape.js";
-export declare class NodeShape extends ShaclCoreNodeShape<any, Ontology, PropertyGroup, PropertyShape, Shape> {
+export declare class NodeShape extends ShaclAstNodeShape<any, Ontology, PropertyGroup, PropertyShape, Shape> {
     private readonly ancestorClassIris;
     private readonly childClassIris;
     private readonly descendantClassIris;
-    private readonly generatedShaclmateNodeShape;
+    private readonly generatedNodeShape;
     private readonly parentClassIris;
     readonly isClass: boolean;
     readonly isList: boolean;
     readonly kind = "NodeShape";
-    constructor({ ancestorClassIris, childClassIris, descendantClassIris, generatedShaclmateNodeShape, isClass, isList, parentClassIris, shapesGraph, }: {
+    constructor({ ancestorClassIris, childClassIris, descendantClassIris, generatedNodeShape, isClass, isList, parentClassIris, shapesGraph, }: {
         ancestorClassIris: readonly NamedNode[];
-        generatedShaclmateNodeShape: generated.ShaclmateNodeShape;
+        generatedNodeShape: generated.NodeShape;
         childClassIris: readonly NamedNode[];
         descendantClassIris: readonly NamedNode[];
         isClass: boolean;

package/dist/input/NodeShape.js

@@ -4,22 +4,22 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { NodeShape as ShaclCoreNodeShape } from "@shaclmate/shacl-ast";
+import { NodeShape as ShaclAstNodeShape } from "@shaclmate/shacl-ast";
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Either, List } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-export class NodeShape extends ShaclCoreNodeShape {
+export class NodeShape extends ShaclAstNodeShape {
     ancestorClassIris;
     childClassIris;
     descendantClassIris;
-    generatedShaclmateNodeShape;
+    generatedNodeShape;
     parentClassIris;
     isClass;
     isList;
     kind = "NodeShape";
-    constructor({ ancestorClassIris, childClassIris, descendantClassIris, generatedShaclmateNodeShape, isClass, isList, parentClassIris, shapesGraph, }) {
-        super(generatedShaclmateNodeShape, shapesGraph);
+    constructor({ ancestorClassIris, childClassIris, descendantClassIris, generatedNodeShape, isClass, isList, parentClassIris, shapesGraph, }) {
+        super(generatedNodeShape, shapesGraph);
         if (ancestorClassIris.length > 0 ||
             childClassIris.length > 0 ||
             descendantClassIris.length > 0 ||
@@ -30,13 +30,13 @@ export class NodeShape extends ShaclCoreNodeShape {
         this.ancestorClassIris = ancestorClassIris;
         this.childClassIris = childClassIris;
         this.descendantClassIris = descendantClassIris;
-        this.generatedShaclmateNodeShape = generatedShaclmateNodeShape;
+        this.generatedNodeShape = generatedNodeShape;
         this.isClass = isClass;
         this.isList = isList;
         this.parentClassIris = parentClassIris;
     }
     get abstract() {
-        return this.generatedShaclmateNodeShape.abstract;
+        return this.generatedNodeShape.abstract;
     }
     get ancestorNodeShapes() {
         return Either.sequence(this.ancestorClassIris
@@ -53,22 +53,22 @@ export class NodeShape extends ShaclCoreNodeShape {
         return Either.sequence(this.descendantClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri)));
     }
     get discriminantValue() {
-        return this.generatedShaclmateNodeShape.discriminantValue;
+        return this.generatedNodeShape.discriminantValue;
     }
     get export() {
-        return this.generatedShaclmateNodeShape.export_;
+        return this.generatedNodeShape.export_;
     }
     get extern() {
-        return this.generatedShaclmateNodeShape.extern;
+        return this.generatedNodeShape.extern;
     }
     get fromRdfType() {
-        return this.generatedShaclmateNodeShape.fromRdfType;
+        return this.generatedNodeShape.fromRdfType;
     }
     get identifierIn() {
         return this.constraints.in_.filter((value) => value.termType === "NamedNode");
     }
     get identifierMintingStrategy() {
-        return this.generatedShaclmateNodeShape.identifierMintingStrategy.map((iri) => {
+        return this.generatedNodeShape.identifierMintingStrategy.map((iri) => {
             switch (iri.value) {
                 case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode":
                     return "blankNode";
@@ -86,7 +86,7 @@ export class NodeShape extends ShaclCoreNodeShape {
         return List.head(this.labels);
     }
     get mutable() {
-        return this.generatedShaclmateNodeShape.mutable;
+        return this.generatedNodeShape.mutable;
     }
     get parentNodeShapes() {
         return Either.sequence(this.parentClassIris
@@ -94,25 +94,25 @@ export class NodeShape extends ShaclCoreNodeShape {
             .map((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri)));
     }
     get rdfType() {
-        return this.generatedShaclmateNodeShape.rdfType;
+        return this.generatedNodeShape.rdfType;
     }
     get shaclmateName() {
-        return this.generatedShaclmateNodeShape.name;
+        return this.generatedNodeShape.name;
     }
     get toRdfTypes() {
-        return this.generatedShaclmateNodeShape.toRdfTypes;
+        return this.generatedNodeShape.toRdfTypes;
     }
     get tsFeatureExcludes() {
-        return this.generatedShaclmateNodeShape.tsFeatureExcludes;
+        return this.generatedNodeShape.tsFeatureExcludes;
     }
     get tsFeatureIncludes() {
-        return this.generatedShaclmateNodeShape.tsFeatureIncludes;
+        return this.generatedNodeShape.tsFeatureIncludes;
     }
     get tsImports() {
-        return this.generatedShaclmateNodeShape.tsImports;
+        return this.generatedNodeShape.tsImports;
     }
     get tsObjectDeclarationType() {
-        return this.generatedShaclmateNodeShape.tsObjectDeclarationType.map((iri) => {
+        return this.generatedNodeShape.tsObjectDeclarationType.map((iri) => {
             switch (iri.value) {
                 case "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class":
                     return "class";

package/dist/input/Ontology.d.ts

@@ -1,10 +1,10 @@
-import { Ontology as OwlOntology } from "@shaclmate/shacl-ast";
+import { Ontology as ShaclAstOntology } from "@shaclmate/shacl-ast";
 import type { Maybe } from "purify-ts";
 import type { TsObjectDeclarationType } from "../enums/TsObjectDeclarationType.js";
 import type * as generated from "./generated.js";
-export declare class Ontology extends OwlOntology {
-    private readonly generatedShaclmateOntology;
-    constructor(generatedShaclmateOntology: generated.ShaclmateOntology);
+export declare class Ontology extends ShaclAstOntology {
+    private readonly _generatedOntology;
+    constructor(_generatedOntology: generated.Ontology);
     get tsFeatureExcludes(): readonly import("@rdfjs/types").NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
     get tsFeatureIncludes(): readonly import("@rdfjs/types").NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
     get tsImports(): readonly string[];

package/dist/input/Ontology.js

@@ -4,25 +4,25 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { Ontology as OwlOntology } from "@shaclmate/shacl-ast";
+import { Ontology as ShaclAstOntology } from "@shaclmate/shacl-ast";
 import { Memoize } from "typescript-memoize";
-export class Ontology extends OwlOntology {
-    generatedShaclmateOntology;
-    constructor(generatedShaclmateOntology) {
-        super(generatedShaclmateOntology);
-        this.generatedShaclmateOntology = generatedShaclmateOntology;
+export class Ontology extends ShaclAstOntology {
+    _generatedOntology;
+    constructor(_generatedOntology) {
+        super(_generatedOntology);
+        this._generatedOntology = _generatedOntology;
     }
     get tsFeatureExcludes() {
-        return this.generatedShaclmateOntology.tsFeatureExcludes;
+        return this._generatedOntology.tsFeatureExcludes;
     }
     get tsFeatureIncludes() {
-        return this.generatedShaclmateOntology.tsFeatureIncludes;
+        return this._generatedOntology.tsFeatureIncludes;
     }
     get tsImports() {
-        return this.generatedShaclmateOntology.tsImports;
+        return this._generatedOntology.tsImports;
     }
     get tsObjectDeclarationType() {
-        return this.generatedShaclmateOntology.tsObjectDeclarationType.map((iri) => {
+        return this._generatedOntology.tsObjectDeclarationType.map((iri) => {
             switch (iri.value) {
                 case "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class":
                     return "class";

package/dist/input/PropertyShape.d.ts

@@ -1,13 +1,13 @@
-import { PropertyShape as ShaclCorePropertyShape } from "@shaclmate/shacl-ast";
+import { PropertyShape as ShaclAstPropertyShape } from "@shaclmate/shacl-ast";
 import { Either, Maybe } from "purify-ts";
 import type { PropertyVisibility } from "../enums/PropertyVisibility.js";
 import type * as generated from "./generated.js";
 import type { NodeShape, Ontology, PropertyGroup, ShapesGraph } from "./index.js";
 import type { Shape } from "./Shape.js";
-export declare class PropertyShape extends ShaclCorePropertyShape<NodeShape, Ontology, PropertyGroup, any, Shape> {
-    private readonly generatedShaclmatePropertyShape;
+export declare class PropertyShape extends ShaclAstPropertyShape<NodeShape, Ontology, PropertyGroup, any, Shape> {
+    private readonly _generatedPropertyShape;
     readonly kind = "PropertyShape";
-    constructor(generatedShaclmatePropertyShape: generated.ShaclmatePropertyShape, shapesGraph: ShapesGraph);
+    constructor(_generatedPropertyShape: generated.PropertyShape, shapesGraph: ShapesGraph);
     get comment(): Maybe<string>;
     get description(): Maybe<string>;
     get label(): Maybe<string>;

package/dist/input/PropertyShape.js

@@ -4,15 +4,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { PropertyShape as ShaclCorePropertyShape } from "@shaclmate/shacl-ast";
+import { PropertyShape as ShaclAstPropertyShape } from "@shaclmate/shacl-ast";
 import { Either, List, Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
-export class PropertyShape extends ShaclCorePropertyShape {
-    generatedShaclmatePropertyShape;
+export class PropertyShape extends ShaclAstPropertyShape {
+    _generatedPropertyShape;
     kind = "PropertyShape";
-    constructor(generatedShaclmatePropertyShape, shapesGraph) {
-        super({ ...generatedShaclmatePropertyShape, uniqueLang: Maybe.empty() }, shapesGraph);
-        this.generatedShaclmatePropertyShape = generatedShaclmatePropertyShape;
+    constructor(_generatedPropertyShape, shapesGraph) {
+        super({ ..._generatedPropertyShape, uniqueLang: Maybe.empty() }, shapesGraph);
+        this._generatedPropertyShape = _generatedPropertyShape;
     }
     get comment() {
         return List.head(this.comments);
@@ -24,13 +24,13 @@ export class PropertyShape extends ShaclCorePropertyShape {
         return List.head(this.labels);
     }
     get mutable() {
-        return this.generatedShaclmatePropertyShape.mutable;
+        return this._generatedPropertyShape.mutable;
     }
     get name() {
         return List.head(this.names);
     }
     get resolve() {
-        const identifier = this.generatedShaclmatePropertyShape.resolve.extract();
+        const identifier = this._generatedPropertyShape.resolve.extract();
         return identifier
             ? this.shapesGraph
                 .nodeShapeByIdentifier(identifier)
@@ -38,10 +38,10 @@ export class PropertyShape extends ShaclCorePropertyShape {
             : Either.of(Maybe.empty());
     }
     get shaclmateName() {
-        return this.generatedShaclmatePropertyShape.name;
+        return this._generatedPropertyShape.name;
     }
     get visibility() {
-        return this.generatedShaclmatePropertyShape.visibility
+        return this._generatedPropertyShape.visibility
             .map((iri) => {
             switch (iri.value) {
                 case "http://purl.org/shaclmate/ontology#_Visibility_Private":