@shaclmate/compiler 4.0.40 → 4.0.42

package/dist/generators/ts/ObjectType.js

@@ -7,113 +7,198 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { NodeKind } from "@shaclmate/shacl-ast";
 import { camelCase } from "change-case";
 import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { DiscriminantProperty as _DiscriminantProperty } from "./_ObjectType/DiscriminantProperty.js";
 import { IdentifierProperty as _IdentifierProperty } from "./_ObjectType/IdentifierProperty.js";
-import { identifierTypeDeclarations } from "./_ObjectType/identifierTypeDeclarations.js";
-import { ObjectType_createFunctionDeclaration } from "./_ObjectType/ObjectType_createFunctionDeclaration.js";
-import { ObjectType_equalsFunctionDeclaration } from "./_ObjectType/ObjectType_equalsFunctionDeclaration.js";
-import { ObjectType_filterFunctionDeclaration } from "./_ObjectType/ObjectType_filterFunctionDeclaration.js";
-import { ObjectType_filterTypeDeclaration } from "./_ObjectType/ObjectType_filterTypeDeclaration.js";
-import { ObjectType_focusSparqlConstructTriplesFunctionDeclaration } from "./_ObjectType/ObjectType_focusSparqlConstructTriplesFunctionDeclaration.js";
-import { ObjectType_focusSparqlWherePatternsFunctionDeclaration } from "./_ObjectType/ObjectType_focusSparqlWherePatternsFunctionDeclaration.js";
-import { ObjectType_fromJsonFunctionDeclaration } from "./_ObjectType/ObjectType_fromJsonFunctionDeclaration.js";
-import { ObjectType_fromRdfResourceFunctionDeclaration } from "./_ObjectType/ObjectType_fromRdfResourceFunctionDeclaration.js";
-import { ObjectType_fromRdfResourceValuesFunctionDeclaration } from "./_ObjectType/ObjectType_fromRdfResourceValuesFunctionDeclaration.js";
-import { ObjectType_fromRdfTypeVariableStatement } from "./_ObjectType/ObjectType_fromRdfTypeVariableStatement.js";
-import { ObjectType_graphqlTypeVariableStatement } from "./_ObjectType/ObjectType_graphqlTypeVariableStatement.js";
-import { ObjectType_hashFunctionDeclarations } from "./_ObjectType/ObjectType_hashFunctionDeclarations.js";
-import { ObjectType_interfaceDeclaration } from "./_ObjectType/ObjectType_interfaceDeclaration.js";
+import { ObjectType_createFunctionExpression } from "./_ObjectType/ObjectType_createFunctionExpression.js";
+import { ObjectType_equalsFunctionExpression } from "./_ObjectType/ObjectType_equalsFunctionExpression.js";
+import { ObjectType_filterFunctionExpression } from "./_ObjectType/ObjectType_filterFunctionExpression.js";
+import { ObjectType_filterTypeExpression } from "./_ObjectType/ObjectType_filterTypeExpression.js";
+import { ObjectType_focusSparqlConstructTriplesFunctionExpression } from "./_ObjectType/ObjectType_focusSparqlConstructTriplesFunctionExpression.js";
+import { ObjectType_focusSparqlWherePatternsFunctionExpression } from "./_ObjectType/ObjectType_focusSparqlWherePatternsFunctionExpression.js";
+import { ObjectType_fromJsonFunctionExpression } from "./_ObjectType/ObjectType_fromJsonFunctionExpression.js";
+import { ObjectType_fromRdfResourceFunctionExpression } from "./_ObjectType/ObjectType_fromRdfResourceFunctionExpression.js";
+import { ObjectType_graphqlTypeExpression } from "./_ObjectType/ObjectType_graphqlTypeExpression.js";
+import { ObjectType_hashFunctionExpression } from "./_ObjectType/ObjectType_hashFunctionExpression.js";
+import { ObjectType_identifierTypeDeclarations } from "./_ObjectType/ObjectType_identifierTypeDeclarations.js";
 import { ObjectType_isTypeFunctionDeclaration } from "./_ObjectType/ObjectType_isTypeFunctionDeclaration.js";
 import { ObjectType_jsonParseFunctionDeclaration } from "./_ObjectType/ObjectType_jsonParseFunctionDeclaration.js";
-import { ObjectType_jsonSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonSchemaFunctionDeclaration.js";
-import { ObjectType_jsonTypeAliasDeclaration } from "./_ObjectType/ObjectType_jsonTypeAliasDeclaration.js";
-import { ObjectType_jsonUiSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonUiSchemaFunctionDeclaration.js";
+import { ObjectType_jsonSchemaExpression } from "./_ObjectType/ObjectType_jsonSchemaExpression.js";
+import { ObjectType_jsonTypeExpression } from "./_ObjectType/ObjectType_jsonTypeExpression.js";
+import { ObjectType_jsonUiSchemaFunctionExpression } from "./_ObjectType/ObjectType_jsonUiSchemaFunctionExpression.js";
 import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
-import { ObjectType_schemaVariableStatement } from "./_ObjectType/ObjectType_schemaVariableStatement.js";
+import { ObjectType_schemaExpression } from "./_ObjectType/ObjectType_schemaExpression.js";
+import { ObjectType_schemaTypeExpression } from "./_ObjectType/ObjectType_schemaTypeExpression.js";
 import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
 import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
-import { ObjectType_toJsonFunctionDeclaration } from "./_ObjectType/ObjectType_toJsonFunctionDeclaration.js";
-import { ObjectType_toRdfResourceFunctionDeclaration } from "./_ObjectType/ObjectType_toRdfResourceFunctionDeclaration.js";
-import { ObjectType_toStringFunctionDeclarations } from "./_ObjectType/ObjectType_toStringFunctionDeclarations.js";
-import { ObjectType_valueSparqlConstructTriplesFunctionDeclaration } from "./_ObjectType/ObjectType_valueSparqlConstructTriplesFunctionDeclaration.js";
-import { ObjectType_valueSparqlWherePatternsFunctionDeclaration } from "./_ObjectType/ObjectType_valueSparqlWherePatternsFunctionDeclaration.js";
+import { ObjectType_toJsonFunctionExpression } from "./_ObjectType/ObjectType_toJsonFunctionExpression.js";
+import { ObjectType_toRdfResourceFunctionExpression } from "./_ObjectType/ObjectType_toRdfResourceFunctionExpression.js";
+import { ObjectType_toStringFunctionExpression } from "./_ObjectType/ObjectType_toStringFunctionExpression.js";
+import { ObjectType_toStringRecordFunctionExpression } from "./_ObjectType/ObjectType_toStringRecordFunctionExpression.js";
+import { ObjectType_valueSparqlConstructTriplesFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlConstructTriplesFunctionExpression.js";
+import { ObjectType_valueSparqlWherePatternsFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlWherePatternsFunctionExpression.js";
 import { ShaclProperty as _ShaclProperty } from "./_ObjectType/ShaclProperty.js";
 import { AbstractType } from "./AbstractType.js";
 import { code, def, joinCode } from "./ts-poet-wrapper.js";
+import { tsComment } from "./tsComment.js";
 export class ObjectType extends AbstractType {
     toRdfTypes;
-    conversionFunction = Maybe.empty();
+    discriminantProperty;
     extern;
     fromRdfType;
     graphqlArgs = Maybe.empty();
     identifierType;
+    jsTypes = [
+        { instanceof: "Object", typeof: "object" },
+    ];
     kind = "Object";
     recursive;
-    referencesObjectType = true;
     synthetic;
-    typeofs = ["object"];
     validationFunction = Maybe.empty();
-    constructor({ extern, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, recursive, synthetic, toRdfTypes, ...superParameters }) {
+    constructor({ discriminantProperty, extern, fromRdfType, identifierType, lazyProperties, recursive, synthetic, toRdfTypes, ...superParameters }) {
         super(superParameters);
+        this.discriminantProperty = discriminantProperty;
         this.extern = extern;
         this.fromRdfType = fromRdfType;
         this.identifierType = identifierType;
         // Lazily initialize some members in getters to avoid recursive construction
-        this.lazyAncestorObjectTypes = lazyAncestorObjectTypes;
-        this.lazyChildObjectTypes = lazyChildObjectTypes;
-        this.lazyDescendantObjectTypes = lazyDescendantObjectTypes;
-        this.lazyDiscriminantProperty = lazyDiscriminantProperty;
-        this.lazyParentObjectTypes = lazyParentObjectTypes;
         this.lazyProperties = lazyProperties;
         this.recursive = recursive;
         this.synthetic = synthetic;
         this.toRdfTypes = toRdfTypes;
     }
-    get _discriminantProperty() {
-        return this.lazyDiscriminantProperty(this);
-    }
-    get ancestorObjectTypes() {
-        return this.lazyAncestorObjectTypes();
-    }
-    get childObjectTypes() {
-        return this.lazyChildObjectTypes();
+    get conversionFunction() {
+        if (this.name.isJust()) {
+            return Maybe.empty();
+        }
+        return Maybe.of({
+            code: this.createFunction,
+            sourceTypes: [
+                {
+                    expression: this.constructorParameters.type.expression,
+                    jsType: {
+                        instanceof: "Object",
+                        typeof: "object",
+                    },
+                },
+            ],
+        });
     }
     get declaration() {
-        const alias = this.alias.extract();
-        if (!alias) {
+        const name = this.name.extract();
+        if (!name) {
             return Maybe.empty();
         }
         const declarations = [];
         if (!this.extern) {
-            const staticModuleDeclarations = [];
             if (this.configuration.features.has("Object.type")) {
-                declarations.push(ObjectType_interfaceDeclaration.call(this));
+                declarations.push(code `\
+ ${this.comment
+                    .alt(this.label)
+                    .map(tsComment)
+                    .orDefault("")}export type ${name} = ${this.inlineExpression};`);
+            }
+            let staticModuleDeclarations = [];
+            // create
+            if (this.configuration.features.has("Object.create")) {
+                staticModuleDeclarations.push(code `export const create: (${this.constructorParameters.signature}) => ${this.reusables.imports.Either}<Error, ${this.expression}> = ${ObjectType_createFunctionExpression.call(this)};`, code `export function createUnsafe(${this.constructorParameters.signature}): ${this.expression} {
+  return create(parameters).unsafeCoerce();
+}`);
+            }
+            // equals
+            if (this.configuration.features.has("Object.equals")) {
+                staticModuleDeclarations.push(code `export const equals: (left: ${this.expression}, right: ${this.expression}) => ${this.reusables.snippets.EqualsResult} = ${ObjectType_equalsFunctionExpression.call(this)};`);
+            }
+            // Filter / filter
+            if (this.configuration.features.has("Object.filter")) {
+                staticModuleDeclarations.push(code `export type Filter = ${ObjectType_filterTypeExpression.call(this)};`);
+                staticModuleDeclarations.push(code `export const filter: (filter: ${this.filterType}, value: ${this.expression}) => boolean = ${ObjectType_filterFunctionExpression.call(this)};`);
+            }
+            // GraphQL
+            if (this.configuration.features.has("GraphQL") && !this.synthetic) {
+                staticModuleDeclarations.push(code `export const GraphQL = ${ObjectType_graphqlTypeExpression.call(this)};`);
+            }
+            // focusSparqlConstructTriples / focusSparqlWherePatterns
+            if (this.configuration.features.has("Object.SPARQL")) {
+                staticModuleDeclarations.push(code `export const focusSparqlConstructTriples: ${this.reusables.snippets.FocusSparqlConstructTriplesFunction}<${this.filterType}> = ${ObjectType_focusSparqlConstructTriplesFunctionExpression.call(this)};`, code `export const focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<${this.filterType}> = ${ObjectType_focusSparqlWherePatternsFunctionExpression.call(this)};`);
+            }
+            // fromJson
+            if (this.configuration.features.has("Object.fromJson")) {
+                staticModuleDeclarations.push(code `export const fromJson: (json: ${this.jsonType().expression}) => ${this.reusables.imports.Either}<Error, ${this.expression}> = ${ObjectType_fromJsonFunctionExpression.call(this)};`);
+            }
+            // fromRdfResource / fromRdfResourceValues
+            if (this.configuration.features.has("Object.fromRdf")) {
+                staticModuleDeclarations.push(code `export const _fromRdfResource: ${this.reusables.snippets._FromRdfResourceFunction}<${this.expression}> = ${ObjectType_fromRdfResourceFunctionExpression.call(this)};`, code `export const fromRdfResource = ${this.reusables.snippets.wrap_FromRdfResourceFunction}(_fromRdfResource);`, code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}> = 
+  (values, options) => values.chainMap(value => value.toResource().chain(resource => fromRdfResource(resource, options)));`);
+            }
+            // hash
+            if (this.configuration.features.has("Object.hash")) {
+                staticModuleDeclarations.push(code `export const hash = ${ObjectType_hashFunctionExpression.call(this)};`);
+            }
+            // Identifier
+            if (this.configuration.features.has("Object.type")) {
+                staticModuleDeclarations = staticModuleDeclarations.concat(ObjectType_identifierTypeDeclarations.call(this));
+            }
+            // isType
+            staticModuleDeclarations = staticModuleDeclarations.concat(ObjectType_isTypeFunctionDeclaration.call(this).toList());
+            // type Json
+            if (this.configuration.features.has("Object.JSON.type")) {
+                staticModuleDeclarations.push(code `export type Json = ${ObjectType_jsonTypeExpression.call(this)}`);
+            }
+            // namespace Json
+            {
+                const jsonModuleDeclarations = [];
+                if (this.configuration.features.has("Object.JSON.parse")) {
+                    jsonModuleDeclarations.push(ObjectType_jsonParseFunctionDeclaration.call(this));
+                }
+                if (this.configuration.features.has("Object.JSON.schema")) {
+                    jsonModuleDeclarations.push(code `export function schema() { return ${ObjectType_jsonSchemaExpression.call(this)} satisfies ${this.reusables.imports.z}.ZodType<Json>; }`);
+                }
+                if (this.configuration.features.has("Object.JSON.uiSchema")) {
+                    jsonModuleDeclarations.push(code `export const uiSchema = ${ObjectType_jsonUiSchemaFunctionExpression.call(this)};`);
+                }
+                if (jsonModuleDeclarations.length > 0) {
+                    staticModuleDeclarations.push(code `export namespace Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`);
+                }
+            }
+            // schema / Schema
+            if (this.configuration.features.has("Object.schema")) {
+                staticModuleDeclarations.push(code `export const schema = ${ObjectType_schemaExpression.call(this)};`, code `export type Schema = typeof schema;`);
+            }
+            // sparqlConstructQuery / sparqlConstructQueryString
+            if (this.configuration.features.has("Object.SPARQL")) {
+                staticModuleDeclarations.push(ObjectType_sparqlConstructQueryFunctionDeclaration.call({
+                    name,
+                    configuration: this.configuration,
+                    filterType: this.filterType,
+                    reusables: this.reusables,
+                }), ObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
+                    name,
+                    configuration: this.configuration,
+                    filterType: this.filterType,
+                    reusables: this.reusables,
+                }));
+            }
+            // toJson
+            if (this.configuration.features.has("Object.toJson")) {
+                staticModuleDeclarations.push(code `export const toJson: (${this.thisVariable}: ${this.expression}) => ${this.jsonType().expression} = ${ObjectType_toJsonFunctionExpression.call(this)};`);
+            }
+            // toRdfResource
+            if (this.configuration.features.has("Object.toRdf")) {
+                staticModuleDeclarations.push(code `export const _toRdfResource: ${this.reusables.snippets._ToRdfResourceFunction}<${this.identifierTypeAlias}, ${this.expression}> = ${ObjectType_toRdfResourceFunctionExpression.call(this)};`, code `export const toRdfResource = ${this.reusables.snippets.wrap_ToRdfResourceFunction}(_toRdfResource);`);
+            }
+            // toString / toStringRecord
+            if (this.configuration.features.has("Object.toString")) {
+                staticModuleDeclarations.push(code `export const ${this.configuration.syntheticNamePrefix}toString: (${this.thisVariable}: ${this.expression}) => string = ${ObjectType_toStringFunctionExpression.call(this)};`, code `export const toStringRecord: (${this.thisVariable}: ${this.expression}) => Record<string, string> = ${ObjectType_toStringRecordFunctionExpression.call(this)};`);
+            }
+            // valueSparqlConstructTriples / valueSparqlWherePatterns
+            if (this.configuration.features.has("Object.SPARQL")) {
+                staticModuleDeclarations.push(code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${ObjectType_valueSparqlConstructTriplesFunctionExpression.call(this)};`, code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${ObjectType_valueSparqlWherePatternsFunctionExpression.call(this)};`);
             }
-            staticModuleDeclarations.push(...ObjectType_createFunctionDeclaration.call(this).toList(), ...ObjectType_equalsFunctionDeclaration.call(this).toList(), ...ObjectType_hashFunctionDeclarations.call(this));
-            const jsonModuleDeclarations = [
-                ...ObjectType_jsonParseFunctionDeclaration.call(this).toList(),
-                ...ObjectType_jsonSchemaFunctionDeclaration.call(this).toList(),
-                ...ObjectType_jsonUiSchemaFunctionDeclaration.call(this).toList(),
-            ];
-            staticModuleDeclarations.push(...ObjectType_graphqlTypeVariableStatement.call(this).toList(), ...identifierTypeDeclarations.call(this), ...ObjectType_jsonTypeAliasDeclaration.call(this).toList(), ...(jsonModuleDeclarations.length > 0
-                ? [
-                    code `export namespace Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`,
-                ]
-                : []), ...ObjectType_filterFunctionDeclaration.call(this).toList(), ...ObjectType_filterTypeDeclaration.call(this).toList(), ...ObjectType_focusSparqlConstructTriplesFunctionDeclaration.call(this).toList(), ...ObjectType_focusSparqlWherePatternsFunctionDeclaration.call(this).toList(), ...ObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...ObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...ObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...ObjectType_fromRdfTypeVariableStatement.call(this).toList(), ...ObjectType_isTypeFunctionDeclaration.call(this).toList(), ...ObjectType_schemaVariableStatement.call(this).toList(), ...ObjectType_sparqlConstructQueryFunctionDeclaration.call({
-                alias,
-                configuration: this.configuration,
-                filterType: this.filterType,
-                reusables: this.reusables,
-            }).toList(), ...ObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
-                alias,
-                configuration: this.configuration,
-                filterType: this.filterType,
-                reusables: this.reusables,
-            }).toList(), ...ObjectType_toJsonFunctionDeclaration.call(this).toList(), ...ObjectType_toRdfResourceFunctionDeclaration.call(this).toList(), ...ObjectType_toStringFunctionDeclarations.call(this), ...ObjectType_valueSparqlConstructTriplesFunctionDeclaration.call(this).toList(), ...ObjectType_valueSparqlWherePatternsFunctionDeclaration.call(this).toList());
             if (staticModuleDeclarations.length > 0) {
                 declarations.push(code `\
-export namespace ${def(alias)} {
+export namespace ${def(name)} {
 ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
 }`);
             }
@@ -123,165 +208,207 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         }
         return Maybe.of(joinCode(declarations, { on: "\n\n" }));
     }
-    get descendantFromRdfTypeVariables() {
-        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfTypeVariable.toList());
-    }
-    get descendantFromRdfTypes() {
-        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfType.toList());
-    }
-    get descendantObjectTypes() {
-        return this.lazyDescendantObjectTypes();
-    }
-    get discriminantProperty() {
-        return Maybe.of({
-            jsonName: this._discriminantProperty.jsonName,
-            name: this._discriminantProperty.name,
-            ownValues: this._discriminantProperty.type.ownValues,
-            descendantValues: this._discriminantProperty.type.descendantValues,
-        });
-    }
-    get discriminantValue() {
-        return this.alias.unsafeCoerce();
-    }
     get equalsFunction() {
-        return code `${this.alias.unsafeCoerce()}.equals`;
+        return this.name
+            .map((name) => code `${name}.equals`)
+            .orDefaultLazy(() => ObjectType_equalsFunctionExpression.call(this));
     }
     get expression() {
-        return code `${this.alias.unsafeCoerce()}`;
+        return this.name
+            .map((name) => code `${name}`)
+            .orDefaultLazy(() => this.inlineExpression);
     }
     get filterFunction() {
-        return code `${this.alias.unsafeCoerce()}.filter`;
+        return this.name
+            .map((name) => code `${name}.filter`)
+            .orDefaultLazy(() => ObjectType_filterFunctionExpression.call(this));
     }
     get filterType() {
-        return code `${this.alias.unsafeCoerce()}.Filter`;
+        return this.name
+            .map((name) => code `${name}.Filter`)
+            .orDefaultLazy(() => ObjectType_filterTypeExpression.call(this));
+    }
+    get fromRdfResourceValuesFunction() {
+        return this.name
+            .map((name) => code `${name}.fromRdfResourceValues`)
+            .orDefaultLazy(() => code `((values, options) => values.chainMap(value => value.toResource().chain(resource => ${ObjectType_fromRdfResourceFunctionExpression.call(this)}(resource, options))))`);
     }
     get fromRdfTypeVariable() {
-        return this.fromRdfType.map(() => code `${this.alias.unsafeCoerce()}.fromRdfType`);
+        return this.fromRdfType.map((fromRdfType) => this.name
+            .map((name) => code `${name}.schema.fromRdfType`)
+            .orDefaultLazy(() => this.rdfjsTermExpression(fromRdfType)));
     }
     get graphqlType() {
-        return new AbstractType.GraphqlType(code `${this.alias.unsafeCoerce()}.GraphQL`, this.reusables);
+        return new AbstractType.GraphqlType(this.name
+            .map((name) => code `${name}.GraphQL`)
+            .orDefaultLazy(() => ObjectType_graphqlTypeExpression.call(this)), this.reusables);
     }
     get hashFunction() {
-        return code `${this.alias.unsafeCoerce()}.hash`;
+        return this.name
+            .map((name) => code `${name}.hash`)
+            .orDefaultLazy(() => ObjectType_hashFunctionExpression.call(this));
     }
     get identifierTypeAlias() {
-        return code `${this.alias.unsafeCoerce()}.Identifier`;
+        return code `${this.name.unsafeCoerce()}.Identifier`;
     }
     get mutable() {
         return this.properties.some((property) => property.mutable);
     }
     get objectSetMethodNames() {
         return ObjectType_objectSetMethodNames.call({
-            alias: this.alias.unsafeCoerce(),
+            name: this.name.unsafeCoerce(),
             configuration: this.configuration,
         });
     }
-    get parentObjectTypes() {
-        return this.lazyParentObjectTypes();
-    }
     get properties() {
         const properties = this.lazyProperties(this);
-        const propertyNames = new Set();
-        for (const property of properties) {
-            if (propertyNames.has(property.name)) {
-                throw new Error(`duplicate property '${property.name}'`);
-            }
-        }
+        invariant(properties.length > 0, `${this.name.extract()}: empty properties`);
         return properties;
     }
+    get referencesNamedType() {
+        return (this.name.isJust() ||
+            this.properties.some((property) => {
+                switch (property.kind) {
+                    case "Identifier":
+                    case "Shacl":
+                        return property.type.referencesNamedType;
+                    default:
+                        return false;
+                }
+            }));
+    }
     get schema() {
-        return code `${this.alias.unsafeCoerce()}.schema`;
+        return this.name
+            .map((name) => code `${name}.schema`)
+            .orDefaultLazy(() => ObjectType_schemaExpression.call(this));
     }
     get schemaType() {
-        return code `typeof ${this.schema}`;
+        return this.name
+            .map((name) => code `${name}.Schema`)
+            .orDefaultLazy(() => ObjectType_schemaTypeExpression.call(this));
     }
     get toRdfResourceValueTypes() {
         return new Set([...this.identifierType.nodeKinds].map(NodeKind.toTermType));
     }
     get toRdfjsResourceType() {
-        if (this.parentObjectTypes.length > 0) {
-            return this.parentObjectTypes[0].toRdfjsResourceType;
-        }
         return code `${this.reusables.imports.Resource}${this.identifierType.kind === "Iri" ? code `<${this.reusables.imports.NamedNode}>` : ""}`;
     }
     get valueSparqlConstructTriplesFunction() {
-        return code `${this.alias.unsafeCoerce()}.valueSparqlConstructTriples`;
+        return this.name
+            .map((name) => code `${name}.valueSparqlConstructTriples`)
+            .orDefaultLazy(() => ObjectType_valueSparqlConstructTriplesFunctionExpression.call(this));
     }
     get valueSparqlWherePatternsFunction() {
-        return code `${this.alias.unsafeCoerce()}.valueSparqlWherePatterns`;
+        return this.name
+            .map((name) => code `${name}.valueSparqlWherePatterns`)
+            .orDefaultLazy(() => ObjectType_valueSparqlWherePatternsFunctionExpression.call(this));
+    }
+    get constructorParameters() {
+        let hasQuestionToken = true;
+        const propertySignatures = [];
+        for (const property of this.properties) {
+            property.constructorParameter.ifJust((propertyConstructorParameter) => {
+                hasQuestionToken =
+                    hasQuestionToken && propertyConstructorParameter.hasQuestionToken;
+                propertySignatures.push(propertyConstructorParameter.signature);
+            });
+        }
+        invariant(propertySignatures.length > 0);
+        const typeExpression = code `{ ${joinCode(propertySignatures)} }`;
+        return {
+            hasQuestionToken,
+            signature: code `parameters${hasQuestionToken ? "?" : ""}: ${typeExpression}`,
+            type: {
+                expression: typeExpression,
+            },
+            variable: "parameters",
+        };
+    }
+    get createFunction() {
+        return this.name
+            .map((name) => code `${name}.create`)
+            .orDefaultLazy(() => ObjectType_createFunctionExpression.call(this));
     }
     get thisVariable() {
-        return code `_${camelCase(this.alias.unsafeCoerce())}`;
+        return this.name
+            .map((name) => code `_${camelCase(name)}`)
+            .orDefault(code `_object`);
+    }
+    get toJsonFunction() {
+        return this.name
+            .map((name) => code `${name}.toJson`)
+            .orDefaultLazy(() => ObjectType_toJsonFunctionExpression.call(this));
+    }
+    get toStringFunction() {
+        return this.name
+            .map((name) => code `${name}.${this.configuration.syntheticNamePrefix}toString`)
+            .orDefaultLazy(() => ObjectType_toStringFunctionExpression.call(this));
+    }
+    get inlineExpression() {
+        return code `{ ${joinCode(this.properties.map((property) => property.declaration), { on: "\n\n" })} }`;
     }
     fromJsonExpression({ variables, }) {
         // Assumes the JSON object has been recursively validated already.
-        return code `${this.alias.unsafeCoerce()}.fromJson(${variables.value})`;
-    }
-    fromRdfResourceValuesExpression({ variables, }) {
-        const { resourceValues: resourceValuesVariable, ...fromRdfResourceValuesOptionsTemp } = variables;
-        const fromRdfResourceValuesOptions = fromRdfResourceValuesOptionsTemp;
-        if (!this.configuration.features.has("ObjectSet")) {
-            delete fromRdfResourceValuesOptions["objectSet"];
-        }
-        return code `${this.alias.unsafeCoerce()}.fromRdfResourceValues(${resourceValuesVariable}, ${fromRdfResourceValuesOptions})`;
+        return code `${this.name.map((name) => code `${name}.fromJson`).orDefaultLazy(() => ObjectType_fromJsonFunctionExpression.call(this))}(${variables.value})`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
     }
     jsonSchema({ context, }) {
-        let expression = code `${this.alias.unsafeCoerce()}.Json.schema()`;
-        if (context === "property" &&
-            this.properties.some((property) => property.recursive)) {
-            expression = code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.alias.unsafeCoerce()}.Json> => ${expression})`;
-        }
-        return expression;
+        return this.name
+            .map((name) => {
+            let expression = code `${name}.Json.schema()`;
+            if (context === "property" &&
+                this.properties.some((property) => property.recursive)) {
+                expression = code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${name}.Json> => ${expression})`;
+            }
+            return expression;
+        })
+            .orDefaultLazy(() => ObjectType_jsonSchemaExpression.call(this));
     }
     jsonType() {
-        return new AbstractType.JsonType(code `${this.alias.unsafeCoerce()}.Json`);
+        return new AbstractType.JsonType(this.name
+            .map((name) => code `${name}.Json`)
+            .orDefaultLazy(() => ObjectType_jsonTypeExpression.call(this)));
     }
     jsonUiSchemaElement({ variables, }) {
-        return Maybe.of(code `${this.alias.unsafeCoerce()}.Json.uiSchema({ scopePrefix: ${variables.scopePrefix} })`);
+        return Maybe.of(code `${this.name
+            .map((name) => code `${name}.Json.uiSchema`)
+            .orDefaultLazy(() => ObjectType_jsonUiSchemaFunctionExpression.call(this))}({ scopePrefix: ${variables.scopePrefix} })`);
     }
     toJsonExpression({ variables, }) {
-        return code `${this.alias.unsafeCoerce()}.toJson(${variables.value})`;
+        const toJsonFunction = this.name
+            .map((name) => code `${name}.toJson`)
+            .orDefaultLazy(() => ObjectType_toJsonFunctionExpression.call(this));
+        return code `${toJsonFunction}(${variables.value})`;
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${this.alias.unsafeCoerce()}.toRdfResource(${variables.value}, { graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
+        const toRdfResourceFunction = this.name
+            .map((name) => code `${name}.toRdfResource`)
+            .orDefaultLazy(() => code `${this.reusables.snippets.wrap_ToRdfResourceFunction}<${this.identifierType.expression}, ${this.expression}>(${ObjectType_toRdfResourceFunctionExpression.call(this)})`);
+        return code `[${toRdfResourceFunction}(${variables.value}, { graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
     }
     toStringExpression({ variables, }) {
-        return code `${this.alias.unsafeCoerce()}.${this.configuration.syntheticNamePrefix}toString(${variables.value})`;
+        return this.name
+            .map((name) => code `${name}.${this.configuration.syntheticNamePrefix}toString(${variables.value})`)
+            .orDefaultLazy(() => code `JSON.stringify(${this.toStringRecordExpression({ variables })})`);
+    }
+    toStringRecordExpression({ variables, }) {
+        return code `${this.reusables.snippets.compactRecord}({${joinCode(this.properties.flatMap((property) => property
+            .toStringInitializer({
+            variables: {
+                value: property.accessExpression({
+                    variables: { object: variables.value },
+                }),
+            },
+        })
+            .toList()), { on: "," })}})`;
     }
-    lazyAncestorObjectTypes;
-    lazyChildObjectTypes;
-    lazyDescendantObjectTypes;
-    lazyDiscriminantProperty;
-    lazyParentObjectTypes;
     lazyProperties;
 }
 __decorate([
     Memoize()
-], ObjectType.prototype, "_discriminantProperty", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "ancestorObjectTypes", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "childObjectTypes", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "descendantFromRdfTypeVariables", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "descendantFromRdfTypes", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "descendantObjectTypes", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "discriminantProperty", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "discriminantValue", null);
+], ObjectType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "equalsFunction", null);
@@ -294,6 +421,9 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "fromRdfTypeVariable", null);
@@ -314,10 +444,10 @@ __decorate([
 ], ObjectType.prototype, "objectSetMethodNames", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "parentObjectTypes", null);
+], ObjectType.prototype, "properties", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "properties", null);
+], ObjectType.prototype, "referencesNamedType", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "schema", null);
@@ -336,9 +466,21 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "constructorParameters", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "createFunction", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "thisVariable", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "toJsonFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "toStringFunction", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "jsonType", null);