@shaclmate/compiler 4.0.24 → 4.0.25

package/dist/Compiler.d.ts

@@ -1,7 +1,7 @@
 import type { Either } from "purify-ts";
 import type { Logger } from "ts-log";
-import type { TsFeature } from "./enums/TsFeature.js";
 import type { Generator } from "./generators/Generator.js";
+import type { TsFeature } from "./generators/ts/TsFeature.js";
 import type { ShapesGraph } from "./input/ShapesGraph.js";
 export declare class Compiler {
     private readonly generator;

package/dist/ShapesGraphToAstTransformer.d.ts

@@ -3,7 +3,7 @@ import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { Either } from "purify-ts";
 import type { Logger } from "ts-log";
 import type * as ast from "./ast/index.js";
-import type { TsFeature } from "./enums/TsFeature.js";
+import type { TsFeature } from "./generators/ts/TsFeature.js";
 import type * as input from "./input/index.js";
 interface RelatedNodeShapes {
     readonly ancestors: input.NodeShape[];

package/dist/_ShapesGraphToAstTransformer/nodeShapeTsFeatures.d.ts

@@ -1,5 +1,5 @@
 import { Either } from "purify-ts";
-import { type TsFeature } from "../enums/TsFeature.js";
+import { type TsFeature } from "../generators/ts/TsFeature.js";
 import type * as input from "../input/index.js";
 import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
 export declare function nodeShapeTsFeatures(this: ShapesGraphToAstTransformer, nodeShape: input.NodeShape): Either<Error, ReadonlySet<TsFeature>>;

package/dist/_ShapesGraphToAstTransformer/nodeShapeTsFeatures.js

@@ -1,5 +1,5 @@
 import { Either } from "purify-ts";
-import { TS_FEATURES } from "../enums/TsFeature.js";
+import { TS_FEATURES } from "../generators/ts/TsFeature.js";
 import { shapeOntology } from "./shapeOntology.js";
 export function nodeShapeTsFeatures(nodeShape) {
     const tsFeaturesDefault = this.tsFeaturesDefault;
@@ -55,9 +55,12 @@ export function nodeShapeTsFeatures(nodeShape) {
                 tsFeatures.add(tsFeature);
             }
         }
-        if (tsFeatures.has("graphql")) {
+        if (tsFeatures.has("graphql") || tsFeatures.has("sparql")) {
             tsFeatures.add("rdf");
         }
+        if (tsFeatures.has("json") || tsFeatures.has("rdf")) {
+            tsFeatures.add("create");
+        }
         return Either.of(tsFeatures);
     });
 }

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -4,7 +4,6 @@ import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import * as ast from "../ast/index.js";
 import { Eithers } from "../Eithers.js";
-import { Visibility } from "../enums/Visibility.js";
 import { ShapeStack } from "./ShapeStack.js";
 import { transformShapeToAstType } from "./transformShapeToAstType.js";
 function synthesizePartialAstObjectType({ identifierType, tsFeatures, }) {
@@ -20,7 +19,6 @@ function synthesizePartialAstObjectType({ identifierType, tsFeatures, }) {
             break;
     }
     return new ast.ObjectType({
-        abstract: false,
         comment: Maybe.empty(),
         extern: false,
         fromRdfType: Maybe.empty(),
@@ -32,7 +30,6 @@ function synthesizePartialAstObjectType({ identifierType, tsFeatures, }) {
         toRdfTypes: [],
         tsFeatures,
         tsImports: [],
-        tsObjectDeclarationType: "class",
     });
 }
 function propertyName(objectType, propertyShape) {
@@ -261,9 +258,6 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
             path: propertyShape.path,
             shapeIdentifier: propertyShape.$identifier(),
             type: astType,
-            visibility: propertyShape.visibility
-                .map(Visibility.fromIri)
-                .orDefault("public"),
         }));
     });
 }

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.js

@@ -8,7 +8,6 @@ import { shapeAstTypeName } from "./shapeAstTypeName.js";
 import { shapeNodeKinds } from "./shapeNodeKinds.js";
 import { transformPropertyShapeToAstObjectTypeProperty } from "./transformPropertyShapeToAstObjectTypeProperty.js";
 const listPropertiesObjectType = new ast.ObjectType({
-    abstract: false,
     extern: false,
     comment: Maybe.empty(),
     label: Maybe.empty(),
@@ -22,7 +21,6 @@ const listPropertiesObjectType = new ast.ObjectType({
     name: Maybe.empty(),
     toRdfTypes: [],
     tsFeatures: new Set([]),
-    tsObjectDeclarationType: "class",
     shapeIdentifier: dataFactory.blankNode(),
     synthetic: true,
     tsImports: [],

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstObjectType.js

@@ -3,13 +3,11 @@ import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import * as ast from "../ast/index.js";
 import { Eithers } from "../Eithers.js";
-import { TsObjectDeclarationType } from "../enums/TsObjectDeclarationType.js";
 import { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.js";
 import { nodeShapeTsFeatures } from "./nodeShapeTsFeatures.js";
 import { ShapeStack } from "./ShapeStack.js";
 import { shapeAstTypeName } from "./shapeAstTypeName.js";
 import { shapeNodeKinds } from "./shapeNodeKinds.js";
-import { shapeOntology } from "./shapeOntology.js";
 import { transformPropertyShapeToAstObjectTypeProperty } from "./transformPropertyShapeToAstObjectTypeProperty.js";
 import { transformShapeToAstType } from "./transformShapeToAstType.js";
 function isObjectTypePropertyRequired(property) {
@@ -56,39 +54,26 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
         if (nodeShape.$identifier().termType !== "NamedNode") {
             return Either.of(Maybe.empty());
         }
-        return Eithers.chain4(shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier))), nodeShapeTsFeatures.call(this, nodeShape), nodeShape.tsObjectDeclarationType.isJust()
-            ? Either.of(nodeShape.tsObjectDeclarationType.map(TsObjectDeclarationType.fromIri))
-            : shapeOntology
-                .call(this, nodeShape)
-                .map((ontology) => ontology.chain((ontology) => ontology.tsObjectDeclarationType.map(TsObjectDeclarationType.fromIri)))).chain(([nodeKinds, propertyShapes, tsFeatures, tsObjectDeclarationType]) => {
-            const abstract = nodeShape.abstract.orDefault(false);
+        return Eithers.chain3(shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier))), nodeShapeTsFeatures.call(this, nodeShape)).chain(([nodeKinds, propertyShapes, tsFeatures]) => {
             const nodeShapeIdentifier = nodeShape.$identifier();
             const { ancestors: ancestorNodeShapes, descendants: descendantNodeShapes, children: childNodeShapes, parents: parentNodeShapes, } = this.relatedNodeShapesByIdentifier.get(nodeShapeIdentifier);
             const isClass = nodeShape.subClassOf.length > 0 ||
                 descendantNodeShapes.length > 0 || // A node shape that is the object of an rdfs:subClassOf is itself an rdfs:Class
                 nodeShape.types.some((type) => type.equals(owl.Class) || type.equals(rdfs.Class));
-            let fromRdfType;
-            let toRdfTypes;
-            if (!abstract) {
-                fromRdfType = nodeShape.fromRdfType.alt(nodeShape.rdfType);
-                if (isClass && nodeShapeIdentifier.termType === "NamedNode") {
-                    fromRdfType = fromRdfType.alt(Maybe.of(nodeShapeIdentifier));
-                }
-                toRdfTypes = nodeShape.toRdfTypes.concat();
-                if (toRdfTypes.length === 0) {
-                    toRdfTypes.push(...nodeShape.rdfType.toList());
-                }
-                // Ensure toRdfTypes has fromRdfType
-                fromRdfType.ifJust((fromRdfType) => {
-                    if (!toRdfTypes.some((toRdfType) => toRdfType.equals(fromRdfType))) {
-                        toRdfTypes.push(fromRdfType);
-                    }
-                });
+            let fromRdfType = nodeShape.fromRdfType.alt(nodeShape.rdfType);
+            if (isClass && nodeShapeIdentifier.termType === "NamedNode") {
+                fromRdfType = fromRdfType.alt(Maybe.of(nodeShapeIdentifier));
             }
-            else {
-                fromRdfType = Maybe.empty();
-                toRdfTypes = [];
+            const toRdfTypes = nodeShape.toRdfTypes.concat();
+            if (toRdfTypes.length === 0) {
+                toRdfTypes.push(...nodeShape.rdfType.toList());
             }
+            // Ensure toRdfTypes has fromRdfType
+            fromRdfType.ifJust((fromRdfType) => {
+                if (!toRdfTypes.some((toRdfType) => toRdfType.equals(fromRdfType))) {
+                    toRdfTypes.push(fromRdfType);
+                }
+            });
             if (nodeKinds.has("Literal")) {
                 return Left(new Error(`${nodeShape} should not have a nodeKind "Literal"`));
             }
@@ -128,7 +113,6 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
             // If this node shape's properties (directly or indirectly) refer to the node shape itself,
             // we'll return this placeholder.
             const objectType = new ast.ObjectType({
-                abstract,
                 comment: nodeShape.comment,
                 extern: nodeShape.extern.orDefault(false),
                 fromRdfType,
@@ -140,7 +124,6 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
                 toRdfTypes,
                 tsFeatures,
                 tsImports: nodeShape.tsImports,
-                tsObjectDeclarationType: tsObjectDeclarationType.orDefault("class"),
             });
             this.cachedAstTypesByShapeIdentifier.set(nodeShape.$identifier(), objectType);
             return (() => {
@@ -170,8 +153,7 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
                         objectType.addProperties(property);
                     });
                 }
-                if (!objectType.abstract &&
-                    !objectType.extern &&
+                if (!objectType.extern &&
                     objectType.fromRdfType.isNothing() &&
                     !objectType.properties.some(isObjectTypePropertyRequired)) {
                     return Left(new Error(`${nodeShape} has no required properties and no implicitly required rdf:type`));

package/dist/ast/AbstractCompoundType.d.ts

@@ -1,5 +1,5 @@
 import type { NodeKind } from "@shaclmate/shacl-ast";
-import type { TsFeature } from "../enums/TsFeature.js";
+import type { TsFeature } from "../generators/ts/TsFeature.js";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";

package/dist/ast/ObjectType.d.ts

@@ -2,9 +2,7 @@ import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { PropertyPath } from "@rdfx/resource";
 import type { NodeKind } from "@shaclmate/shacl-ast";
 import type { Maybe } from "purify-ts";
-import type { TsFeature } from "../enums/TsFeature.js";
-import type { TsObjectDeclarationType } from "../enums/TsObjectDeclarationType.js";
-import type { Visibility } from "../enums/Visibility.js";
+import type { TsFeature } from "../generators/ts/TsFeature.js";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
@@ -12,12 +10,6 @@ import type { IriType } from "./IriType.js";
 import { Type } from "./Type.js";
 export declare class ObjectType extends AbstractType {
     #private;
-    /**
-     * Classes generated from this type are abstract / cannot be instantiated themselves.
-     *
-     * Defaults to false.
-     */
-    readonly abstract: boolean;
     /**
      * If true, the code for this ObjectType is defined externally and should not be generated.
      *
@@ -64,12 +56,7 @@ export declare class ObjectType extends AbstractType {
      * import { MyType } from "./MyType.js"
      */
     readonly tsImports: readonly string[];
-    /**
-     * Whether to generate a TypeScript class or interface for this type.
-     */
-    readonly tsObjectDeclarationType: TsObjectDeclarationType;
-    constructor({ abstract, extern, fromRdfType, identifierType, synthetic, toRdfTypes, tsFeatures, tsImports, tsObjectDeclarationType, ...superParameters }: {
-        abstract: boolean;
+    constructor({ extern, fromRdfType, identifierType, synthetic, toRdfTypes, tsFeatures, tsImports, ...superParameters }: {
         extern: boolean;
         fromRdfType: Maybe<NamedNode>;
         identifierType: BlankNodeType | IdentifierType | IriType;
@@ -77,7 +64,6 @@ export declare class ObjectType extends AbstractType {
         toRdfTypes: readonly NamedNode[];
         tsFeatures: ReadonlySet<TsFeature>;
         tsImports: readonly string[];
-        tsObjectDeclarationType: TsObjectDeclarationType;
     } & ConstructorParameters<typeof AbstractType>[0]);
     get ancestorObjectTypes(): readonly ObjectType[];
     get childObjectTypes(): readonly ObjectType[];
@@ -163,11 +149,7 @@ export declare namespace ObjectType {
          * Type of this property.
          */
         readonly type: Type;
-        /**
-         * Visibility: private, protected, public.
-         */
-        readonly visibility: Visibility;
-        constructor({ comment, description, display, label, mutable, name, objectType, order, path, shapeIdentifier, type, visibility, }: {
+        constructor({ comment, description, display, label, mutable, name, objectType, order, path, shapeIdentifier, type, }: {
             comment: Maybe<string>;
             description: Maybe<string>;
             display: boolean;
@@ -179,7 +161,6 @@ export declare namespace ObjectType {
             path: PropertyPath;
             shapeIdentifier: BlankNode | NamedNode;
             type: Type;
-            visibility: Visibility;
         });
         equals(other: Property): boolean;
         /**
@@ -204,7 +185,6 @@ export declare namespace ObjectType {
                 recursive: boolean | undefined;
                 shapeIdentifier: BlankNode | NamedNode<string>;
             };
-            visibility: Visibility;
         };
         toString(): string;
     }

package/dist/ast/ObjectType.js

@@ -43,12 +43,6 @@ export class ObjectType extends AbstractType {
      * Mutable to support cycle-handling logic in the compiler.
      */
     #properties = [];
-    /**
-     * Classes generated from this type are abstract / cannot be instantiated themselves.
-     *
-     * Defaults to false.
-     */
-    abstract;
     /**
      * If true, the code for this ObjectType is defined externally and should not be generated.
      *
@@ -95,13 +89,8 @@ export class ObjectType extends AbstractType {
      * import { MyType } from "./MyType.js"
      */
     tsImports;
-    /**
-     * Whether to generate a TypeScript class or interface for this type.
-     */
-    tsObjectDeclarationType;
-    constructor({ abstract, extern, fromRdfType, identifierType, synthetic, toRdfTypes, tsFeatures, tsImports, tsObjectDeclarationType, ...superParameters }) {
+    constructor({ extern, fromRdfType, identifierType, synthetic, toRdfTypes, tsFeatures, tsImports, ...superParameters }) {
         super(superParameters);
-        this.abstract = abstract;
         this.extern = extern;
         this.fromRdfType = fromRdfType;
         this.identifierType = identifierType;
@@ -109,7 +98,6 @@ export class ObjectType extends AbstractType {
         this.toRdfTypes = toRdfTypes;
         this.tsFeatures = tsFeatures;
         this.tsImports = tsImports;
-        this.tsObjectDeclarationType = tsObjectDeclarationType;
     }
     get ancestorObjectTypes() {
         return this.#ancestorObjectTypes;
@@ -224,11 +212,7 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
          * Type of this property.
          */
         type;
-        /**
-         * Visibility: private, protected, public.
-         */
-        visibility;
-        constructor({ comment, description, display, label, mutable, name, objectType, order, path, shapeIdentifier, type, visibility, }) {
+        constructor({ comment, description, display, label, mutable, name, objectType, order, path, shapeIdentifier, type, }) {
             this.comment = comment;
             this.description = description;
             this.display = display;
@@ -240,7 +224,6 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
             this.path = path;
             this.shapeIdentifier = shapeIdentifier;
             this.type = type;
-            this.visibility = visibility;
         }
         equals(other) {
             return this.shapeIdentifier.equals(other.shapeIdentifier);
@@ -373,7 +356,6 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
                 recursive: this.recursive ? true : undefined,
                 shapeIdentifier: this.shapeIdentifier,
                 type: this.type.toJSON(),
-                visibility: this.visibility,
             };
         }
         toString() {

package/dist/generators/ts/AbstractContainerType.d.ts

@@ -24,7 +24,6 @@ import { type Code } from "./ts-poet-wrapper.js";
  * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
  */
 export declare abstract class AbstractContainerType<ItemTypeT extends AbstractContainerType.ItemType> extends AbstractType {
-    readonly abstract = false;
     readonly declaration: Maybe<Code>;
     abstract readonly kind: "DefaultValueType" | "ListType" | "OptionType" | "SetType";
     /**

package/dist/generators/ts/AbstractContainerType.js

@@ -13,7 +13,6 @@ import { code } from "./ts-poet-wrapper.js";
  * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
  */
 export class AbstractContainerType extends AbstractType {
-    abstract = false;
     declaration = Maybe.empty();
     /**
      * Container item type.

package/dist/generators/ts/AbstractLazyObjectType.d.ts

@@ -13,7 +13,6 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
         readonly partialPropertyName: string;
         readonly rawName: Code;
     };
-    readonly abstract = false;
     readonly declaration: Maybe<Code>;
     readonly discriminantProperty: AbstractType["discriminantProperty"];
     readonly mutable = false;

package/dist/generators/ts/AbstractLazyObjectType.js

@@ -9,12 +9,12 @@ import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
 import { removeUndefined } from "./removeUndefined.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class AbstractLazyObjectType extends AbstractType {
     partialType;
     resolveType;
     runtimeClass;
-    abstract = false;
     declaration = Maybe.empty();
     discriminantProperty = Maybe.empty();
     mutable = false;
@@ -124,7 +124,7 @@ export class AbstractLazyObjectType extends AbstractType {
         invariant(resolvedNamedObjectUnionType.members.length ===
             partialNamedObjectUnionType.members.length);
         const caseBlocks = resolvedNamedObjectUnionType.members.map(({ discriminantValues }, memberI) => {
-            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialNamedObjectUnionType.members[memberI].type.newExpression({ parameters: variables.resolvedObjectUnion })};`;
+            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialNamedObjectUnionType.members[memberI].type.name}.${syntheticNamePrefix}create(${variables.resolvedObjectUnion});`;
         });
         caseBlocks.push(code `default: ${variables.resolvedObjectUnion} satisfies never; throw new Error("unrecognized type");`);
         return code `switch (${variables.resolvedObjectUnion}.${resolvedNamedObjectUnionType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} }`;

package/dist/generators/ts/AbstractNamedUnionType.d.ts

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
-import type { TsFeature } from "../../enums/TsFeature.js";
 import { AbstractType } from "./AbstractType.js";
 import { AbstractUnionType } from "./AbstractUnionType.js";
+import type { TsFeature } from "./TsFeature.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractNamedUnionType<MemberTypeT extends Type> extends AbstractUnionType<MemberTypeT> {
@@ -18,7 +18,6 @@ export declare abstract class AbstractNamedUnionType<MemberTypeT extends Type> e
     get jsonSchemaFunctionDeclaration(): Code;
     get jsonTypeAliasDeclaration(): Code;
     get name(): string;
-    get staticModuleName(): string;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     protected get staticModuleDeclarations(): Record<string, Code>;

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -27,7 +27,7 @@ export class AbstractNamedUnionType extends AbstractUnionType {
         const staticModuleDeclarations = Object.entries(this.staticModuleDeclarations);
         if (staticModuleDeclarations.length > 0) {
             declarations.push(code `\
-export namespace ${def(this.staticModuleName)} {
+export namespace ${def(this.name)} {
 ${joinCode(staticModuleDeclarations
                 .sort((left, right) => left[0].localeCompare(right[0]))
                 .map((_) => _[1]), { on: "\n\n" })}
@@ -37,19 +37,19 @@ ${joinCode(staticModuleDeclarations
     }
     get equalsFunction() {
         if (this.features.has("equals")) {
-            return code `${this.staticModuleName}.${syntheticNamePrefix}equals`;
+            return code `${this.name}.${syntheticNamePrefix}equals`;
         }
         return this.inlineEqualsFunction;
     }
     get filterFunction() {
-        return code `${this.staticModuleName}.${syntheticNamePrefix}filter`;
+        return code `${this.name}.${syntheticNamePrefix}filter`;
     }
     get filterType() {
-        return code `${this.staticModuleName}.${syntheticNamePrefix}Filter`;
+        return code `${this.name}.${syntheticNamePrefix}Filter`;
     }
     get jsonSchemaFunctionDeclaration() {
         const meta = {
-            id: this.name,
+        // id: this.name,
         };
         this.comment.ifJust((description) => {
             meta["description"] = description;
@@ -65,18 +65,15 @@ ${joinCode(staticModuleDeclarations
     get name() {
         return this._name;
     }
-    get staticModuleName() {
-        return this._name;
-    }
     get valueSparqlConstructTriplesFunction() {
         if (this.features.has("sparql")) {
-            return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlConstructTriples`;
+            return code `${this.name}.${syntheticNamePrefix}valueSparqlConstructTriples`;
         }
         return this.inlineValueSparqlConstructTriplesFunction;
     }
     get valueSparqlWherePatternsFunction() {
         if (this.features.has("sparql")) {
-            return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlWherePatterns`;
+            return code `${this.name}.${syntheticNamePrefix}valueSparqlWherePatterns`;
         }
         return this.inlineValueSparqlWherePatternsFunction;
     }
@@ -130,30 +127,30 @@ export namespace ${syntheticNamePrefix}Json {
     }
     fromJsonExpression({ variables, }) {
         if (this.features.has("json")) {
-            return code `${this.staticModuleName}.${syntheticNamePrefix}fromJson(${variables.value})`;
+            return code `${this.name}.${syntheticNamePrefix}fromJson(${variables.value})`;
         }
         return code `${this.inlineFromJsonFunction}(${variables.value})`;
     }
     fromRdfResourceValuesExpression({ variables, }) {
         const { resourceValues: resourceValuesVariable, ...otherVariables } = variables;
         if (this.features.has("rdf")) {
-            return code `${this.staticModuleName}.${syntheticNamePrefix}fromRdfResourceValues(${resourceValuesVariable}, ${otherVariables})`;
+            return code `${this.name}.${syntheticNamePrefix}fromRdfResourceValues(${resourceValuesVariable}, ${otherVariables})`;
         }
         return code `${this.inlineFromRdfResourceValuesFunction}(${resourceValuesVariable}, ${otherVariables})`;
     }
     hashStatements({ depth, variables, }) {
         if (this.features.has("hash")) {
             return [
-                code `${this.staticModuleName}.${syntheticNamePrefix}hash(${variables.value}, ${variables.hasher});`,
+                code `${this.name}.${syntheticNamePrefix}hash(${variables.value}, ${variables.hasher});`,
             ];
         }
         return this.inlineHashStatements({ depth, variables });
     }
     jsonSchema({ context, }) {
         if (this.features.has("json")) {
-            const expression = code `${this.staticModuleName}.${syntheticNamePrefix}Json.schema()`;
+            const expression = code `${this.name}.${syntheticNamePrefix}Json.schema()`;
             if (context === "property" && this.recursive) {
-                return code `${imports.z}.lazy((): ${imports.z}.ZodType<${this.staticModuleName}.${syntheticNamePrefix}Json> => ${expression})`;
+                return code `${imports.z}.lazy((): ${imports.z}.ZodType<${this.name}.${syntheticNamePrefix}Json> => ${expression})`;
             }
             return expression;
         }
@@ -161,25 +158,25 @@ export namespace ${syntheticNamePrefix}Json {
     }
     jsonType() {
         if (this.features.has("json")) {
-            return new AbstractType.JsonType(`${this.staticModuleName}.${syntheticNamePrefix}Json`);
+            return new AbstractType.JsonType(`${this.name}.${syntheticNamePrefix}Json`);
         }
         return this.inlineJsonType;
     }
     toJsonExpression({ variables, }) {
         if (this.features.has("json")) {
-            return code `${this.staticModuleName}.${syntheticNamePrefix}toJson(${variables.value})`;
+            return code `${this.name}.${syntheticNamePrefix}toJson(${variables.value})`;
         }
         return code `${this.inlineToJsonFunction}(${variables.value})`;
     }
     toRdfResourceValuesExpression({ variables, }) {
         const { value: valueVariable, ...otherVariables } = variables;
         if (this.features.has("rdf")) {
-            return code `${this.staticModuleName}.${syntheticNamePrefix}toRdfResourceValues(${valueVariable}, ${otherVariables})`;
+            return code `${this.name}.${syntheticNamePrefix}toRdfResourceValues(${valueVariable}, ${otherVariables})`;
         }
         return code `${this.inlineToRdfResourceValuesFunction}(${valueVariable}, ${otherVariables})`;
     }
     toStringExpression({ variables, }) {
-        return code `${this.staticModuleName}.${syntheticNamePrefix}toString(${variables.value})`;
+        return code `${this.name}.${syntheticNamePrefix}toString(${variables.value})`;
     }
 }
 __decorate([

package/dist/generators/ts/AbstractTermType.d.ts

@@ -13,7 +13,6 @@ import { type Code } from "./ts-poet-wrapper.js";
  * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:hasValue and sh:in.
  */
 export declare abstract class AbstractTermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, _RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> extends AbstractType {
-    readonly abstract = false;
     readonly declaration: Maybe<Code>;
     readonly equalsFunction: Code;
     readonly graphqlArgs: AbstractType["graphqlArgs"];

package/dist/generators/ts/AbstractTermType.js

@@ -22,7 +22,6 @@ import { code, joinCode } from "./ts-poet-wrapper.js";
  * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:hasValue and sh:in.
  */
 export class AbstractTermType extends AbstractType {
-    abstract = false;
     declaration = Maybe.empty();
     equalsFunction = code `${snippets.booleanEquals}`;
     graphqlArgs = Maybe.empty();

package/dist/generators/ts/AbstractType.d.ts

@@ -7,10 +7,6 @@ import { type Code } from "./ts-poet-wrapper.js";
  */
 export declare abstract class AbstractType {
     protected readonly logger: Logger;
-    /**
-     * Is the type abstract?
-     */
-    abstract readonly abstract: boolean;
     /**
      * Comment from rdfs:comment.
      */

package/dist/generators/ts/AbstractUnionType.d.ts

@@ -9,7 +9,6 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractUnionType<MemberTypeT extends Type> extends AbstractType {
     private readonly discriminant;
     private readonly identifierType;
-    readonly abstract = false;
     readonly recursive: boolean;
     constructor({ identifierType, members, recursive, ...superParameters }: {
         identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
@@ -26,7 +25,6 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get typeofs(): AbstractType["typeofs"];
-    protected get concreteMembers(): readonly AbstractUnionType.ConcreteMember<MemberTypeT>[];
     protected get inlineEqualsFunction(): Code;
     protected get inlineFilterFunction(): Code;
     protected get inlineFilterType(): Code;
@@ -81,13 +79,7 @@ export declare namespace Discriminant {
     }[]): Discriminant;
 }
 export declare namespace AbstractUnionType {
-    interface AbstractMember<TypeT extends Type> {
-        readonly abstract: true;
-        readonly discriminantValues: readonly AbstractType.DiscriminantProperty.Value[];
-        readonly type: TypeT;
-    }
-    interface ConcreteMember<TypeT extends Type> {
-        readonly abstract: false;
+    interface Member<TypeT extends Type> {
         readonly discriminantValues: readonly AbstractType.DiscriminantProperty.Value[];
         readonly jsonType: Code | string;
         readonly jsonTypeCheck: (instance: Code) => Code;
@@ -98,7 +90,6 @@ export declare namespace AbstractUnionType {
         readonly unwrap: (instance: Code) => Code;
         readonly wrap: (instance: Code) => Code;
     }
-    type Member<TypeT extends Type> = AbstractMember<TypeT> | ConcreteMember<TypeT>;
 }
 export {};
 //# sourceMappingURL=AbstractUnionType.d.ts.map