@shaclmate/compiler 2.0.22 → 2.0.23

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

@@ -7,33 +7,23 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { pascalCase } from "change-case";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { tsComment } from "../tsComment.js";
 import { Property } from "./Property.js";
 export class ShaclProperty extends Property {
-    mutable;
     comment;
     description;
     label;
     path;
-    constructor({ comment, description, label, mutable, path, ...superParameters }) {
+    constructor({ comment, description, label, path, ...superParameters }) {
         super(superParameters);
         this.comment = comment;
         this.description = description;
         this.label = label;
-        this.mutable = mutable;
         this.path = path;
     }
-    get classGetAccessorDeclaration() {
-        return Maybe.empty();
-    }
-    get classPropertyDeclaration() {
-        return Maybe.of({
-            isReadonly: !this.mutable,
-            leadingTrivia: this.declarationComment,
-            name: this.name,
-            scope: Property.visibilityToScope(this.visibility),
-            type: this.type.name,
-        });
+    get equalsFunction() {
+        return this.type.equalsFunction;
     }
     get constructorParametersPropertySignature() {
         let hasQuestionToken = false;
@@ -54,82 +44,52 @@ export class ShaclProperty extends Property {
             type: [...typeNames].sort().join(" | "),
         });
     }
-    get declarationImports() {
-        return this.type.useImports(this.objectType.features);
-    }
-    get equalsFunction() {
-        return this.type.equalsFunction;
-    }
-    get interfacePropertySignature() {
-        return Maybe.of({
-            isReadonly: !this.mutable,
-            leadingTrivia: this.declarationComment,
-            name: this.name,
-            type: this.type.name,
-        });
-    }
-    get jsonPropertySignature() {
-        return Maybe.of({
-            isReadonly: true,
-            name: this.name,
-            type: this.type.jsonName,
-        });
-    }
-    get snippetDeclarations() {
-        return this.type.snippetDeclarations(this.objectType.features);
-    }
-    get declarationComment() {
-        return this.comment
-            .alt(this.description)
-            .alt(this.label)
-            .map(tsComment)
-            .extract();
-    }
-    get pathExpression() {
-        return `${this.dataFactoryVariable}.namedNode("${this.path.value}")`;
-    }
-    classConstructorStatements({ variables, }) {
+    constructorStatements({ variables, }) {
         const typeConversions = this.type.conversions;
         if (typeConversions.length === 1) {
-            return [`this.${this.name} = ${variables.parameter};`];
+            switch (this.objectType.declarationType) {
+                case "class":
+                    return [`this.${this.name} = ${variables.parameter};`];
+                case "interface":
+                    return [`const ${this.name} = ${variables.parameter};`];
+            }
         }
+        let lhs;
         const statements = [];
-        for (const conversion of this.type.conversions) {
-            statements.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { this.${this.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
+        switch (this.objectType.declarationType) {
+            case "class":
+                lhs = `this.${this.name}`;
+                break;
+            case "interface":
+                lhs = this.name;
+                statements.push(`let ${this.name}: ${this.type.name};`);
+                break;
         }
-        // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
-        statements.push(`{ this.${this.name} =( ${variables.parameter}) as never;\n }`);
-        return [statements.join(" else ")];
+        statements.push(typeConversions
+            .map((conversion) => `if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${lhs} = ${conversion.conversionExpression(variables.parameter)}; }`)
+            // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
+            .concat(`{ ${lhs} = (${variables.parameter}) satisfies never; }`)
+            .join(" else "));
+        return statements;
     }
     fromJsonStatements({ variables, }) {
         return [
             `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: `${variables.jsonObject}["${this.name}"]` } })};`,
         ];
     }
-    fromRdfStatements({ variables, }) {
-        return [
-            `const _${this.name}Either: purify.Either<rdfjsResource.Resource.ValueError, ${this.type.name}> = ${this.type.fromRdfExpression({ variables: { ...variables, predicate: this.pathExpression, resourceValues: `${variables.resource}.values(${this.pathExpression}, { unique: true })` } })};`,
-            `if (_${this.name}Either.isLeft()) { return _${this.name}Either; }`,
-            `const ${this.name} = _${this.name}Either.unsafeCoerce();`,
-        ];
+    get getAccessorDeclaration() {
+        return Maybe.empty();
     }
     hashStatements(parameters) {
         return this.type.hashStatements(parameters);
     }
-    interfaceConstructorStatements({ variables, }) {
-        const typeConversions = this.type.conversions;
-        if (typeConversions.length === 1) {
-            return [`const ${this.name} = ${variables.parameter};`];
-        }
-        const statements = [`let ${this.name}: ${this.type.name};`];
-        const conversionBranches = [];
-        for (const conversion of this.type.conversions) {
-            conversionBranches.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${this.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
-        }
-        // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
-        conversionBranches.push(`{ ${this.name} =( ${variables.parameter}) as never;\n }`);
-        statements.push(conversionBranches.join(" else "));
-        return statements;
+    get jsonPropertySignature() {
+        return Maybe.of({
+            hasQuestionToken: this.type.jsonName.optional,
+            isReadonly: true,
+            name: this.name,
+            type: this.type.jsonName.requiredName,
+        });
     }
     jsonUiSchemaElement({ variables, }) {
         const scope = `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
@@ -138,7 +98,10 @@ export class ShaclProperty extends Property {
             .altLazy(() => Maybe.of(`{ ${this.label.isJust() ? `label: "${this.label.unsafeCoerce()}", ` : ""}scope: ${scope}, type: "Control" }`));
     }
     jsonZodSchema(parameters) {
-        let schema = this.type.jsonZodSchema(parameters);
+        let schema = this.type.jsonZodSchema({
+            ...parameters,
+            context: "property",
+        });
         this.comment.alt(this.description).ifJust((description) => {
             schema = `${schema}.describe(${JSON.stringify(description)})`;
         });
@@ -147,13 +110,47 @@ export class ShaclProperty extends Property {
             schema,
         });
     }
+    get propertyDeclaration() {
+        return Maybe.of({
+            isReadonly: !this.mutable,
+            leadingTrivia: this.declarationComment,
+            name: this.name,
+            scope: ShaclProperty.visibilityToScope(this.visibility),
+            type: this.type.name,
+        });
+    }
+    get declarationImports() {
+        return this.type.useImports({ features: this.objectType.features });
+    }
+    get propertySignature() {
+        return Maybe.of({
+            isReadonly: !this.mutable,
+            leadingTrivia: this.declarationComment,
+            name: this.name,
+            type: this.type.name,
+        });
+    }
+    snippetDeclarations(parameters) {
+        return this.type.snippetDeclarations(parameters);
+    }
+    fromRdfStatements({ variables, }) {
+        // Assume the property has the correct range and ignore the object's RDF type.
+        // This also accommodates the case where the object of a property is a dangling identifier that's not the
+        // subject of any statements.
+        return [
+            `const _${this.name}Either: purify.Either<Error, ${this.type.name}> = ${this.type.fromRdfExpression({ variables: { ...variables, ignoreRdfType: true, predicate: this.predicate, resourceValues: `${variables.resource}.values(${syntheticNamePrefix}properties.${this.name}["identifier"], { unique: true })` } })};`,
+            `if (_${this.name}Either.isLeft()) { return _${this.name}Either; }`,
+            `const ${this.name} = _${this.name}Either.unsafeCoerce();`,
+        ];
+    }
     sparqlConstructTemplateTriples({ variables, }) {
         const objectString = `\`\${${variables.variablePrefix}}${pascalCase(this.name)}\``;
         return this.type.sparqlConstructTemplateTriples({
-            context: "property",
+            allowIgnoreRdfType: true,
+            context: "object",
             variables: {
-                object: `${this.dataFactoryVariable}.variable!(${objectString})`,
-                predicate: this.rdfjsTermExpression(this.path),
+                object: `dataFactory.variable!(${objectString})`,
+                predicate: this.predicate,
                 subject: variables.subject,
                 variablePrefix: objectString,
             },
@@ -162,10 +159,11 @@ export class ShaclProperty extends Property {
     sparqlWherePatterns({ variables, }) {
         const objectString = `\`\${${variables.variablePrefix}}${pascalCase(this.name)}\``;
         return this.type.sparqlWherePatterns({
-            context: "property",
+            allowIgnoreRdfType: true,
+            context: "object",
             variables: {
-                object: `${this.dataFactoryVariable}.variable!(${objectString})`,
-                predicate: this.rdfjsTermExpression(this.path),
+                object: `dataFactory.variable!(${objectString})`,
+                predicate: this.predicate,
                 subject: variables.subject,
                 variablePrefix: objectString,
             },
@@ -176,13 +174,38 @@ export class ShaclProperty extends Property {
     }
     toRdfStatements({ variables, }) {
         return [
-            `${variables.resource}.add(${this.pathExpression}, ${this.type.toRdfExpression({
-                variables: { ...variables, predicate: this.pathExpression },
+            `${variables.resource}.add(${this.predicate}, ${this.type.toRdfExpression({
+                variables: { ...variables, predicate: this.predicate },
             })});`,
         ];
     }
+    get declarationComment() {
+        return this.comment
+            .alt(this.description)
+            .alt(this.label)
+            .map(tsComment)
+            .extract();
+    }
+    get predicate() {
+        return `${this.objectType.staticModuleName}.${syntheticNamePrefix}properties.${this.name}["identifier"]`;
+    }
 }
 __decorate([
     Memoize()
-], ShaclProperty.prototype, "pathExpression", null);
+], ShaclProperty.prototype, "constructorParametersPropertySignature", null);
+__decorate([
+    Memoize()
+], ShaclProperty.prototype, "jsonPropertySignature", null);
+__decorate([
+    Memoize()
+], ShaclProperty.prototype, "propertyDeclaration", null);
+__decorate([
+    Memoize()
+], ShaclProperty.prototype, "declarationImports", null);
+__decorate([
+    Memoize()
+], ShaclProperty.prototype, "propertySignature", null);
+__decorate([
+    Memoize()
+], ShaclProperty.prototype, "predicate", null);
 //# sourceMappingURL=ShaclProperty.js.map

package/dist/generators/ts/_ObjectType/TypeDiscriminatorProperty.d.ts

@@ -1,33 +1,34 @@
-import type { Import } from "generators/ts/Import.js";
 import { Maybe } from "purify-ts";
 import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
+import type { Import } from "../Import.js";
 import { Property } from "./Property.js";
 export declare class TypeDiscriminatorProperty extends Property<TypeDiscriminatorProperty.Type> {
-    readonly equalsFunction = "strictEquals";
-    readonly mutable = false;
-    readonly value: string;
     private readonly abstract;
     private readonly override;
-    constructor({ abstract, override, type, value, ...superParameters }: {
+    readonly constructorParametersPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
+    readonly declarationImports: readonly Import[];
+    readonly equalsFunction = "$strictEquals";
+    readonly getAccessorDeclaration: Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
+    readonly graphqlField: Property<TypeDiscriminatorProperty.Type>["graphqlField"];
+    readonly initializer: string;
+    readonly mutable = false;
+    readonly recursive = false;
+    constructor({ abstract, initializer, override, type, ...superParameters }: {
         abstract: boolean;
+        initializer: string;
         override: boolean;
         type: TypeDiscriminatorProperty.Type;
-        value: string;
     } & ConstructorParameters<typeof Property>[0]);
-    get classGetAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
-    get classPropertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
-    get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    get declarationImports(): readonly Import[];
-    get interfacePropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
     get jsonPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    get snippetDeclarations(): readonly string[];
-    classConstructorStatements(): readonly string[];
+    constructorStatements(): readonly string[];
     fromJsonStatements(): readonly string[];
     fromRdfStatements(): readonly string[];
     hashStatements({ variables, }: Parameters<Property<TypeDiscriminatorProperty>["hashStatements"]>[0]): readonly string[];
-    interfaceConstructorStatements(): readonly string[];
     jsonUiSchemaElement({ variables, }: Parameters<Property<TypeDiscriminatorProperty.Type>["jsonUiSchemaElement"]>[0]): Maybe<string>;
     jsonZodSchema({ variables, }: Parameters<Property<TypeDiscriminatorProperty.Type>["jsonZodSchema"]>[0]): ReturnType<Property<TypeDiscriminatorProperty.Type>["jsonZodSchema"]>;
+    get propertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
+    get propertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    snippetDeclarations(): readonly string[];
     sparqlConstructTemplateTriples(): readonly string[];
     sparqlWherePatterns(): readonly string[];
     toJsonObjectMember({ variables, }: Parameters<Property<TypeDiscriminatorProperty.Type>["toJsonObjectMember"]>[0]): Maybe<string>;
@@ -36,12 +37,15 @@ export declare class TypeDiscriminatorProperty extends Property<TypeDiscriminato
 export declare namespace TypeDiscriminatorProperty {
     class Type {
         readonly mutable: boolean;
-        readonly values: readonly string[];
-        constructor({ mutable, values, }: {
+        readonly descendantValues: readonly string[];
+        readonly ownValues: readonly string[];
+        constructor({ descendantValues, mutable, ownValues, }: {
+            descendantValues: readonly string[];
             mutable: boolean;
-            values: readonly string[];
+            ownValues: readonly string[];
         });
         get name(): string;
+        get values(): string[];
     }
 }
 //# sourceMappingURL=TypeDiscriminatorProperty.d.ts.map

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

@@ -8,49 +8,25 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { SnippetDeclarations } from "../SnippetDeclarations.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { Property } from "./Property.js";
 export class TypeDiscriminatorProperty extends Property {
-    equalsFunction = "strictEquals";
-    mutable = false;
-    value;
     abstract;
     override;
-    constructor({ abstract, override, type, value, ...superParameters }) {
+    constructorParametersPropertySignature = Maybe.empty();
+    declarationImports = [];
+    equalsFunction = `${syntheticNamePrefix}strictEquals`;
+    getAccessorDeclaration = Maybe.empty();
+    graphqlField = Maybe.empty();
+    initializer;
+    mutable = false;
+    recursive = false;
+    constructor({ abstract, initializer, override, type, ...superParameters }) {
         super({ ...superParameters, type });
         invariant(this.visibility === "public");
         this.abstract = abstract;
+        this.initializer = initializer;
         this.override = override;
-        this.value = value;
-    }
-    get classGetAccessorDeclaration() {
-        return Maybe.empty();
-    }
-    get classPropertyDeclaration() {
-        return Maybe.of({
-            // Work around a ts-morph bug that puts the override keyword before the abstract keyword
-            isAbstract: this.abstract && this.override ? undefined : this.abstract,
-            hasOverrideKeyword: this.abstract && this.override ? undefined : this.override,
-            initializer: !this.abstract ? `"${this.value}"` : undefined,
-            isReadonly: true,
-            leadingTrivia: this.abstract && this.override ? "abstract override " : undefined,
-            name: this.name,
-            type: !this.abstract && this.type.name === `"${this.value}"`
-                ? undefined
-                : this.type.name,
-        });
-    }
-    get constructorParametersPropertySignature() {
-        return Maybe.empty();
-    }
-    get declarationImports() {
-        return [];
-    }
-    get interfacePropertySignature() {
-        return Maybe.of({
-            isReadonly: true,
-            name: this.name,
-            type: this.type.name,
-        });
     }
     get jsonPropertySignature() {
         return Maybe.of({
@@ -59,35 +35,31 @@ export class TypeDiscriminatorProperty extends Property {
             type: this.type.name,
         });
     }
-    get snippetDeclarations() {
-        const snippetDeclarations = [];
-        if (this.objectType.features.has("equals")) {
-            snippetDeclarations.push(SnippetDeclarations.strictEquals);
+    constructorStatements() {
+        switch (this.objectType.declarationType) {
+            case "class":
+                return [];
+            case "interface":
+                if (this.abstract) {
+                    return [];
+                }
+                return [`const ${this.name} = "${this.initializer}" as const`];
         }
-        return snippetDeclarations;
-    }
-    classConstructorStatements() {
-        return [];
     }
     fromJsonStatements() {
         return this.fromRdfStatements();
     }
     fromRdfStatements() {
         return !this.abstract && this.objectType.declarationType === "interface"
-            ? [`const ${this.name} = "${this.value}" as const`]
+            ? [`const ${this.name} = "${this.initializer}" as const`]
             : [];
     }
     hashStatements({ variables, }) {
         return [`${variables.hasher}.update(${variables.value});`];
     }
-    interfaceConstructorStatements() {
-        return !this.abstract
-            ? [`const ${this.name} = "${this.value}" as const`]
-            : [];
-    }
     jsonUiSchemaElement({ variables, }) {
         const scope = `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
-        return Maybe.of(`{ rule: { condition: { schema: { const: "${this.value}" }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
+        return Maybe.of(`{ rule: { condition: { schema: { const: "${this.initializer}" }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
     }
     jsonZodSchema({ variables, }) {
         return Maybe.of({
@@ -97,6 +69,34 @@ export class TypeDiscriminatorProperty extends Property {
                 : `${variables.zod}.literal("${this.type.values[0]}")`,
         });
     }
+    get propertyDeclaration() {
+        return Maybe.of({
+            // Work around a ts-morph bug that puts the override keyword before the abstract keyword
+            isAbstract: this.abstract && this.override ? undefined : this.abstract,
+            hasOverrideKeyword: this.abstract && this.override ? undefined : this.override,
+            initializer: !this.abstract ? `"${this.initializer}"` : undefined,
+            isReadonly: true,
+            leadingTrivia: this.abstract && this.override ? "abstract override " : undefined,
+            name: this.name,
+            type: !this.abstract && this.type.name === `"${this.initializer}"`
+                ? undefined
+                : this.type.name,
+        });
+    }
+    get propertySignature() {
+        return Maybe.of({
+            isReadonly: true,
+            name: this.name,
+            type: this.type.name,
+        });
+    }
+    snippetDeclarations() {
+        const snippetDeclarations = [];
+        if (this.objectType.features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.strictEquals);
+        }
+        return snippetDeclarations;
+    }
     sparqlConstructTemplateTriples() {
         return [];
     }
@@ -113,18 +113,26 @@ export class TypeDiscriminatorProperty extends Property {
 (function (TypeDiscriminatorProperty) {
     class Type {
         mutable;
-        values;
-        constructor({ mutable, values, }) {
+        descendantValues;
+        ownValues;
+        constructor({ descendantValues, mutable, ownValues, }) {
+            this.descendantValues = descendantValues;
             this.mutable = mutable;
-            this.values = values;
+            this.ownValues = ownValues;
         }
         get name() {
             return this.values.map((name) => `"${name}"`).join(" | ");
         }
+        get values() {
+            return this.ownValues.concat(this.descendantValues);
+        }
     }
     __decorate([
         Memoize()
     ], Type.prototype, "name", null);
+    __decorate([
+        Memoize()
+    ], Type.prototype, "values", null);
     TypeDiscriminatorProperty.Type = Type;
 })(TypeDiscriminatorProperty || (TypeDiscriminatorProperty = {}));
 //# sourceMappingURL=TypeDiscriminatorProperty.js.map

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

@@ -1,5 +1,6 @@
 import { Maybe } from "purify-ts";
 import { StructureKind, } from "ts-morph";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { tsComment } from "../tsComment.js";
 import { equalsFunctionOrMethodDeclaration } from "./equalsFunctionOrMethodDeclaration.js";
 import { hashFunctionOrMethodDeclarations } from "./hashFunctionOrMethodDeclarations.js";
@@ -29,7 +30,7 @@ function constructorDeclaration() {
         // of trying to sense whether we need to or not.
         statements.push("super(parameters);");
     }
-    const propertyStatements = this.properties.flatMap((property) => property.classConstructorStatements({
+    const propertyStatements = this.properties.flatMap((property) => property.constructorStatements({
         variables: { parameter: `parameters.${property.name}` },
     }));
     statements.push(...propertyStatements);
@@ -57,8 +58,8 @@ export function classDeclaration() {
     const getAccessors = [];
     const properties = [];
     for (const property of this.properties) {
-        property.classPropertyDeclaration.ifJust((propertyDeclaration) => properties.push(propertyDeclaration));
-        property.classGetAccessorDeclaration.ifJust((getAccessor) => getAccessors.push(getAccessor));
+        property.propertyDeclaration.ifJust((propertyDeclaration) => properties.push(propertyDeclaration));
+        property.getAccessorDeclaration.ifJust((getAccessor) => getAccessors.push(getAccessor));
     }
     return Maybe.of({
         ctors: [constructorDeclaration.bind(this)()],
@@ -104,14 +105,14 @@ function toRdfMethodDeclaration() {
     }));
 }
 function toStringMethodDeclaration() {
-    if (!this.features.has("toJson")) {
+    if (!this.features.has("json")) {
         return Maybe.empty();
     }
     return Maybe.of({
         hasOverrideKeyword: this.parentObjectTypes.length > 0,
         name: "toString",
         returnType: "string",
-        statements: ["return JSON.stringify(this.toJson());"],
+        statements: [`return JSON.stringify(this.${syntheticNamePrefix}toJson());`],
     });
 }
 //# sourceMappingURL=classDeclaration.js.map

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

@@ -1,6 +1,7 @@
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { StructureKind } from "ts-morph";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 export function createFunctionDeclaration() {
     if (!this.features.has("create")) {
         return Maybe.empty();
@@ -17,16 +18,16 @@ export function createFunctionDeclaration() {
     // Should always have at least an identifier
     invariant(parametersPropertySignatures.length > 0);
     const parametersType = [`{ ${parametersPropertySignatures.join(", ")} }`]
-        .concat(this.parentObjectTypes.map((parentObjectType) => `Parameters<typeof ${parentObjectType.name}.create>[0]`))
+        .concat(this.parentObjectTypes.map((parentObjectType) => `Parameters<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}create>[0]`))
         .join(" & ");
     const propertyInitializers = [];
     const omitPropertyNames = [];
     const propertyStatements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        propertyInitializers.push(`...${parentObjectType.name}.create(parameters)`);
+        propertyInitializers.push(`...${parentObjectType.staticModuleName}.${syntheticNamePrefix}create(parameters)`);
     }
     for (const property of this.properties) {
-        const thisPropertyStatements = property.interfaceConstructorStatements({
+        const thisPropertyStatements = property.constructorStatements({
             variables: { parameter: `parameters.${property.name}` },
         });
         if (thisPropertyStatements.length > 0) {
@@ -42,7 +43,7 @@ export function createFunctionDeclaration() {
     return Maybe.of({
         isExported: true,
         kind: StructureKind.Function,
-        name: "create",
+        name: `${syntheticNamePrefix}create`,
         parameters: [
             {
                 name: "parameters",

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

@@ -1,4 +1,5 @@
 import { Maybe } from "purify-ts";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 export function equalsFunctionOrMethodDeclaration() {
     if (!this.features.has("equals")) {
         return Maybe.empty();
@@ -23,14 +24,14 @@ export function equalsFunctionOrMethodDeclaration() {
     if (this.parentObjectTypes.length > 0) {
         switch (this.declarationType) {
             case "class": {
-                chain.push("super.equals(other)");
+                chain.push(`super.${syntheticNamePrefix}equals(other)`);
                 hasOverrideKeyword = true;
                 break;
             }
             case "interface": {
                 // For every parent, find the nearest equals implementation
                 for (const parentObjectType of this.parentObjectTypes) {
-                    chain.push(`${parentObjectType.name}.equals(left, right)`);
+                    chain.push(`${parentObjectType.staticModuleName}.${syntheticNamePrefix}equals(left, right)`);
                 }
                 break;
             }
@@ -41,7 +42,7 @@ export function equalsFunctionOrMethodDeclaration() {
     }
     return Maybe.of({
         hasOverrideKeyword,
-        name: "equals",
+        name: `${syntheticNamePrefix}equals`,
         parameters: this.declarationType === "interface"
             ? [
                 {
@@ -59,7 +60,7 @@ export function equalsFunctionOrMethodDeclaration() {
                     type: this.name,
                 },
             ],
-        returnType: "EqualsResult",
+        returnType: `${syntheticNamePrefix}EqualsResult`,
         statements: [
             `return ${chain
                 .map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : `chain(() => ${chainPart})`)

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

@@ -1,5 +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>;
+export declare function fromRdfTypeVariableStatement(this: ObjectType): Maybe<VariableStatementStructure>;
 //# sourceMappingURL=fromRdfTypeVariableStatement.d.ts.map

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

@@ -1,7 +1,9 @@
 import { Maybe } from "purify-ts";
-import { StructureKind } from "ts-morph";
-export function fromRdfTypeVariableDeclaration() {
-    if (!this.features.has("fromRdf")) {
+import { StructureKind, VariableDeclarationKind, } from "ts-morph";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+export function fromRdfTypeVariableStatement() {
+    if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
     if (this.extern) {
@@ -11,11 +13,12 @@ export function fromRdfTypeVariableDeclaration() {
         return Maybe.empty();
     }
     return Maybe.of({
+        declarationKind: VariableDeclarationKind.Const,
         kind: StructureKind.VariableStatement,
         declarations: [
             {
-                name: "fromRdfType",
-                initializer: this.rdfjsTermExpression(this.fromRdfType.unsafeCoerce()),
+                name: `${syntheticNamePrefix}fromRdfType`,
+                initializer: rdfjsTermExpression(this.fromRdfType.unsafeCoerce()),
                 type: "rdfjs.NamedNode<string>",
             },
         ],