@shaclmate/compiler 4.0.41 → 4.0.42

package/dist/generators/ts/LiteralType.d.ts

@@ -3,10 +3,11 @@ import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class LiteralType extends AbstractLiteralType {
-    readonly expression: Code;
+    protected readonly inlineExpression: Code;
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
+    readonly fromRdfResourceValuesFunction: Code;
     readonly jsTypes: readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";
@@ -20,7 +21,7 @@ export declare class LiteralType extends AbstractLiteralType {
     graphqlResolveExpression(_parameters: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractLiteralType["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractLiteralType["jsonType"]>[0]): AbstractLiteralType.JsonType;
-    literalExpression(literal: Literal): Code;
+    literalValueExpression(literal: Literal): Code;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/dist/generators/ts/LiteralType.js

@@ -3,7 +3,7 @@ import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class LiteralType extends AbstractLiteralType {
-    expression = code `${this.reusables.imports.Literal}`;
+    inlineExpression = code `${this.reusables.imports.Literal}`;
     conversionFunction = Maybe.of({
         code: code `${this.reusables.snippets.convertToLiteral}`,
         sourceTypes: [
@@ -23,6 +23,7 @@ export class LiteralType extends AbstractLiteralType {
     });
     filterFunction = code `${this.reusables.snippets.filterLiteral}`;
     filterType = code `${this.reusables.snippets.LiteralFilter}`;
+    fromRdfResourceValuesFunction = code `${this.reusables.snippets.literalFromRdfResourceValues}`;
     jsTypes = [
         { instanceof: "Object", typeof: "object" },
     ];
@@ -37,6 +38,9 @@ export class LiteralType extends AbstractLiteralType {
         if (this.in_.length > 0) {
             initializers = initializers.concat(code `in: ${arrayOf(...this.in_.map((in_) => this.rdfjsTermExpression(in_)))}`);
         }
+        if (this.languageIn.length > 0) {
+            initializers = initializers.concat(code `languageIn: ${arrayOf(...this.languageIn)}`);
+        }
         return initializers;
     }
     fromJsonExpression({ variables, }) {
@@ -57,7 +61,7 @@ export class LiteralType extends AbstractLiteralType {
             : "";
         return new AbstractLiteralType.JsonType(code `{ readonly "@language"?: string${discriminantProperty}, readonly "@type"?: string, readonly "@value": string }`);
     }
-    literalExpression(literal) {
+    literalValueExpression(literal) {
         return this.rdfjsTermExpression(literal);
     }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {

package/dist/generators/ts/ObjectType.d.ts

@@ -12,7 +12,6 @@ import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class ObjectType extends AbstractType {
     protected readonly toRdfTypes: readonly NamedNode[];
-    readonly conversionFunction: Maybe<AbstractType.ConversionFunction>;
     readonly discriminantProperty: Maybe<ObjectType.DiscriminantProperty>;
     readonly extern: boolean;
     readonly fromRdfType: Maybe<NamedNode>;
@@ -24,7 +23,6 @@ export declare class ObjectType extends AbstractType {
     }];
     readonly kind = "Object";
     readonly recursive: boolean;
-    readonly referencesObjectType = true;
     readonly synthetic: boolean;
     readonly validationFunction: Maybe<Code>;
     constructor({ discriminantProperty, extern, fromRdfType, identifierType, lazyProperties, recursive, synthetic, toRdfTypes, ...superParameters }: {
@@ -39,11 +37,13 @@ export declare class ObjectType extends AbstractType {
         synthetic: boolean;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof AbstractType>[0]);
+    get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
     get declaration(): Maybe<Code>;
     get equalsFunction(): Code;
     get expression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
+    get fromRdfResourceValuesFunction(): Code;
     get fromRdfTypeVariable(): Maybe<Code>;
     get graphqlType(): AbstractType.GraphqlType;
     get hashFunction(): Code;
@@ -51,15 +51,27 @@ export declare class ObjectType extends AbstractType {
     get mutable(): boolean;
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
     get properties(): readonly ObjectType.Property[];
+    get referencesNamedType(): boolean;
     get schema(): Code;
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get toRdfjsResourceType(): Code;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
+    protected get constructorParameters(): {
+        hasQuestionToken: boolean;
+        signature: Code;
+        type: {
+            expression: Code;
+        };
+        variable: string;
+    };
+    protected get createFunction(): Code;
     protected get thisVariable(): Code;
+    protected get toJsonFunction(): Code;
+    protected get toStringFunction(): Code;
+    private get inlineExpression();
     fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
-    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: {
         variables: {
             value: Code;
@@ -71,6 +83,7 @@ export declare class ObjectType extends AbstractType {
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
+    protected toStringRecordExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
     private readonly lazyProperties;
 }
 export declare namespace ObjectType {

package/dist/generators/ts/ObjectType.js

@@ -7,43 +7,43 @@ 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;
@@ -54,7 +54,6 @@ export class ObjectType extends AbstractType {
     ];
     kind = "Object";
     recursive;
-    referencesObjectType = true;
     synthetic;
     validationFunction = Maybe.empty();
     constructor({ discriminantProperty, extern, fromRdfType, identifierType, lazyProperties, recursive, synthetic, toRdfTypes, ...superParameters }) {
@@ -69,41 +68,137 @@ export class ObjectType extends AbstractType {
         this.synthetic = synthetic;
         this.toRdfTypes = toRdfTypes;
     }
+    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" })}
 }`);
             }
@@ -114,53 +209,83 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return Maybe.of(joinCode(declarations, { on: "\n\n" }));
     }
     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 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));
@@ -169,54 +294,121 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         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: "," })}})`;
     }
     lazyProperties;
 }
+__decorate([
+    Memoize()
+], ObjectType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "equalsFunction", null);
@@ -229,6 +421,9 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "fromRdfTypeVariable", null);
@@ -250,6 +445,9 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType.prototype, "properties", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "referencesNamedType", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "schema", null);
@@ -268,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);