@shaclmate/compiler 4.0.23 → 4.0.25

package/dist/generators/ts/NamedObjectType.js

@@ -9,12 +9,10 @@ import { camelCase } from "change-case";
 import { Maybe, NonEmptyList } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
-import { IdentifierPrefixProperty as _IdentifierPrefixProperty } from "./_NamedObjectType/IdentifierPrefixProperty.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";
@@ -24,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";
@@ -37,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";
@@ -50,8 +48,6 @@ import { code, def, joinCode } from "./ts-poet-wrapper.js";
 export class NamedObjectType extends AbstractType {
     imports;
     toRdfTypes;
-    abstract;
-    declarationType;
     extern;
     features;
     fromRdfType;
@@ -60,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, lazyIdentifierProperty, 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;
@@ -77,12 +70,10 @@ export class NamedObjectType extends AbstractType {
         this.lazyChildObjectTypes = lazyChildObjectTypes;
         this.lazyDescendantObjectTypes = lazyDescendantObjectTypes;
         this.lazyDiscriminantProperty = lazyDiscriminantProperty;
-        this.lazyIdentifierProperty = lazyIdentifierProperty;
         this.lazyParentObjectTypes = lazyParentObjectTypes;
         this.lazyProperties = lazyProperties;
         this.name = name;
         this.recursive = recursive;
-        this.staticModuleName = staticModuleName;
         this.synthetic = synthetic;
         this.toRdfTypes = toRdfTypes;
     }
@@ -99,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",
             },
@@ -112,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(),
@@ -132,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" })}
 }`);
             }
@@ -168,32 +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`);
-    }
-    get identifierProperty() {
-        return this.lazyIdentifierProperty(this);
+        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);
@@ -201,18 +167,6 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     get objectSetMethodNames() {
         return NamedObjectType_objectSetMethodNames.call(this);
     }
-    get ownProperties() {
-        if (this.parentObjectTypes.length === 0) {
-            // Consider that a root of the object type hierarchy "owns" the identifier and type discriminant properties
-            // for all of its subtypes in the hierarchy.
-            // invariant(this.properties.length >= 2, this.name);
-            return this.properties;
-        }
-        return this.ownShaclProperties;
-    }
-    get ownShaclProperties() {
-        return this.properties.filter((property) => property.kind === "ShaclProperty");
-    }
     get parentObjectTypes() {
         return this.lazyParentObjectTypes();
     }
@@ -227,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}`;
@@ -242,100 +196,57 @@ ${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;
     lazyDescendantObjectTypes;
     lazyDiscriminantProperty;
-    lazyIdentifierProperty;
     lazyParentObjectTypes;
     lazyProperties;
 }
@@ -381,9 +292,6 @@ __decorate([
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "graphqlType", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "identifierProperty", null);
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "identifierTypeAlias", null);
@@ -393,12 +301,6 @@ __decorate([
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "objectSetMethodNames", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "ownProperties", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "ownShaclProperties", null);
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "parentObjectTypes", null);
@@ -430,7 +332,6 @@ __decorate([
     Memoize()
 ], NamedObjectType.prototype, "jsonType", null);
 (function (NamedObjectType) {
-    NamedObjectType.IdentifierPrefixProperty = _IdentifierPrefixProperty;
     NamedObjectType.IdentifierProperty = _IdentifierProperty;
     NamedObjectType.ShaclProperty = _ShaclProperty;
     NamedObjectType.DiscriminantProperty = _DiscriminantProperty;

package/dist/generators/ts/NamedObjectUnionType.js

@@ -30,13 +30,13 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
         return new AbstractType.GraphqlType(code `${this._name}.${syntheticNamePrefix}GraphQL`);
     }
     get identifierTypeAlias() {
-        return code `${this.staticModuleName}.${syntheticNamePrefix}Identifier`;
+        return code `${this.name}.${syntheticNamePrefix}Identifier`;
     }
     get objectSetMethodNames() {
         return NamedObjectType_objectSetMethodNames.call(this);
     }
     get schema() {
-        return code `${this.staticModuleName}.${syntheticNamePrefix}schema`;
+        return code `${this.name}.${syntheticNamePrefix}schema`;
     }
     get schemaType() {
         return code `typeof ${this.schema}`;
@@ -66,7 +66,7 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
         }
         return singleEntryRecord(`${syntheticNamePrefix}focusSparqlConstructTriples`, code `\
 export function ${syntheticNamePrefix}focusSparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${imports.sparqljs}.Triple[] {
-  return [${joinCode(this.concreteMembers.map((member) => code `...${member.type.staticModuleName}.${syntheticNamePrefix}focusSparqlConstructTriples({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`), { on: ", " })}];
+  return [${joinCode(this.members.map((member) => code `...${member.type.name}.${syntheticNamePrefix}focusSparqlConstructTriples({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`), { on: ", " })}];
 }`);
     }
     get focusSparqlWherePatternsFunctionDeclaration() {
@@ -89,8 +89,8 @@ if (focusIdentifier.termType === "Variable") {
       variablePrefix,
   }));
 }`,
-            code `patterns.push({ patterns: [${joinCode(this.concreteMembers.map((member) => code `${{
-                patterns: code `${member.type.staticModuleName}.${syntheticNamePrefix}focusSparqlWherePatterns({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`,
+            code `patterns.push({ patterns: [${joinCode(this.members.map((member) => code `${{
+                patterns: code `${member.type.name}.${syntheticNamePrefix}focusSparqlWherePatterns({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`,
                 type: literalOf("group"),
             }}`), { on: ", " })}], type: "union" });`,
             code `return patterns;`,
@@ -103,8 +103,8 @@ if (focusIdentifier.termType === "Variable") {
         }
         return singleEntryRecord(`${syntheticNamePrefix}fromRdfResource`, code `\
 export const ${syntheticNamePrefix}fromRdfResource: ${snippets.FromRdfResourceFunction}<${this.name}> = (resource, options) => 
-  ${this.concreteMembers.reduce((expression, member) => {
-            const memberTypeExpression = code `(${member.type.staticModuleName}.${syntheticNamePrefix}fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${imports.Either}<Error, ${this.name}>)`;
+  ${this.members.reduce((expression, member) => {
+            const memberTypeExpression = code `(${member.type.name}.${syntheticNamePrefix}fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${imports.Either}<Error, ${this.name}>)`;
             return expression !== null
                 ? code `${expression}.altLazy(() => ${memberTypeExpression})`
                 : memberTypeExpression;
@@ -119,7 +119,7 @@ export const ${syntheticNamePrefix}GraphQL = new ${imports.GraphQLUnionType}(${{
             description: this.comment.map(JSON.stringify).extract(),
             name: this.name,
             resolveType: code `(value: ${this.name}) => value.${syntheticNamePrefix}type`,
-            types: code `[${joinCode(this.concreteMembers.map((member) => member.type.graphqlType.nullableName), { on: ", " })}]`,
+            types: code `[${joinCode(this.members.map((member) => member.type.graphqlType.nullableName), { on: ", " })}]`,
         }});`);
     }
     get identifierTypeDeclarations() {
@@ -136,13 +136,13 @@ export namespace ${syntheticNamePrefix}Identifier {
         }
         return singleEntryRecord(`is${this._name}`, code `\
     export function is${this._name}(object: ${syntheticNamePrefix}Object): object is ${this.name} {
-      return ${joinCode(this.concreteMembers.map((member) => code `${member.type.staticModuleName}.is${member.type.name}(object)`), { on: " || " })};
+      return ${joinCode(this.members.map((member) => code `${member.type.name}.is${member.type.name}(object)`), { on: " || " })};
     }`);
     }
     get schemaVariableStatement() {
         const commonPropertiesByName = {};
-        this.concreteMembers.forEach((member, memberI) => {
-            for (const memberTypeProperty of member.type.ownProperties.concat(member.type.ancestorObjectTypes.flatMap((ancestorObjectType) => ancestorObjectType.ownProperties))) {
+        this.members.forEach((member, memberI) => {
+            for (const memberTypeProperty of member.type.properties.concat(member.type.ancestorObjectTypes.flatMap((ancestorObjectType) => ancestorObjectType.properties))) {
                 if (memberTypeProperty.kind !== "ShaclProperty") {
                     continue;
                 }
@@ -154,7 +154,7 @@ export namespace ${syntheticNamePrefix}Identifier {
                 }
                 else {
                     commonPropertiesByName[memberTypeProperty.name] = commonProperty = {
-                        memberTypesWithProperty: new Array(this.concreteMembers.length).fill(false),
+                        memberTypesWithProperty: new Array(this.members.length).fill(false),
                         property: memberTypeProperty,
                     };
                     commonProperty.memberTypesWithProperty[memberI] = true;
@@ -182,19 +182,8 @@ ${{
         }
         return singleEntryRecord(`${syntheticNamePrefix}toRdfResource`, code `\
 export const ${syntheticNamePrefix}toRdfResource: ${snippets.ToRdfResourceFunction}<${this.name}> = (value, options) => {
-${joinCode(this.concreteMembers
-            .map((member) => {
-            let returnExpression;
-            switch (member.type.declarationType) {
-                case "class":
-                    returnExpression = code `value.${syntheticNamePrefix}toRdfResource(options)`;
-                    break;
-                case "interface":
-                    returnExpression = code `${member.type.staticModuleName}.${syntheticNamePrefix}toRdfResource(value, options)`;
-                    break;
-            }
-            return code `if (${member.type.staticModuleName}.is${member.type.name}(value)) { return ${returnExpression}; }`;
-        })
+${joinCode(this.members
+            .map((member) => code `if (${member.type.name}.is${member.type.name}(value)) { return ${member.type.name}.${syntheticNamePrefix}toRdfResource(value, options); }`)
             .concat(code `throw new Error("unrecognized type");`))}
 };`);
     }

package/dist/generators/ts/TypeFactory.js

@@ -2,7 +2,7 @@ import TermMap from "@rdfjs/term-map";
 import TermSet from "@rdfjs/term-set";
 import { LiteralDecoder, literalDatatypeDefinitions } from "@rdfx/literal";
 import base62 from "@sindresorhus/base62";
-import { rdf, xsd } from "@tpluscode/rdf-ns-builders";
+import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import reservedTsIdentifiers_ from "reserved-identifiers";
 import { invariant } from "ts-invariant";
@@ -75,11 +75,8 @@ export class TypeFactory {
         const name = tsName(astType.name.unsafeCoerce(), {
             synthetic: astType.synthetic,
         });
-        const staticModuleName = astType.childObjectTypes.length > 0 ? `${name}Static` : name;
         const namedObjectType = new NamedObjectType({
-            abstract: astType.abstract,
             comment: astType.comment,
-            declarationType: astType.tsObjectDeclarationType,
             extern: astType.extern,
             features: astType.tsFeatures,
             fromRdfType: astType.fromRdfType,
@@ -91,14 +88,9 @@ export class TypeFactory {
             lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createNamedObjectType(astType)),
             lazyDiscriminantProperty: (namedObjectType) => {
                 // Discriminant property
-                const discriminantOwnValue = !astType.abstract
-                    ? namedObjectType.discriminantValue
-                    : undefined;
                 const discriminantDescendantValues = new Set();
                 for (const descendantObjectType of namedObjectType.descendantObjectTypes) {
-                    if (!descendantObjectType.abstract) {
-                        discriminantDescendantValues.add(descendantObjectType.discriminantValue);
-                    }
+                    discriminantDescendantValues.add(descendantObjectType.discriminantValue);
                 }
                 return new NamedObjectType.DiscriminantProperty({
                     logger: this.logger,
@@ -107,21 +99,10 @@ export class TypeFactory {
                     type: new NamedObjectType.DiscriminantProperty.Type({
                         descendantValues: [...discriminantDescendantValues].sort(),
                         mutable: false,
-                        ownValues: discriminantOwnValue ? [discriminantOwnValue] : [],
+                        ownValues: [namedObjectType.discriminantValue],
                     }),
-                    visibility: "public",
                 });
             },
-            lazyIdentifierProperty: (namedObjectType) => new NamedObjectType.IdentifierProperty({
-                identifierMintingStrategy: astType.identifierMintingStrategy,
-                identifierPrefixPropertyName: `${syntheticNamePrefix}identifierPrefix`,
-                logger: this.logger,
-                name: `${syntheticNamePrefix}identifier`,
-                namedObjectType,
-                type: identifierType,
-                typeAlias: code `${staticModuleName}.${syntheticNamePrefix}Identifier`,
-                visibility: "public",
-            }),
             lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createNamedObjectType(astType)),
             lazyProperties: (namedObjectType) => {
                 const properties = astType.properties
@@ -138,38 +119,19 @@ export class TypeFactory {
                     astObjectTypeProperty: astProperty,
                     namedObjectType,
                 }));
-                if (namedObjectType._discriminantProperty.type.ownValues.length > 0 ||
-                    namedObjectType._discriminantProperty.type.descendantValues.length > 0) {
-                    properties.splice(0, 0, namedObjectType._discriminantProperty);
-                }
-                // Some ObjectTypes have an identifierPrefix property, depending on their identifier minting strategy.
-                if (namedObjectTypeNeedsIdentifierPrefixProperty(astType)) {
-                    properties.splice(0, 0, new NamedObjectType.IdentifierPrefixProperty({
-                        logger: this.logger,
-                        name: `${syntheticNamePrefix}identifierPrefix`,
-                        namedObjectType,
-                        own: !astType.ancestorObjectTypes.some(namedObjectTypeNeedsIdentifierPrefixProperty),
-                        type: new StringType({
-                            comment: astType.comment,
-                            datatype: xsd.string,
-                            hasValues: [],
-                            in_: [],
-                            label: astType.label,
-                            logger: this.logger,
-                            languageIn: [],
-                            primitiveIn: [],
-                        }),
-                        visibility: "protected",
-                    }));
-                }
-                // Every NamedObjectType has an identifier property. Some are abstract.
-                properties.splice(0, 0, namedObjectType.identifierProperty);
+                properties.splice(0, 0, namedObjectType._discriminantProperty);
+                properties.splice(0, 0, new NamedObjectType.IdentifierProperty({
+                    logger: this.logger,
+                    name: `${syntheticNamePrefix}identifier`,
+                    namedObjectType,
+                    type: identifierType,
+                    typeAlias: code `${name}.${syntheticNamePrefix}Identifier`,
+                }));
                 return properties;
             },
             logger: this.logger,
             name,
             recursive: astType.recursive,
-            staticModuleName,
             synthetic: astType.synthetic,
             toRdfTypes: astType.toRdfTypes,
         });
@@ -321,7 +283,6 @@ export class TypeFactory {
             logger: this.logger,
             minCount: 0,
             mutable: astType.mutable,
-            identifierMintingStrategy: astType.identifierMintingStrategy,
             toRdfTypes: astType.toRdfTypes,
         });
     }
@@ -464,7 +425,6 @@ export class TypeFactory {
             path: astObjectTypeProperty.path,
             recursive: !!astObjectTypeProperty.recursive,
             type: this.createType(astObjectTypeProperty.type),
-            visibility: astObjectTypeProperty.visibility,
         });
         this.cachedObjectTypePropertiesByShapeIdentifier.set(astObjectTypeProperty.shapeIdentifier, property);
         return property;
@@ -502,22 +462,6 @@ export class TypeFactory {
         });
     }
 }
-function namedObjectTypeNeedsIdentifierPrefixProperty(namedObjectType) {
-    return namedObjectType.identifierMintingStrategy
-        .map((identifierMintingStrategy) => {
-        switch (identifierMintingStrategy) {
-            case "blankNode":
-                return false;
-            case "sha256":
-            case "uuidv4":
-                return true;
-            default:
-                identifierMintingStrategy;
-                throw new RangeError(identifierMintingStrategy);
-        }
-    })
-        .orDefault(false);
-}
 function tsName(name, options) {
     if (name[0] === "$") {
         return name;

package/dist/generators/ts/ZodGenerator.js

@@ -15,7 +15,7 @@ export class ZodGenerator {
         const declarations = [];
         for (const namedObjectType of ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => this.typeFactory.createNamedObjectType(astObjectType))) {
             declarations.push(code `\
-export namespace ${namedObjectType.staticModuleName} {
+export namespace ${namedObjectType.name} {
   ${joinCode(NamedObjectType_jsonTypeAliasDeclaration.bind(namedObjectType)().toList())}
 
   export namespace ${syntheticNamePrefix}Json {
@@ -26,7 +26,7 @@ export namespace ${namedObjectType.staticModuleName} {
         for (const astNamedUnionType of ast_.namedUnionTypes.map((astNamedUnionType) => this.typeFactory.createUnionType(astNamedUnionType))) {
             invariant(astNamedUnionType.kind !== "AnonymousUnionType");
             declarations.push(code `\
-export namespace ${astNamedUnionType.staticModuleName} {
+export namespace ${astNamedUnionType.name} {
   ${astNamedUnionType.jsonTypeAliasDeclaration}
   export namespace ${syntheticNamePrefix}Json {
     ${astNamedUnionType.jsonSchemaFunctionDeclaration}