@shaclmate/compiler 2.0.22 → 2.0.24

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 Maybe.of(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,55 @@ 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.
+        const typeFromRdfExpression = this.type.fromRdfExpression({
+            variables: {
+                ...variables,
+                ignoreRdfType: true,
+                predicate: this.predicate,
+                resourceValues: `purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>>(${variables.resource}.values(${syntheticNamePrefix}properties.${this.name}["identifier"], { unique: true }))`,
+            },
+        });
+        return [
+            `const _${this.name}Either: purify.Either<Error, ${this.type.name}> = ${typeFromRdfExpression}.chain(values => values.head());`,
+            `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 +167,12 @@ 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),
+                languageIn: variables.languageIn,
+                object: `dataFactory.variable!(${objectString})`,
+                predicate: this.predicate,
                 subject: variables.subject,
                 variablePrefix: objectString,
             },
@@ -176,13 +183,41 @@ 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, "equalsFunction", null);
+__decorate([
+    Memoize()
+], 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: Maybe<string>;
+    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 = Maybe.of(`${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,27 +1,25 @@
 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";
 import { toJsonFunctionOrMethodDeclaration } from "./toJsonFunctionOrMethodDeclaration.js";
 import { toRdfFunctionOrMethodDeclaration } from "./toRdfFunctionOrMethodDeclaration.js";
 function constructorDeclaration() {
-    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersPropertySignature
-        .map((propertySignature) => `readonly ${propertySignature.name}${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
-        .toList());
-    let parametersType;
+    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersPropertySignature.toList());
+    const parametersType = [];
     if (parametersPropertySignatures.length > 0) {
-        parametersType = `{ ${parametersPropertySignatures.join(", ")} }`;
-    }
-    else {
-        parametersType = "";
+        parametersType.push(`{ ${parametersPropertySignatures
+            .map((propertySignature) => `readonly ${propertySignature.name}${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
+            .join(", ")} }`);
     }
     if (this.parentObjectTypes.length > 0) {
         // Pass up parameters
-        parametersType = `${parametersType}${parametersType.length > 0 ? " & " : ""}ConstructorParameters<typeof ${this.parentObjectTypes[0].name}>[0]`;
+        parametersType.push(`ConstructorParameters<typeof ${this.parentObjectTypes[0].name}>[0]`);
     }
     if (parametersType.length === 0) {
-        parametersType = "object";
+        parametersType.push("object");
     }
     const statements = [];
     if (this.parentObjectTypes.length > 0) {
@@ -29,8 +27,14 @@ function constructorDeclaration() {
         // of trying to sense whether we need to or not.
         statements.push("super(parameters);");
     }
-    const propertyStatements = this.properties.flatMap((property) => property.classConstructorStatements({
-        variables: { parameter: `parameters.${property.name}` },
+    const parametersHasQuestionToken = this.parentObjectTypes.length === 0 &&
+        parametersPropertySignatures.every((propertySignature) => !!propertySignature.hasQuestionToken);
+    const parametersVariable = `parameters${parametersHasQuestionToken ? "?" : ""}`;
+    const propertyStatements = this.properties.flatMap((property) => property.constructorStatements({
+        variables: {
+            parameter: `${parametersVariable}.${property.name}`,
+            parameters: parametersVariable,
+        },
     }));
     statements.push(...propertyStatements);
     return {
@@ -39,8 +43,9 @@ function constructorDeclaration() {
             : undefined,
         parameters: [
             {
+                hasQuestionToken: parametersHasQuestionToken,
                 name: statements.length > 0 ? "parameters" : "_parameters",
-                type: parametersType,
+                type: parametersType.join(" & "),
             },
         ],
         statements,
@@ -57,8 +62,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 +109,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