@shaclmate/compiler 4.0.24 → 4.0.25

package/dist/generators/ts/AbstractUnionType.js

@@ -16,7 +16,6 @@ import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class AbstractUnionType extends AbstractType {
     discriminant;
     identifierType;
-    abstract = false;
     recursive;
     constructor({ identifierType, members, recursive, ...superParameters }) {
         super(superParameters);
@@ -25,9 +24,6 @@ export class AbstractUnionType extends AbstractType {
         this.recursive = recursive;
         this.discriminant = Discriminant.infer(members);
         this.lazyMembers = () => members.map((member, memberI) => {
-            if (member.type.abstract) {
-                return { abstract: true, discriminantValues: [], type: member.type };
-            }
             let discriminantValues;
             invariant(this.discriminant.memberValues.length === members.length);
             switch (this.discriminant.kind) {
@@ -69,9 +65,7 @@ export class AbstractUnionType extends AbstractType {
                 default:
                     throw this.discriminant;
             }
-            if (discriminantValues.length === 0) {
-                return { abstract: true, discriminantValues: [], type: member.type };
-            }
+            invariant(discriminantValues.length > 0);
             const typeCheck = (json) => (instance) => {
                 const discriminant = this.discriminant; // To get type narrowing to work
                 if (discriminant.kind === "typeof") {
@@ -82,13 +76,12 @@ export class AbstractUnionType extends AbstractType {
                         case "NamedObjectUnionType":
                         case "NamedUnionType":
                         case "NamedObjectType":
-                            return code `${member.type.staticModuleName}.is${member.type.name}(${instance})`;
+                            return code `${member.type.name}.is${member.type.name}(${instance})`;
                     }
                 }
                 return code `(${joinCode(discriminantValues.map((discriminantValue) => code `${instance}.${discriminant.name} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
             };
             return {
-                abstract: false,
                 discriminantValues,
                 jsonType: member.type.jsonType({
                     includeDiscriminantProperty: this.discriminant.kind === "intrinsic" ||
@@ -150,7 +143,7 @@ export class AbstractUnionType extends AbstractType {
                     },
                 ];
             case "typeof":
-                return this.concreteMembers.map(({ primaryDiscriminantValue, type, typeCheck }) => ({
+                return this.members.map(({ primaryDiscriminantValue, type, typeCheck }) => ({
                     conversionExpression: (value) => value,
                     sourceTypeCheckExpression: (value) => typeCheck(value),
                     sourceTypeName: type.name,
@@ -202,7 +195,7 @@ export class AbstractUnionType extends AbstractType {
             //   kind: '"extrinsic" | "intrinsic" | "typeof"',
             // },
             kind: code `${literalOf(this.kind.substring(0, this.kind.length - "Type".length))}`,
-            members: code `{ ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}: ${{
+            members: code `{ ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}: ${{
                 discriminantValues: code `readonly (number | string)[]`,
                 type: type.schemaType,
             }}`), { on: ";" })} }`,
@@ -218,15 +211,12 @@ export class AbstractUnionType extends AbstractType {
         return set;
     }
     get typeofs() {
-        return NonEmptyList.fromArray(this.concreteMembers.flatMap((member) => member.type.typeofs)).unsafeCoerce();
-    }
-    get concreteMembers() {
-        return this.members.filter((member) => !member.abstract);
+        return NonEmptyList.fromArray(this.members.flatMap((member) => member.type.typeofs)).unsafeCoerce();
     }
     get inlineEqualsFunction() {
         return code `\
 ((left: ${this.name}, right: ${this.name}) => {
-${joinCode(this.concreteMembers.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `left`)} && ${typeCheck(code `right`)}) {
+${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `left`)} && ${typeCheck(code `right`)}) {
   return ${type.equalsFunction}(${unwrap(code `left`)} as ${type.name}, ${unwrap(code `right`)} as ${type.name});
 }`))}
 
@@ -243,7 +233,7 @@ if (filter.${syntheticNamePrefix}identifier !== undefined && !${identifierType.f
   return false;
 }`)
                 .toList(),
-            ...this.concreteMembers.map(({ primaryDiscriminantValue, type, typeCheck, unwrap }) => code `\
+            ...this.members.map(({ primaryDiscriminantValue, type, typeCheck, unwrap }) => code `\
 if (filter.on?.[${literalOf(primaryDiscriminantValue)}] !== undefined && ${typeCheck(code `value`)}) {
   if (!${type.filterFunction}(filter.on[${literalOf(primaryDiscriminantValue)}], ${unwrap(code `value`)})) {
     return false;
@@ -258,13 +248,13 @@ if (filter.on?.[${literalOf(primaryDiscriminantValue)}] !== undefined && ${typeC
         return code `\
   {
    ${this.identifierType.map((identifierType) => code `readonly ${syntheticNamePrefix}identifier?: ${identifierType.filterType};`).orDefault(code ``)}
-   readonly on?: { ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}?: ${type.filterType}`), { on: ";" })} }
+   readonly on?: { ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}?: ${type.filterType}`), { on: ";" })} }
   }`;
     }
     get inlineFromJsonFunction() {
         return code `\
 ((value: ${this.jsonType().name}): ${this.name} => {
-${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) => code `if (${jsonTypeCheck(code `value`)}) { return ${wrap(type.fromJsonExpression({
+${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) => code `if (${jsonTypeCheck(code `value`)}) { return ${wrap(type.fromJsonExpression({
             variables: {
                 value: code `(${unwrap(code `value`)} as ${jsonType})`,
             },
@@ -287,7 +277,7 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
 (((values, _options) =>
     values.chain(values => values.chainMap(value => {
       const valueAsValues = ${imports.Right}(value.toValues());
-      return ${this.concreteMembers.reduce((expression, { type, primaryDiscriminantValue }, memberI) => {
+      return ${this.members.reduce((expression, { type, primaryDiscriminantValue }, memberI) => {
             let typeExpression = type.fromRdfResourceValuesExpression({
                 variables: {
                     context: variables.context,
@@ -317,9 +307,9 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
             case "extrinsic":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
+                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
             case "hybrid":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ primaryDiscriminantValue, type }, memberI) => {
+                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
                         case "extrinsic":
                             return code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`;
@@ -333,12 +323,12 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
                     }
                 }), { on: "," })}]).readonly()`;
             case "intrinsic":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({
+                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type }) => type.jsonSchema({
                     includeDiscriminantProperty: true,
                     context: "type",
                 })), { on: "," })}]).readonly()`;
             case "typeof":
-                return code `${imports.z}.union([${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
+                return code `${imports.z}.union([${joinCode(this.members.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
             default:
                 throw discriminant;
         }
@@ -347,9 +337,9 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
             case "extrinsic":
-                return new AbstractType.JsonType(code `(${joinCode(this.concreteMembers.map(({ jsonType, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`), { on: "|" })})`);
+                return new AbstractType.JsonType(code `(${joinCode(this.members.map(({ jsonType, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`), { on: "|" })})`);
             case "hybrid":
-                return new AbstractType.JsonType(code `(${joinCode(this.concreteMembers.map(({ jsonType, primaryDiscriminantValue }, memberI) => {
+                return new AbstractType.JsonType(code `(${joinCode(this.members.map(({ jsonType, primaryDiscriminantValue }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
                         case "extrinsic":
                             return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`;
@@ -361,7 +351,7 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
                 }), { on: "|" })})`);
             case "intrinsic":
             case "typeof":
-                return new AbstractType.JsonType(joinCode(this.concreteMembers.map(({ jsonType }) => code `${jsonType}`), { on: "|" }));
+                return new AbstractType.JsonType(joinCode(this.members.map(({ jsonType }) => code `${jsonType}`), { on: "|" }));
             default:
                 throw discriminant;
         }
@@ -370,9 +360,9 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
             case "extrinsic":
-                return code `(${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.name} }`), { on: "|" })})`;
+                return code `(${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.name} }`), { on: "|" })})`;
             case "hybrid":
-                return code `(${joinCode(this.concreteMembers.map(({ primaryDiscriminantValue, type }, memberI) => {
+                return code `(${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
                         case "extrinsic":
                             return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.name} }`;
@@ -398,7 +388,7 @@ ${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wr
     get inlineToJsonFunction() {
         return code `\
 ((value: ${this.name}): ${this.jsonType().name} => {
-${joinCode(this.concreteMembers.map(({ typeCheck, typeToJsonExpression, unwrap, wrap }) => code `if (${typeCheck(code `value`)}) { return ${wrap(typeToJsonExpression(unwrap(code `value`)))}; }`))}
+${joinCode(this.members.map(({ typeCheck, typeToJsonExpression, unwrap, wrap }) => code `if (${typeCheck(code `value`)}) { return ${wrap(typeToJsonExpression(unwrap(code `value`)))}; }`))}
 
   throw new Error("unable to serialize to JSON");
 })`;
@@ -418,7 +408,7 @@ ${joinCode(this.concreteMembers.map(({ typeCheck, typeToJsonExpression, unwrap,
                     throw new Error();
             }
         }), { on: " | " })})[] => {
-${joinCode(this.concreteMembers.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(code `value`)}) { return ${type.toRdfResourceValuesExpression({
+${joinCode(this.members.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(code `value`)}) { return ${type.toRdfResourceValuesExpression({
             variables: {
                 graph: code `_options.graph`,
                 propertyPath: code `_options.propertyPath`,
@@ -434,7 +424,7 @@ ${joinCode(this.concreteMembers.map(({ type, unwrap, typeCheck }) => code `if ($
     get inlineToStringFunction() {
         return code `\
 ((value: ${this.name}): string => {
-${joinCode(this.concreteMembers.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.toStringExpression({
+${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.toStringExpression({
             variables: { value: unwrap(code `value`) },
         })}; }`))}
 
@@ -446,7 +436,7 @@ ${joinCode(this.concreteMembers.map(({ type, typeCheck, unwrap }) => code `if ($
 ((({ ignoreRdfType, filter, schema, ...otherParameters }) => {
   let triples: ${imports.sparqljs}.Triple[] = [];
 
-  ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `\
+  ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `\
 triples = triples.concat(${type.valueSparqlConstructTriplesFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }));`))}
   
   return triples;
@@ -457,7 +447,7 @@ triples = triples.concat(${type.valueSparqlConstructTriplesFunction}({ ...otherP
 ((({ filter, schema, ...otherParameters }) => {
   const unionPatterns: ${imports.sparqljs}.GroupPattern[] = [];
 
-  ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `\
+  ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `\
 unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }).concat(), type: "group" });`))}
   
   return [{ patterns: unionPatterns, type: "union" }];
@@ -466,7 +456,7 @@ unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...oth
     get schemaObject() {
         return {
             ...super.schemaObject,
-            members: code `{ ${joinCode(this.concreteMembers.map(({ discriminantValues, type, primaryDiscriminantValue }) => code `${literalOf(primaryDiscriminantValue)}: ${{
+            members: code `{ ${joinCode(this.members.map(({ discriminantValues, type, primaryDiscriminantValue }) => code `${literalOf(primaryDiscriminantValue)}: ${{
                 discriminantValues: discriminantValues,
                 type: type.schema,
             }}`), { on: "," })} }`,
@@ -476,7 +466,7 @@ unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...oth
         return Maybe.empty();
     }
     inlineHashStatements({ depth, variables, }) {
-        return this.concreteMembers.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(variables.value)}) { ${joinCode(type
+        return this.members.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(variables.value)}) { ${joinCode(type
             .hashStatements({
             depth: depth + 1,
             variables: {
@@ -509,9 +499,6 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractUnionType.prototype, "typeofs", null);
-__decorate([
-    Memoize()
-], AbstractUnionType.prototype, "concreteMembers", null);
 __decorate([
     Memoize()
 ], AbstractUnionType.prototype, "inlineEqualsFunction", null);

package/dist/generators/ts/LazyObjectOptionType.js

@@ -9,6 +9,7 @@ import { Memoize } from "typescript-memoize";
 import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 import { imports } from "./imports.js";
 import { snippets } from "./snippets.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
 const Super = (AbstractLazyObjectType);
 export class LazyObjectOptionType extends Super {
@@ -30,12 +31,12 @@ export class LazyObjectOptionType extends Super {
         const conversions = super.conversions.concat();
         if (this.partialType.itemType.kind === "NamedObjectType") {
             conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => ${this.partialType.itemType.newExpression({ parameters: code `object` })}), resolver: async () => ${imports.Right}((${value} as ${imports.Maybe}<${this.resolveType.itemType.name}>).unsafeCoerce()) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(${this.partialType.itemType.name}.${syntheticNamePrefix}create), resolver: async () => ${imports.Right}((${value} as ${imports.Maybe}<${this.resolveType.itemType.name}>).unsafeCoerce()) })`,
                 sourceTypeCheckExpression: (value) => code `${imports.Maybe}.isMaybe(${value})`,
                 sourceTypeName: code `${imports.Maybe}<${this.resolveType.itemType.name}>`,
                 sourceTypeof: "object",
             }, {
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${imports.Maybe}.of(${this.partialType.itemType.newExpression({ parameters: value })}), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.itemType.name}) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${imports.Maybe}.of(${this.partialType.itemType.name}.${syntheticNamePrefix}create(${value})), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.itemType.name}) })`,
                 // Don't check instanceof value since the NamedObjectUnionType may be an interface
                 // Rely on the fact that this will be the last type check on an object
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,

package/dist/generators/ts/LazyObjectSetType.js

@@ -9,6 +9,7 @@ import { Memoize } from "typescript-memoize";
 import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 import { imports } from "./imports.js";
 import { snippets } from "./snippets.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
 export class LazyObjectSetType extends AbstractLazyObjectType {
     graphqlArgs = Maybe.of({
@@ -36,7 +37,7 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
         const conversions = super.conversions.concat();
         if (this.partialType.itemType.kind === "NamedObjectType") {
             conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => ${this.partialType.itemType.newExpression({ parameters: code `object` })}), resolver: async () => ${imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(${this.partialType.itemType.name}.${syntheticNamePrefix}create), resolver: async () => ${imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
                 sourceTypeName: code `readonly ${this.resolveType.itemType.name}[]`,
                 sourceTypeof: "object",

package/dist/generators/ts/LazyObjectType.js

@@ -2,6 +2,7 @@ import { Maybe } from "purify-ts";
 import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 import { imports } from "./imports.js";
 import { snippets } from "./snippets.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
 export class LazyObjectType extends AbstractLazyObjectType {
     graphqlArgs = Maybe.empty();
@@ -22,7 +23,7 @@ export class LazyObjectType extends AbstractLazyObjectType {
         const conversions = super.conversions.concat();
         if (this.partialType.kind === "NamedObjectType") {
             conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.newExpression({ parameters: value })}, resolver: async () => ${imports.Right}(${value} as ${this.resolveType.name}) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.name}.${syntheticNamePrefix}create(${value}), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.name}) })`,
                 // Don't check instanceof value since the NamedObjectType may be an interface
                 // Rely on the fact that this will be the last type check on an object
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,

package/dist/generators/ts/NamedObjectType.d.ts

@@ -1,7 +1,5 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe, NonEmptyList } from "purify-ts";
-import type { TsFeature } from "../../enums/TsFeature.js";
-import type { TsObjectDeclarationType } from "../../enums/TsObjectDeclarationType.js";
 import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
 import { IdentifierProperty as _IdentifierProperty } from "./_NamedObjectType/IdentifierProperty.js";
 import type { Property as _Property } from "./_NamedObjectType/Property.js";
@@ -10,13 +8,12 @@ import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
+import type { TsFeature } from "./TsFeature.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class NamedObjectType extends AbstractType {
     private readonly imports;
     protected readonly toRdfTypes: readonly NamedNode[];
-    readonly abstract: boolean;
-    readonly declarationType: TsObjectDeclarationType;
     readonly extern: boolean;
     readonly features: ReadonlySet<TsFeature>;
     readonly fromRdfType: Maybe<NamedNode>;
@@ -25,13 +22,10 @@ export declare class NamedObjectType extends AbstractType {
     readonly kind = "NamedObjectType";
     readonly name: string;
     readonly recursive: boolean;
-    readonly staticModuleName: string;
     readonly synthetic: boolean;
     readonly typeofs: NonEmptyList<"object">;
-    constructor({ abstract, declarationType, extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, staticModuleName, synthetic, toRdfTypes, ...superParameters }: {
-        abstract: boolean;
+    constructor({ extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }: {
         comment: Maybe<string>;
-        declarationType: TsObjectDeclarationType;
         extern: boolean;
         features: ReadonlySet<TsFeature>;
         fromRdfType: Maybe<NamedNode>;
@@ -46,7 +40,6 @@ export declare class NamedObjectType extends AbstractType {
         lazyProperties: (namedObjectType: NamedObjectType) => readonly NamedObjectType.Property[];
         name: string;
         recursive: boolean;
-        staticModuleName: string;
         synthetic: boolean;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof AbstractType>[0]);
@@ -88,13 +81,9 @@ export declare class NamedObjectType extends AbstractType {
     jsonSchema({ context, }: Parameters<AbstractType["jsonSchema"]>[0]): Code;
     jsonType(): AbstractType.JsonType;
     jsonUiSchemaElement({ variables, }: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    newExpression({ parameters }: {
-        parameters: Code;
-    }): Code;
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
-    protected ensureAtMostOneSuperObjectType(): void;
     private readonly lazyAncestorObjectTypes;
     private readonly lazyChildObjectTypes;
     private readonly lazyDescendantObjectTypes;

package/dist/generators/ts/NamedObjectType.js

@@ -11,9 +11,8 @@ import { Memoize } from "typescript-memoize";
 import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
 import { IdentifierProperty as _IdentifierProperty } from "./_NamedObjectType/IdentifierProperty.js";
 import { identifierTypeDeclarations } from "./_NamedObjectType/identifierTypeDeclarations.js";
-import { NamedObjectType_classDeclaration } from "./_NamedObjectType/NamedObjectType_classDeclaration.js";
 import { NamedObjectType_createFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_createFunctionDeclaration.js";
-import { NamedObjectType_equalsFunctionOrMethodDeclaration } from "./_NamedObjectType/NamedObjectType_equalsFunctionOrMethodDeclaration.js";
+import { NamedObjectType_equalsFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_equalsFunctionDeclaration.js";
 import { NamedObjectType_filterFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_filterFunctionDeclaration.js";
 import { NamedObjectType_filterTypeDeclaration } from "./_NamedObjectType/NamedObjectType_filterTypeDeclaration.js";
 import { NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.js";
@@ -23,7 +22,7 @@ import { NamedObjectType_fromRdfResourceFunctionDeclaration } from "./_NamedObje
 import { NamedObjectType_fromRdfResourceValuesFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_fromRdfResourceValuesFunctionDeclaration.js";
 import { NamedObjectType_fromRdfTypeVariableStatement } from "./_NamedObjectType/NamedObjectType_fromRdfTypeVariableStatement.js";
 import { NamedObjectType_graphqlTypeVariableStatement } from "./_NamedObjectType/NamedObjectType_graphqlTypeVariableStatement.js";
-import { NamedObjectType_hashFunctionOrMethodDeclarations } from "./_NamedObjectType/NamedObjectType_hashFunctionOrMethodDeclarations.js";
+import { NamedObjectType_hashFunctionDeclarations } from "./_NamedObjectType/NamedObjectType_hashFunctionDeclarations.js";
 import { NamedObjectType_interfaceDeclaration } from "./_NamedObjectType/NamedObjectType_interfaceDeclaration.js";
 import { NamedObjectType_isTypeFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_isTypeFunctionDeclaration.js";
 import { NamedObjectType_jsonParseFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonParseFunctionDeclaration.js";
@@ -36,9 +35,9 @@ import { NamedObjectType_propertiesFromRdfResourceFunctionDeclaration } from "./
 import { NamedObjectType_schemaVariableStatement } from "./_NamedObjectType/NamedObjectType_schemaVariableStatement.js";
 import { NamedObjectType_sparqlConstructQueryFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.js";
 import { NamedObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
-import { NamedObjectType_toJsonFunctionOrMethodDeclaration } from "./_NamedObjectType/NamedObjectType_toJsonFunctionOrMethodDeclaration.js";
-import { NamedObjectType_toRdfResourceFunctionOrMethodDeclaration } from "./_NamedObjectType/NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.js";
-import { NamedObjectType_toStringFunctionOrMethodDeclarations } from "./_NamedObjectType/NamedObjectType_toStringFunctionOrMethodDeclaration.js";
+import { NamedObjectType_toJsonFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_toJsonFunctionDeclaration.js";
+import { NamedObjectType_toRdfResourceFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_toRdfResourceFunctionDeclaration.js";
+import { NamedObjectType_toStringFunctionDeclarations } from "./_NamedObjectType/NamedObjectType_toStringFunctionDeclarations.js";
 import { NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.js";
 import { NamedObjectType_valueSparqlWherePatternsFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js";
 import { ShaclProperty as _ShaclProperty } from "./_NamedObjectType/ShaclProperty.js";
@@ -49,8 +48,6 @@ import { code, def, joinCode } from "./ts-poet-wrapper.js";
 export class NamedObjectType extends AbstractType {
     imports;
     toRdfTypes;
-    abstract;
-    declarationType;
     extern;
     features;
     fromRdfType;
@@ -59,13 +56,10 @@ export class NamedObjectType extends AbstractType {
     kind = "NamedObjectType";
     name;
     recursive;
-    staticModuleName;
     synthetic;
     typeofs = NonEmptyList(["object"]);
-    constructor({ abstract, declarationType, extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, staticModuleName, synthetic, toRdfTypes, ...superParameters }) {
+    constructor({ extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }) {
         super(superParameters);
-        this.abstract = abstract;
-        this.declarationType = declarationType;
         this.extern = extern;
         this.features = features;
         this.fromRdfType = fromRdfType;
@@ -80,7 +74,6 @@ export class NamedObjectType extends AbstractType {
         this.lazyProperties = lazyProperties;
         this.name = name;
         this.recursive = recursive;
-        this.staticModuleName = staticModuleName;
         this.synthetic = synthetic;
         this.toRdfTypes = toRdfTypes;
     }
@@ -97,7 +90,7 @@ export class NamedObjectType extends AbstractType {
         return [
             {
                 conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object" && ${value} instanceof ${this.name}`,
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
                 sourceTypeName: this.name,
                 sourceTypeof: "object",
             },
@@ -110,17 +103,8 @@ export class NamedObjectType extends AbstractType {
         }
         if (!this.extern) {
             const staticModuleDeclarations = [];
-            switch (this.declarationType) {
-                case "class": {
-                    declarations.push(NamedObjectType_classDeclaration.call(this));
-                    break;
-                }
-                case "interface": {
-                    declarations.push(NamedObjectType_interfaceDeclaration.call(this));
-                    staticModuleDeclarations.push(...NamedObjectType_createFunctionDeclaration.call(this).toList(), ...NamedObjectType_equalsFunctionOrMethodDeclaration.bind(this)().toList(), ...NamedObjectType_hashFunctionOrMethodDeclarations.call(this));
-                    break;
-                }
-            }
+            declarations.push(NamedObjectType_interfaceDeclaration.call(this));
+            staticModuleDeclarations.push(...NamedObjectType_createFunctionDeclaration.call(this).toList(), ...NamedObjectType_equalsFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_hashFunctionDeclarations.call(this));
             const jsonModuleDeclarations = [
                 ...NamedObjectType_jsonParseFunctionDeclaration.call(this).toList(),
                 ...NamedObjectType_jsonSchemaFunctionDeclaration.call(this).toList(),
@@ -130,16 +114,10 @@ export class NamedObjectType extends AbstractType {
                 ? [
                     code `export namespace ${syntheticNamePrefix}Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`,
                 ]
-                : []), NamedObjectType_filterFunctionDeclaration.call(this), NamedObjectType_filterTypeDeclaration.call(this), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfTypeVariableStatement.call(this).toList(), NamedObjectType_isTypeFunctionDeclaration.call(this), ...NamedObjectType_propertiesFromJsonFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.bind(this)().toList(), NamedObjectType_schemaVariableStatement.call(this), ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.bind(this)().toList(), ...(this.declarationType === "interface"
-                ? NamedObjectType_toJsonFunctionOrMethodDeclaration.call(this).toList()
-                : []), ...(this.declarationType === "interface"
-                ? NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.call(this).toList()
-                : []), ...(this.declarationType === "interface"
-                ? NamedObjectType_toStringFunctionOrMethodDeclarations.call(this)
-                : []), ...NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.bind(this)().toList());
+                : []), NamedObjectType_filterFunctionDeclaration.call(this), NamedObjectType_filterTypeDeclaration.call(this), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfTypeVariableStatement.call(this).toList(), NamedObjectType_isTypeFunctionDeclaration.call(this), ...NamedObjectType_propertiesFromJsonFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.bind(this)().toList(), NamedObjectType_schemaVariableStatement.call(this), ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_toJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_toRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_toStringFunctionDeclarations.call(this), ...NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.bind(this)().toList());
             if (staticModuleDeclarations.length > 0) {
                 declarations.push(code `\
-export namespace ${def(this.staticModuleName)} {
+export namespace ${def(this.name)} {
 ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
 }`);
             }
@@ -166,29 +144,22 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return this.name;
     }
     get equalsFunction() {
-        switch (this.declarationType) {
-            case "class":
-                return code `((left, right) => left.${syntheticNamePrefix}equals(right))`;
-            case "interface":
-                return code `${this.staticModuleName}.${syntheticNamePrefix}equals`;
-            default:
-                throw new RangeError(this.declarationType);
-        }
+        return code `${this.name}.${syntheticNamePrefix}equals`;
     }
     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 fromRdfTypeVariable() {
-        return this.fromRdfType.map(() => code `${this.staticModuleName}.${syntheticNamePrefix}fromRdfType`);
+        return this.fromRdfType.map(() => code `${this.name}.${syntheticNamePrefix}fromRdfType`);
     }
     get graphqlType() {
-        return new AbstractType.GraphqlType(code `${this.staticModuleName}.${syntheticNamePrefix}GraphQL`);
+        return new AbstractType.GraphqlType(code `${this.name}.${syntheticNamePrefix}GraphQL`);
     }
     get identifierTypeAlias() {
-        return code `${this.staticModuleName}.${syntheticNamePrefix}Identifier`;
+        return code `${this.name}.${syntheticNamePrefix}Identifier`;
     }
     get mutable() {
         return this.properties.some((property) => property.mutable);
@@ -210,7 +181,7 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return properties;
     }
     get schema() {
-        return code `${this.staticModuleName}.${syntheticNamePrefix}schema`;
+        return code `${this.name}.${syntheticNamePrefix}schema`;
     }
     get schemaType() {
         return code `typeof ${this.schema}`;
@@ -225,94 +196,52 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return code `${imports.Resource}${this.identifierType.kind === "IriType" ? code `<${imports.NamedNode}>` : ""}`;
     }
     get valueSparqlConstructTriplesFunction() {
-        return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlConstructTriples`;
+        return code `${this.name}.${syntheticNamePrefix}valueSparqlConstructTriples`;
     }
     get valueSparqlWherePatternsFunction() {
-        return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlWherePatterns`;
+        return code `${this.name}.${syntheticNamePrefix}valueSparqlWherePatterns`;
     }
     get thisVariable() {
-        switch (this.declarationType) {
-            case "class":
-                return code `this`;
-            case "interface":
-                return code `_${camelCase(this.name)}`;
-            default:
-                throw new RangeError(this.declarationType);
-        }
+        return code `_${camelCase(this.name)}`;
     }
     fromJsonExpression({ variables, }) {
         // Assumes the JSON object has been recursively validated already.
-        return code `${this.staticModuleName}.${syntheticNamePrefix}fromJson(${variables.value})`;
+        return code `${this.name}.${syntheticNamePrefix}fromJson(${variables.value})`;
     }
     fromRdfResourceValuesExpression({ variables, }) {
         const { resourceValues, ...options } = variables;
-        return code `${this.staticModuleName}.${syntheticNamePrefix}fromRdfResourceValues(${resourceValues}, ${options})`;
+        return code `${this.name}.${syntheticNamePrefix}fromRdfResourceValues(${resourceValues}, ${options})`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
     }
     hashStatements({ variables, }) {
-        switch (this.declarationType) {
-            case "class":
-                return [
-                    code `${variables.value}.${syntheticNamePrefix}hash(${variables.hasher});`,
-                ];
-            case "interface":
-                return [
-                    code `${this.staticModuleName}.${syntheticNamePrefix}hash(${variables.value}, ${variables.hasher});`,
-                ];
-        }
+        return [
+            code `${this.name}.${syntheticNamePrefix}hash(${variables.value}, ${variables.hasher});`,
+        ];
     }
     jsonSchema({ context, }) {
-        let expression = code `${this.staticModuleName}.${syntheticNamePrefix}Json.schema()`;
+        let expression = code `${this.name}.${syntheticNamePrefix}Json.schema()`;
         if (context === "property" &&
             this.properties.some((property) => property.recursive)) {
-            expression = code `${imports.z}.lazy((): ${imports.z}.ZodType<${this.staticModuleName}.${syntheticNamePrefix}Json> => ${expression})`;
+            expression = code `${imports.z}.lazy((): ${imports.z}.ZodType<${this.name}.${syntheticNamePrefix}Json> => ${expression})`;
         }
         return expression;
     }
     jsonType() {
-        return new AbstractType.JsonType(code `${this.staticModuleName}.${syntheticNamePrefix}Json`);
+        return new AbstractType.JsonType(code `${this.name}.${syntheticNamePrefix}Json`);
     }
     jsonUiSchemaElement({ variables, }) {
-        return Maybe.of(code `${this.staticModuleName}.${syntheticNamePrefix}Json.uiSchema({ scopePrefix: ${variables.scopePrefix} })`);
-    }
-    newExpression({ parameters }) {
-        switch (this.declarationType) {
-            case "class":
-                return code `new ${this.name}(${parameters})`;
-            case "interface":
-                return code `${this.staticModuleName}.${syntheticNamePrefix}create(${parameters})`;
-        }
+        return Maybe.of(code `${this.name}.${syntheticNamePrefix}Json.uiSchema({ scopePrefix: ${variables.scopePrefix} })`);
     }
     toJsonExpression({ variables, }) {
-        switch (this.declarationType) {
-            case "class":
-                return code `${variables.value}.${syntheticNamePrefix}toJson()`;
-            case "interface":
-                return code `${this.staticModuleName}.${syntheticNamePrefix}toJson(${variables.value})`;
-        }
+        return code `${this.name}.${syntheticNamePrefix}toJson(${variables.value})`;
     }
     toStringExpression({ variables, }) {
-        switch (this.declarationType) {
-            case "class":
-                return code `${variables.value}.toString()`;
-            case "interface":
-                return code `${this.staticModuleName}.${syntheticNamePrefix}toString(${variables.value})`;
-        }
+        return code `${this.name}.${syntheticNamePrefix}toString(${variables.value})`;
     }
     toRdfResourceValuesExpression({ variables, }) {
-        switch (this.declarationType) {
-            case "class":
-                return code `[${variables.value}.${syntheticNamePrefix}toRdfResource({ graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
-            case "interface":
-                return code `[${this.staticModuleName}.${syntheticNamePrefix}toRdfResource(${variables.value}, { graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
-        }
-    }
-    ensureAtMostOneSuperObjectType() {
-        if (this.parentObjectTypes.length > 1) {
-            throw new RangeError(`object type '${this.name}' has multiple super object types`);
-        }
+        return code `[${this.name}.${syntheticNamePrefix}toRdfResource(${variables.value}, { graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
     }
     lazyAncestorObjectTypes;
     lazyChildObjectTypes;