@shaclmate/compiler 4.0.39 → 4.0.40

package/dist/generators/ts/{_NamedObjectType → _ObjectType}/DiscriminantProperty.js

@@ -19,7 +19,7 @@ export class DiscriminantProperty extends AbstractProperty {
         super({ ...superParameters, type });
     }
     get declaration() {
-        return code `readonly ${this.name}: ${this.type.name};`;
+        return code `readonly ${this.name}: ${this.type.expression};`;
     }
     get jsonName() {
         return "@type";
@@ -33,7 +33,7 @@ export class DiscriminantProperty extends AbstractProperty {
         });
     }
     get jsonSignature() {
-        return Maybe.of(code `readonly "${this.jsonName}": ${this.type.name}`);
+        return Maybe.of(code `readonly "${this.jsonName}": ${this.type.expression}`);
     }
     get schema() {
         return Maybe.empty();
@@ -42,7 +42,7 @@ export class DiscriminantProperty extends AbstractProperty {
     //   return super.schemaInitializers.concat(code`type: ${this.type.schema}`);
     // }
     get constValue() {
-        return code `${literalOf(this.namedObjectType.discriminantValue)} as const`;
+        return code `${literalOf(this.objectType.discriminantValue)} as const`;
     }
     constructorInitializer() {
         return Maybe.empty();
@@ -54,13 +54,13 @@ export class DiscriminantProperty extends AbstractProperty {
         return Maybe.empty();
     }
     hashStatements({ variables, }) {
-        if (this.namedObjectType.parentObjectTypes.length > 0) {
+        if (this.objectType.parentObjectTypes.length > 0) {
             return [];
         }
         return [code `${variables.hasher}.update(${variables.value});`];
     }
     jsonUiSchemaElement({ variables, }) {
-        if (this.namedObjectType.parentObjectTypes.length > 0) {
+        if (this.objectType.parentObjectTypes.length > 0) {
             return Maybe.empty();
         }
         const scope = code `\`\${${variables.scopePrefix}}/properties/${this.jsonName}\``;
@@ -102,8 +102,8 @@ __decorate([
             this.mutable = mutable;
             this.ownValues = ownValues;
         }
-        get name() {
-            return `${this.values.map((name) => `"${name}"`).join(" | ")}`;
+        get expression() {
+            return code `${this.values.map((name) => `"${name}"`).join(" | ")}`;
         }
         get schema() {
             throw new Error("should never be called");
@@ -122,7 +122,7 @@ __decorate([
     }
     __decorate([
         Memoize()
-    ], Type.prototype, "name", null);
+    ], Type.prototype, "expression", null);
     __decorate([
         Memoize()
     ], Type.prototype, "schema", null);

package/dist/generators/ts/{_NamedObjectType → _ObjectType}/IdentifierProperty.d.ts

@@ -5,14 +5,9 @@ import type { IriType } from "../IriType.js";
 import { type Code } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export declare class IdentifierProperty extends AbstractProperty<BlankNodeType | IdentifierType | IriType> {
-    private readonly typeAlias;
     readonly kind = "Identifier";
     readonly mutable = false;
     readonly recursive = false;
-    constructor({ typeAlias, ...superParameters }: {
-        type: BlankNodeType | IdentifierType | IriType;
-        typeAlias: Code;
-    } & ConstructorParameters<typeof AbstractProperty>[0]);
     get constructorParameter(): Maybe<Code>;
     get declaration(): Code;
     get filterProperty(): Maybe<{
@@ -23,6 +18,7 @@ export declare class IdentifierProperty extends AbstractProperty<BlankNodeType |
     get jsonSchema(): AbstractProperty<IdentifierType>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
     protected get schemaInitializers(): readonly Code[];
+    private get typeExpression();
     accessExpression({ variables, }: Parameters<AbstractProperty<BlankNodeType | IdentifierType | IriType>["accessExpression"]>[0]): Code;
     constructorInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["constructorInitializer"]>[0]): Maybe<Code>;
     fromJsonInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromJsonInitializer"]>[0]): Maybe<Code>;

package/dist/generators/ts/{_NamedObjectType → _ObjectType}/IdentifierProperty.js

@@ -12,30 +12,25 @@ import { Memoize } from "typescript-memoize";
 import { arrayOf, code, joinCode, literalOf, } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export class IdentifierProperty extends AbstractProperty {
-    typeAlias;
     kind = "Identifier";
     mutable = false;
     recursive = false;
-    constructor({ typeAlias, ...superParameters }) {
-        super(superParameters);
-        this.typeAlias = typeAlias;
-    }
     get constructorParameter() {
         let hasQuestionToken = false;
-        const typeNames = [code `(() => ${this.typeAlias})`];
+        const typeNames = [code `(() => ${this.typeExpression})`];
         for (const type of this.type.conversionFunction.unsafeCoerce()
             .sourceTypes) {
             if (type.typeof === "undefined") {
                 hasQuestionToken = true;
             }
             else {
-                typeNames.push(code `${type.name}`);
+                typeNames.push(code `${type.expression}`);
             }
         }
         return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeNames, { on: "|" })};`);
     }
     get declaration() {
-        return code `readonly ${this.name}: () => ${this.typeAlias};`;
+        return code `readonly ${this.name}: () => ${this.typeExpression};`;
     }
     get filterProperty() {
         return Maybe.of({
@@ -50,7 +45,7 @@ export class IdentifierProperty extends AbstractProperty {
             args: Maybe.empty(),
             description: Maybe.empty(),
             name: `_${this.name.substring(syntheticNamePrefix.length)}`,
-            resolve: code `(source) => ${this.typeAlias}.stringify(${this.accessExpression({ variables: { object: code `source` } })})`,
+            resolve: code `(source) => ${this.typeExpression}.stringify(${this.accessExpression({ variables: { object: code `source` } })})`,
             type: this.type.graphqlType.name,
         });
     }
@@ -78,6 +73,11 @@ export class IdentifierProperty extends AbstractProperty {
     get schemaInitializers() {
         return super.schemaInitializers.concat(code `type: ${this.type.schema}`);
     }
+    get typeExpression() {
+        return this.objectType.alias
+            .map((objectTypeAlias) => code `${objectTypeAlias}.Identifier`)
+            .orDefault(this.type.expression);
+    }
     accessExpression({ variables, }) {
         return code `${variables.object}.${this.name}()`;
     }
@@ -131,7 +131,9 @@ export class IdentifierProperty extends AbstractProperty {
                 ignoreRdfType: true, // Unused
                 preferredLanguages: variables.preferredLanguages,
                 propertyPatterns: code `[]`,
-                schema: code `${this.namedObjectType.name}.schema.properties.${this.name}.type`,
+                schema: this.objectType.alias
+                    .map((objectTypeAlias) => code `${objectTypeAlias}.schema.properties.${this.name}.type`)
+                    .orDefault(this.type.schema),
                 valueVariable: variables.focusIdentifier,
                 variablePrefix: variables.variablePrefix, // Unused
             }})`,
@@ -180,4 +182,7 @@ __decorate([
 __decorate([
     Memoize()
 ], IdentifierProperty.prototype, "jsonSignature", null);
+__decorate([
+    Memoize()
+], IdentifierProperty.prototype, "typeExpression", null);
 //# sourceMappingURL=IdentifierProperty.js.map

package/dist/generators/ts/_ObjectType/ObjectType_createFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_createFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_createFunctionDeclaration.d.ts.map

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_createFunctionDeclaration.js → _ObjectType/ObjectType_createFunctionDeclaration.js}

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
-export function NamedObjectType_createFunctionDeclaration() {
+export function ObjectType_createFunctionDeclaration() {
     if (!this.configuration.features.has("Object.create")) {
         return Maybe.empty();
     }
@@ -11,7 +11,7 @@ export function NamedObjectType_createFunctionDeclaration() {
         parametersType.push(code `{ ${joinCode(parametersPropertySignatures)} }`);
     }
     for (const parentObjectType of this.parentObjectTypes) {
-        parametersType.push(code `Parameters<typeof ${parentObjectType.name}.create>[0]`);
+        parametersType.push(code `Parameters<typeof ${parentObjectType.alias.unsafeCoerce()}.create>[0]`);
     }
     if (parametersType.length === 0) {
         parametersType.push(code `object`);
@@ -23,7 +23,7 @@ export function NamedObjectType_createFunctionDeclaration() {
     const chains = [];
     this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
         chains.push({
-            expression: code `${parentObjectType.name}.create(parameters)`,
+            expression: code `${parentObjectType.alias.unsafeCoerce()}.create(parameters)`,
             variable: `super${parentObjectTypeI}`,
         });
     });
@@ -54,12 +54,12 @@ export function NamedObjectType_createFunctionDeclaration() {
         .toReversed()
         .reduce((acc, { expression, variable }, chainI) => code `(${expression}).${chainI === 0 ? "map" : "chain"}(${variable} => ${acc})`, returnExpression);
     return Maybe.of(code `\
-export function create(${parametersSignature}): ${this.reusables.imports.Either}<Error, ${this.name}> {
+export function create(${parametersSignature}): ${this.reusables.imports.Either}<Error, ${this.expression}> {
   return ${returnExpression};
 }
   
-export function createUnsafe(${parametersSignature}): ${this.name} {
+export function createUnsafe(${parametersSignature}): ${this.expression} {
   return create(parameters).unsafeCoerce();
 }`);
 }
-//# sourceMappingURL=NamedObjectType_createFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_createFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_equalsFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_equalsFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_equalsFunctionDeclaration.d.ts.map

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_equalsFunctionDeclaration.js → _ObjectType/ObjectType_equalsFunctionDeclaration.js}

@@ -1,13 +1,13 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_equalsFunctionDeclaration() {
+export function ObjectType_equalsFunctionDeclaration() {
     if (!this.configuration.features.has("Object.equals")) {
         return Maybe.empty();
     }
     const chain = [];
     // For every parent, find the nearest equals implementation
     for (const parentObjectType of this.parentObjectTypes) {
-        chain.push(code `${parentObjectType.name}.equals(left, right)`);
+        chain.push(code `${parentObjectType.equalsFunction}(left, right)`);
     }
     for (const property of this.properties) {
         if (property.kind === "Discriminant") {
@@ -16,8 +16,8 @@ export function NamedObjectType_equalsFunctionDeclaration() {
         chain.push(code `(${property.type.equalsFunction})(${property.accessExpression({ variables: { object: code `left` } })}, ${property.accessExpression({ variables: { object: code `right` } })}).mapLeft(propertyValuesUnequal => ({ left, right, propertyName: "${property.name}", propertyValuesUnequal, type: "property" as const }))`);
     }
     return Maybe.of(code `\
-export function equals(left: ${this.name}, right: ${this.name}): ${this.reusables.snippets.EqualsResult} {
+export function equals(left: ${this.expression}, right: ${this.expression}): ${this.reusables.snippets.EqualsResult} {
   return ${joinCode(chain.map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : code `chain(() => ${chainPart})`), { on: "." })}
 }`);
 }
-//# sourceMappingURL=NamedObjectType_equalsFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_equalsFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_filterFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_filterFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_filterFunctionDeclaration.d.ts.map

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_filterFunctionDeclaration.js → _ObjectType/ObjectType_filterFunctionDeclaration.js}

@@ -1,6 +1,6 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_filterFunctionDeclaration() {
+export function ObjectType_filterFunctionDeclaration() {
     if (!this.configuration.features.has("Object.filter")) {
         return Maybe.empty();
     }
@@ -17,8 +17,8 @@ export function NamedObjectType_filterFunctionDeclaration() {
     }
     statements.push(code `return true;`);
     return Maybe.of(code `\
-export function filter(filter: ${this.filterType}, value: ${this.name}): boolean {
+export function filter(filter: ${this.filterType}, value: ${this.expression}): boolean {
   ${joinCode(statements)}
 }`);
 }
-//# sourceMappingURL=NamedObjectType_filterFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_filterFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_filterTypeDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_filterTypeDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_filterTypeDeclaration.d.ts.map

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_filterTypeDeclaration.js → _ObjectType/ObjectType_filterTypeDeclaration.js}

@@ -1,6 +1,6 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_filterTypeDeclaration() {
+export function ObjectType_filterTypeDeclaration() {
     if (!this.configuration.features.has("Object.filter")) {
         return Maybe.empty();
     }
@@ -17,9 +17,9 @@ export function NamedObjectType_filterTypeDeclaration() {
         }
     }
     for (const parentObjectType of this.parentObjectTypes) {
-        members.push(code `${parentObjectType.name}.Filter`);
+        members.push(code `${parentObjectType.alias.unsafeCoerce()}.Filter`);
     }
     return Maybe.of(code `\
 export type Filter = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`);
 }
-//# sourceMappingURL=NamedObjectType_filterTypeDeclaration.js.map
+//# sourceMappingURL=ObjectType_filterTypeDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_focusSparqlConstructTriplesFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_focusSparqlConstructTriplesFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_focusSparqlConstructTriplesFunctionDeclaration.d.ts.map

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.js → _ObjectType/ObjectType_focusSparqlConstructTriplesFunctionDeclaration.js}

@@ -6,7 +6,7 @@ const variables = {
     focusIdentifier: code `parameters.focusIdentifier`,
     variablePrefix: code `parameters.variablePrefix`,
 };
-export function NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration() {
+export function ObjectType_focusSparqlConstructTriplesFunctionDeclaration() {
     if (!this.configuration.features.has("Object.SPARQL")) {
         return Maybe.empty();
     }
@@ -15,7 +15,7 @@ export function NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration()
     let triplesVariableDeclarationKeyword = "const";
     const statements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        statements.push(code `triples = triples.concat(${parentObjectType.name}.focusSparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
+        statements.push(code `triples = triples.concat(${parentObjectType.alias.unsafeCoerce()}.focusSparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
         triplesVariableDeclarationKeyword = "let";
     }
     if (this.fromRdfType.isJust()) {
@@ -51,4 +51,4 @@ ${statements.length > 0
         : "return [];"}
 };`);
 }
-//# sourceMappingURL=NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_focusSparqlConstructTriplesFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_focusSparqlWherePatternsFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_focusSparqlWherePatternsFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_focusSparqlWherePatternsFunctionDeclaration.d.ts.map

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.js → _ObjectType/ObjectType_focusSparqlWherePatternsFunctionDeclaration.js}

@@ -7,7 +7,7 @@ const variables = {
     focusIdentifier: code `parameters.focusIdentifier`,
     variablePrefix: code `parameters.variablePrefix`,
 };
-export function NamedObjectType_focusSparqlWherePatternsFunctionDeclaration() {
+export function ObjectType_focusSparqlWherePatternsFunctionDeclaration() {
     if (!this.configuration.features.has("Object.SPARQL")) {
         return Maybe.empty();
     }
@@ -17,7 +17,7 @@ export function NamedObjectType_focusSparqlWherePatternsFunctionDeclaration() {
     const statements = [];
     for (const parentObjectType of this.parentObjectTypes) {
         statements.push(code `\
-patterns = patterns.concat(${parentObjectType.name}.focusSparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
+patterns = patterns.concat(${parentObjectType.alias.unsafeCoerce()}.focusSparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
         patternsVariableDeclarationKeyword = "let";
     }
     if (this.fromRdfType.isJust()) {
@@ -99,4 +99,4 @@ ${statements.length > 0
         : "return [];"}
 };`);
 }
-//# sourceMappingURL=NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_focusSparqlWherePatternsFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_fromJsonFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_fromJsonFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_fromJsonFunctionDeclaration.d.ts.map

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_fromJsonFunctionDeclaration.js → _ObjectType/ObjectType_fromJsonFunctionDeclaration.js}

@@ -1,6 +1,6 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_fromJsonFunctionDeclaration() {
+export function ObjectType_fromJsonFunctionDeclaration() {
     if (!this.configuration.features.has("Object.fromJson")) {
         return Maybe.empty();
     }
@@ -10,7 +10,7 @@ export function NamedObjectType_fromJsonFunctionDeclaration() {
     const chains = [];
     this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
         chains.push({
-            expression: code `${parentObjectType.name}.fromJson(${variables.jsonObject})`,
+            expression: code `${parentObjectType.alias.unsafeCoerce()}.fromJson(${variables.jsonObject})`,
             variable: `super${parentObjectTypeI}`,
         });
     });
@@ -36,8 +36,8 @@ export function NamedObjectType_fromJsonFunctionDeclaration() {
             break;
     }
     return Maybe.of(code `\
-export function fromJson(${variables.jsonObject}: ${this.jsonType().name}): ${this.reusables.imports.Either}<Error, ${this.name}> {
+export function fromJson(${variables.jsonObject}: ${this.jsonType().name}): ${this.reusables.imports.Either}<Error, ${this.expression}> {
   return ${returnExpression};
 }`);
 }
-//# sourceMappingURL=NamedObjectType_fromJsonFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_fromJsonFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfResourceFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_fromRdfResourceFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_fromRdfResourceFunctionDeclaration.d.ts.map

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_fromRdfResourceFunctionDeclaration.js → _ObjectType/ObjectType_fromRdfResourceFunctionDeclaration.js}

@@ -1,6 +1,6 @@
 import { Maybe } from "purify-ts";
 import { arrayOf, code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
+export function ObjectType_fromRdfResourceFunctionDeclaration() {
     if (!this.configuration.features.has("Object.fromRdf")) {
         return Maybe.empty();
     }
@@ -25,7 +25,7 @@ export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
     const partials = [];
     this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
         chains.push({
-            expression: code `${parentObjectType.name}._fromRdfResource(${variables.resource}, { ...${optionsVariable}, ignoreRdfType: true })`,
+            expression: code `${parentObjectType.alias.unsafeCoerce()}._fromRdfResource(${variables.resource}, { ...${optionsVariable}, ignoreRdfType: true })`,
             variable: `super${parentObjectTypeI}`,
         });
         partials.push(`super${parentObjectTypeI}`);
@@ -71,10 +71,10 @@ export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
             .reduce((acc, { expression, variable }) => code `(${expression}).chain(${variable} => ${acc})`, code `(${resultExpression})`)}`;
     }
     return Maybe.of(code `\
-export const _fromRdfResource: ${this.reusables.snippets._FromRdfResourceFunction}<${this.name}> = (${variables.resource}, ${optionsVariable}) => {
+export const _fromRdfResource: ${this.reusables.snippets._FromRdfResourceFunction}<${this.expression}> = (${variables.resource}, ${optionsVariable}) => {
   return ${returnExpression};
 }
 
 export const fromRdfResource = ${this.reusables.snippets.wrap_FromRdfResourceFunction}(_fromRdfResource);`);
 }
-//# sourceMappingURL=NamedObjectType_fromRdfResourceFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_fromRdfResourceFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfResourceValuesFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_fromRdfResourceValuesFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_fromRdfResourceValuesFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfResourceValuesFunctionDeclaration.js

@@ -0,0 +1,15 @@
+import { Maybe } from "purify-ts";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_fromRdfResourceValuesFunctionDeclaration() {
+    if (!this.configuration.features.has("Object.fromRdf")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.alias.unsafeCoerce()}> = (values, options) => 
+  values.chain(
+    values => values.chainMap(
+      value => value.toResource().chain(resource => ${this.alias.unsafeCoerce()}.fromRdfResource(resource, options))
+    )
+  );`);
+}
+//# sourceMappingURL=ObjectType_fromRdfResourceValuesFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfTypeVariableStatement.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_fromRdfTypeVariableStatement(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_fromRdfTypeVariableStatement.d.ts.map

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_fromRdfTypeVariableStatement.js → _ObjectType/ObjectType_fromRdfTypeVariableStatement.js}

@@ -1,10 +1,10 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
-export function NamedObjectType_fromRdfTypeVariableStatement() {
+export function ObjectType_fromRdfTypeVariableStatement() {
     if (!this.configuration.features.has("Object.fromRdf")) {
         return Maybe.empty();
     }
     return this.fromRdfType.map((fromRdfType) => code `\
 export const fromRdfType: ${this.reusables.imports.NamedNode}<string> = ${this.rdfjsTermExpression(fromRdfType)};`);
 }
-//# sourceMappingURL=NamedObjectType_fromRdfTypeVariableStatement.js.map
+//# sourceMappingURL=ObjectType_fromRdfTypeVariableStatement.js.map

package/dist/generators/ts/_ObjectType/ObjectType_graphqlTypeVariableStatement.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_graphqlTypeVariableStatement(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_graphqlTypeVariableStatement.d.ts.map

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_graphqlTypeVariableStatement.js → _ObjectType/ObjectType_graphqlTypeVariableStatement.js}

@@ -1,6 +1,6 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
-export function NamedObjectType_graphqlTypeVariableStatement() {
+export function ObjectType_graphqlTypeVariableStatement() {
     if (!this.configuration.features.has("GraphQL")) {
         return Maybe.empty();
     }
@@ -8,7 +8,7 @@ export function NamedObjectType_graphqlTypeVariableStatement() {
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export const GraphQL = new ${this.reusables.imports.GraphQLObjectType}<${this.name}, { objectSet: ${this.configuration.syntheticNamePrefix}ObjectSet }>(${{
+export const GraphQL = new ${this.reusables.imports.GraphQLObjectType}<${this.expression}, { objectSet: ${this.configuration.syntheticNamePrefix}ObjectSet }>(${{
         description: this.comment.extract(),
         fields: code `() => (${this.properties.reduce((fields, property) => {
             property.graphqlField.ifJust((field) => {
@@ -27,7 +27,7 @@ export const GraphQL = new ${this.reusables.imports.GraphQLObjectType}<${this.na
             });
             return fields;
         }, {})})`,
-        name: this.name,
+        name: this.alias.unsafeCoerce(),
     }});`);
 }
-//# sourceMappingURL=NamedObjectType_graphqlTypeVariableStatement.js.map
+//# sourceMappingURL=ObjectType_graphqlTypeVariableStatement.js.map

package/dist/generators/ts/_ObjectType/ObjectType_hashFunctionDeclarations.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_hashFunctionDeclarations(this: ObjectType): readonly Code[];
+//# sourceMappingURL=ObjectType_hashFunctionDeclarations.d.ts.map

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_hashFunctionDeclarations.js → _ObjectType/ObjectType_hashFunctionDeclarations.js}

@@ -1,6 +1,6 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
 const hasherVariable = code `hasher`;
-export function NamedObjectType_hashFunctionDeclarations() {
+export function ObjectType_hashFunctionDeclarations() {
     if (!this.configuration.features.has("Object.hash")) {
         return [];
     }
@@ -17,9 +17,9 @@ export function NamedObjectType_hashFunctionDeclarations() {
     const hashShaclPropertiesStatements = [];
     const hashStatements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        hashShaclPropertiesStatements.push(code `${parentObjectType.name}.hashShaclProperties(${hasherVariable}, ${this.thisVariable});`);
+        hashShaclPropertiesStatements.push(code `${parentObjectType.alias.unsafeCoerce()}.hashShaclProperties(${hasherVariable}, ${this.thisVariable});`);
     }
-    hashStatements.push(code `${this.name}.hashShaclProperties(${hasherVariable}, ${this.thisVariable});`);
+    hashStatements.push(code `${this.alias.unsafeCoerce()}.hashShaclProperties(${hasherVariable}, ${this.thisVariable});`);
     hashShaclPropertiesStatements.push(...hashOwnShaclPropertiesStatements);
     hashShaclPropertiesStatements.push(code `return ${hasherVariable};`);
     hashStatements.push(...this.properties
@@ -33,13 +33,13 @@ export function NamedObjectType_hashFunctionDeclarations() {
     hashStatements.push(code `return ${hasherVariable};`);
     return [
         code `\
-export function hash<HasherT extends ${this.reusables.snippets.Hasher}>(${hasherVariable}: HasherT, ${this.thisVariable}: ${this.name}): HasherT {
+export function hash<HasherT extends ${this.reusables.snippets.Hasher}>(${hasherVariable}: HasherT, ${this.thisVariable}: ${this.expression}): HasherT {
   ${joinCode(hashStatements)}
 }`,
         code `\
-export function hashShaclProperties<HasherT extends ${this.reusables.snippets.Hasher}>(${hasherVariable}: HasherT, ${this.thisVariable}: ${this.name}): HasherT {
+export function hashShaclProperties<HasherT extends ${this.reusables.snippets.Hasher}>(${hasherVariable}: HasherT, ${this.thisVariable}: ${this.expression}): HasherT {
   ${joinCode(hashShaclPropertiesStatements)}
 }`,
     ];
 }
-//# sourceMappingURL=NamedObjectType_hashFunctionDeclarations.js.map
+//# sourceMappingURL=ObjectType_hashFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectType/ObjectType_interfaceDeclaration.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_interfaceDeclaration(this: ObjectType): Code;
+//# sourceMappingURL=ObjectType_interfaceDeclaration.d.ts.map

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_interfaceDeclaration.js → _ObjectType/ObjectType_interfaceDeclaration.js}

@@ -1,16 +1,16 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
 import { tsComment } from "../tsComment.js";
-export function NamedObjectType_interfaceDeclaration() {
+export function ObjectType_interfaceDeclaration() {
     return code `\
 ${this.comment
         .alt(this.label)
         .map(tsComment)
-        .orDefault("")}export interface ${this.name}${this.parentObjectTypes.length > 0
+        .orDefault("")}export interface ${this.alias.unsafeCoerce()}${this.parentObjectTypes.length > 0
         ? ` extends ${this.parentObjectTypes
-            .map((parentObjectType) => parentObjectType.name)
+            .map((parentObjectType) => parentObjectType.alias.unsafeCoerce())
             .join(", ")}`
         : ""} {
   ${joinCode(this.properties.map((property) => property.declaration), { on: "\n\n" })}
 }`;
 }
-//# sourceMappingURL=NamedObjectType_interfaceDeclaration.js.map
+//# sourceMappingURL=ObjectType_interfaceDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_isTypeFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_isTypeFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_isTypeFunctionDeclaration.d.ts.map

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_isTypeFunctionDeclaration.js → _ObjectType/ObjectType_isTypeFunctionDeclaration.js}

@@ -1,11 +1,11 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
-export function NamedObjectType_isTypeFunctionDeclaration() {
+export function ObjectType_isTypeFunctionDeclaration() {
     if (!this.configuration.features.has("Object.type")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export function is${this.name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${this.name} {
+export function is${this.alias.unsafeCoerce()}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${this.alias.unsafeCoerce()} {
   switch (object.${this._discriminantProperty.name}) {
     ${this._discriminantProperty.type.descendantValues
         .concat(this._discriminantProperty.type.ownValues)
@@ -14,4 +14,4 @@ export function is${this.name}(object: ${this.configuration.syntheticNamePrefix}
   }
 }`);
 }
-//# sourceMappingURL=NamedObjectType_isTypeFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_isTypeFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_jsonParseFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_jsonParseFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_jsonParseFunctionDeclaration.d.ts.map