@shaclmate/compiler 4.0.39 → 4.0.40

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

@@ -1,6 +1,6 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
-export function NamedObjectType_jsonParseFunctionDeclaration() {
+export function ObjectType_jsonParseFunctionDeclaration() {
     if (!this.configuration.features.has("Object.JSON.parse")) {
         return Maybe.empty();
     }
@@ -11,4 +11,4 @@ export function parse(json: unknown): ${this.reusables.imports.Either}<Error, Js
   return ${this.reusables.imports.Right}(jsonSafeParseResult.data);
 }`);
 }
-//# sourceMappingURL=NamedObjectType_jsonParseFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_jsonParseFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_jsonSchemaFunctionDeclaration.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_jsonSchemaFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_jsonSchemaFunctionDeclaration.d.ts.map

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

@@ -1,6 +1,6 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_jsonSchemaFunctionDeclaration() {
+export function ObjectType_jsonSchemaFunctionDeclaration() {
     if (!this.configuration.features.has("Object.JSON.schema")) {
         return Maybe.empty();
     }
@@ -28,4 +28,4 @@ export function schema() {
   return ${this.reusables.imports.z}.object({${joinCode(properties, { on: "," })}}).meta(${meta}) satisfies ${this.reusables.imports.z}.ZodType<Json>;
 }`);
 }
-//# sourceMappingURL=NamedObjectType_jsonSchemaFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_jsonSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_jsonTypeAliasDeclaration.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_jsonTypeAliasDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_jsonTypeAliasDeclaration.d.ts.map

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

@@ -1,6 +1,6 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_jsonTypeAliasDeclaration() {
+export function ObjectType_jsonTypeAliasDeclaration() {
     if (!this.configuration.features.has("Object.JSON.type")) {
         return Maybe.empty();
     }
@@ -13,4 +13,4 @@ export function NamedObjectType_jsonTypeAliasDeclaration() {
     }
     return Maybe.of(code `export type Json = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`);
 }
-//# sourceMappingURL=NamedObjectType_jsonTypeAliasDeclaration.js.map
+//# sourceMappingURL=ObjectType_jsonTypeAliasDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_jsonUiSchemaFunctionDeclaration.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_jsonUiSchemaFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_jsonUiSchemaFunctionDeclaration.d.ts.map

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

@@ -1,17 +1,17 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_jsonUiSchemaFunctionDeclaration() {
+export function ObjectType_jsonUiSchemaFunctionDeclaration() {
     if (!this.configuration.features.has("Object.JSON.uiSchema")) {
         return Maybe.empty();
     }
     const variables = { scopePrefix: code `scopePrefix` };
     const elements = this.parentObjectTypes
-        .map((parentObjectType) => code `${parentObjectType.name}.Json.uiSchema({ scopePrefix })`)
+        .map((parentObjectType) => code `${parentObjectType.alias.unsafeCoerce()}.Json.uiSchema({ scopePrefix })`)
         .concat(this.properties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
     return Maybe.of(code `\
 export function uiSchema(parameters?: { scopePrefix?: string }): any {
   const scopePrefix = parameters?.scopePrefix ?? "#";
-  return { "elements": [ ${joinCode(elements, { on: "," })} ], label: "${this.label.orDefault(this.name)}", type: "Group" };
+  return { "elements": [ ${joinCode(elements, { on: "," })} ], label: "${this.label.orDefault(this.alias.unsafeCoerce())}", type: "Group" };
 }`);
 }
-//# sourceMappingURL=NamedObjectType_jsonUiSchemaFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_jsonUiSchemaFunctionDeclaration.js.map

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

@@ -1,11 +1,11 @@
 import type { TsGenerator } from "../TsGenerator.js";
-export declare function NamedObjectType_objectSetMethodNames(this: {
+export declare function ObjectType_objectSetMethodNames(this: {
+    readonly alias: string;
     readonly configuration: TsGenerator.Configuration;
-    readonly name: string;
 }): {
     object: string;
     objectCount: string;
     objectIdentifiers: string;
     objects: string;
 };
-//# sourceMappingURL=NamedObjectType_objectSetMethodNames.d.ts.map
+//# sourceMappingURL=ObjectType_objectSetMethodNames.d.ts.map

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

@@ -1,11 +1,11 @@
 import { camelCase, trainCase } from "change-case";
 import plur from "plur";
-export function NamedObjectType_objectSetMethodNames() {
+export function ObjectType_objectSetMethodNames() {
     const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-    const prefixSingular = camelCase(this.name, {
+    const prefixSingular = camelCase(this.alias, {
         prefixCharacters: syntheticNamePrefix,
     });
-    const thisNameParts = trainCase(this.name, {
+    const thisNameParts = trainCase(this.alias, {
         prefixCharacters: syntheticNamePrefix,
     }).split("-");
     let prefixPlural = camelCase(`${thisNameParts.slice(0, thisNameParts.length - 1).join("")}${plur(thisNameParts[thisNameParts.length - 1])}`, { prefixCharacters: syntheticNamePrefix });
@@ -20,4 +20,4 @@ export function NamedObjectType_objectSetMethodNames() {
         objects: prefixPlural,
     };
 }
-//# sourceMappingURL=NamedObjectType_objectSetMethodNames.js.map
+//# sourceMappingURL=ObjectType_objectSetMethodNames.js.map

package/dist/generators/ts/_ObjectType/ObjectType_schemaVariableStatement.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_schemaVariableStatement(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_schemaVariableStatement.d.ts.map

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

@@ -0,0 +1,14 @@
+import { Maybe } from "purify-ts";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_schemaVariableStatement() {
+    if (!this.configuration.features.has("Object.schema")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export const schema = { properties: { ${joinCode(this.parentObjectTypes
+        .map((parentObjectType) => code `...${parentObjectType.alias.unsafeCoerce()}.schema.properties`)
+        .concat(this.properties.flatMap((property) => property.schema
+        .toList()
+        .map((propertySchema) => code `${property.name}: ${propertySchema}`))), { on: ", " })} } } as const;`);
+}
+//# sourceMappingURL=ObjectType_schemaVariableStatement.js.map

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

@@ -2,10 +2,10 @@ import { Maybe } from "purify-ts";
 import type { Reusables } from "../Reusables.js";
 import type { TsGenerator } from "../TsGenerator.js";
 import { type Code } from "../ts-poet-wrapper.js";
-export declare function NamedObjectType_sparqlConstructQueryFunctionDeclaration(this: {
+export declare function ObjectType_sparqlConstructQueryFunctionDeclaration(this: {
+    readonly alias: string;
     readonly configuration: TsGenerator.Configuration;
     readonly filterType: Code;
-    readonly name: string;
     readonly reusables: Reusables;
 }): Maybe<Code>;
-//# sourceMappingURL=NamedObjectType_sparqlConstructQueryFunctionDeclaration.d.ts.map
+//# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.d.ts.map

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

@@ -1,20 +1,20 @@
 import { camelCase } from "change-case";
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
-export function NamedObjectType_sparqlConstructQueryFunctionDeclaration() {
+export function ObjectType_sparqlConstructQueryFunctionDeclaration() {
     if (!this.configuration.features.has("Object.SPARQL")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
 export function sparqlConstructQuery({ filter, ignoreRdfType, preferredLanguages, prefixes, subject, ...queryParameters }: { filter?: ${this.filterType}; ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; preferredLanguages?: readonly string[]; subject: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable} } & Omit<${this.reusables.imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type">): ${this.reusables.imports.sparqljs}.ConstructQuery {
-  const variablePrefix = subject.termType === "Variable" ? subject.value : "${camelCase(this.name)}";
+  const variablePrefix = subject.termType === "Variable" ? subject.value : "${camelCase(this.alias)}";
 
   return {
     ...queryParameters,
     prefixes: prefixes ?? {},
     queryType: "CONSTRUCT",
     template: (queryParameters.template ?? []).concat(
-      ${this.name}.focusSparqlConstructTriples({
+      ${this.alias}.focusSparqlConstructTriples({
         filter,
         focusIdentifier: subject,
         ignoreRdfType: !!ignoreRdfType,
@@ -24,7 +24,7 @@ export function sparqlConstructQuery({ filter, ignoreRdfType, preferredLanguages
     type: "query",
     where: (queryParameters.where ?? []).concat(
       ${this.reusables.snippets.normalizeSparqlWherePatterns}(
-        ${this.name}.focusSparqlWherePatterns({
+        ${this.alias}.focusSparqlWherePatterns({
           filter,
           focusIdentifier: subject,
           ignoreRdfType: !!ignoreRdfType,
@@ -36,4 +36,4 @@ export function sparqlConstructQuery({ filter, ignoreRdfType, preferredLanguages
   };
 }`);
 }
-//# sourceMappingURL=NamedObjectType_sparqlConstructQueryFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.js.map

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

@@ -2,10 +2,10 @@ import { Maybe } from "purify-ts";
 import type { Reusables } from "../Reusables.js";
 import type { TsGenerator } from "../TsGenerator.js";
 import { type Code } from "../ts-poet-wrapper.js";
-export declare function NamedObjectType_sparqlConstructQueryStringFunctionDeclaration(this: {
+export declare function ObjectType_sparqlConstructQueryStringFunctionDeclaration(this: {
+    readonly alias: string;
     readonly configuration: TsGenerator.Configuration;
     readonly filterType: Code;
-    readonly name: string;
     readonly reusables: Reusables;
 }): Maybe<Code>;
-//# sourceMappingURL=NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts.map
+//# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts.map

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

@@ -0,0 +1,12 @@
+import { Maybe } from "purify-ts";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_sparqlConstructQueryStringFunctionDeclaration() {
+    if (!this.configuration.features.has("Object.SPARQL")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function sparqlConstructQueryString(parameters: Parameters<typeof ${this.alias}.sparqlConstructQuery>[0] & ${this.reusables.imports.sparqljs}.GeneratorOptions): string {
+  return new ${this.reusables.imports.sparqljs}.Generator(parameters).stringify(${this.alias}.sparqlConstructQuery(parameters));
+}`);
+}
+//# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_toJsonFunctionDeclaration.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_toJsonFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_toJsonFunctionDeclaration.d.ts.map

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

@@ -1,12 +1,12 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_toJsonFunctionDeclaration() {
+export function ObjectType_toJsonFunctionDeclaration() {
     if (!this.configuration.features.has("Object.toJson")) {
         return Maybe.empty();
     }
     const jsonObjectMembers = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        jsonObjectMembers.push(code `...${parentObjectType.name}.toJson(${this.thisVariable})`);
+        jsonObjectMembers.push(code `...${parentObjectType.alias.unsafeCoerce()}.toJson(${this.thisVariable})`);
     }
     if (this.properties.length > 0) {
         jsonObjectMembers.push(...this.properties.flatMap((property) => property
@@ -34,8 +34,8 @@ export function NamedObjectType_toJsonFunctionDeclaration() {
     //     break;
     // }
     return Maybe.of(code `\
-export function toJson(${this.thisVariable}: ${this.name}): ${returnType} {
+export function toJson(${this.thisVariable}: ${this.expression}): ${returnType} {
   return JSON.parse(JSON.stringify({ ${joinCode(jsonObjectMembers, { on: "," })} } satisfies ${this.jsonType().name}));
 }`);
 }
-//# sourceMappingURL=NamedObjectType_toJsonFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_toJsonFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_toRdfResourceFunctionDeclaration.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_toRdfResourceFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_toRdfResourceFunctionDeclaration.d.ts.map

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

@@ -1,11 +1,11 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_toRdfResourceFunctionDeclaration() {
+export function ObjectType_toRdfResourceFunctionDeclaration() {
     if (!this.configuration.features.has("Object.toRdf")) {
         return Maybe.empty();
     }
-    const statements = this.parentObjectTypes.map((parentObjectType) => code `${parentObjectType.name}._toRdfResource({ ...parameters, ignoreRdfType: true });`);
+    const statements = this.parentObjectTypes.map((parentObjectType) => code `${parentObjectType.alias.unsafeCoerce()}._toRdfResource({ ...parameters, ignoreRdfType: true });`);
     if (this.toRdfTypes.length > 0) {
         statements.push(code `if (!${variables.ignoreRdfType}) { ${joinCode(this.toRdfTypes.map((toRdfType) => code `${variables.resource}.add(${this.rdfjsTermExpression(rdf.type)}, ${this.reusables.imports.dataFactory}.namedNode("${toRdfType.value}"), ${variables.graph});`), { on: " " })} }`);
     }
@@ -23,7 +23,7 @@ export function NamedObjectType_toRdfResourceFunctionDeclaration() {
     }
     statements.push(code `return ${variables.resource};`);
     return Maybe.of(code `\
-export const _toRdfResource: ${this.reusables.snippets._ToRdfResourceFunction}<${this.identifierTypeAlias}, ${this.name}> = (parameters) => {
+export const _toRdfResource: ${this.reusables.snippets._ToRdfResourceFunction}<${this.identifierTypeAlias}, ${this.expression}> = (parameters) => {
 ${joinCode(statements)}
 }
 
@@ -36,4 +36,4 @@ const variables = {
     resource: code `parameters.resource`,
     resourceSet: code `parameters.resourceSet`,
 };
-//# sourceMappingURL=NamedObjectType_toRdfResourceFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_toRdfResourceFunctionDeclaration.js.map

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

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

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

@@ -1,12 +1,12 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_toStringFunctionDeclarations() {
+export function ObjectType_toStringFunctionDeclarations() {
     if (!this.configuration.features.has("Object.toString")) {
         return [];
     }
     let propertiesToStringInitializers = [];
     if (this.parentObjectTypes.length > 0) {
         for (const parentObjectType of this.parentObjectTypes) {
-            propertiesToStringInitializers.push(code `...${parentObjectType.name}._propertiesToStrings(${this.thisVariable})`);
+            propertiesToStringInitializers.push(code `...${parentObjectType.alias.unsafeCoerce()}._propertiesToStrings(${this.thisVariable})`);
         }
     }
     propertiesToStringInitializers = propertiesToStringInitializers.concat(this.properties.flatMap((property) => property
@@ -19,18 +19,18 @@ export function NamedObjectType_toStringFunctionDeclarations() {
     })
         .toList()));
     const propertiesToStringsReturnExpression = code `${this.reusables.snippets.compactRecord}({${joinCode(propertiesToStringInitializers, { on: "," })}})`;
-    const toStringReturnExpression = (propertiesToStrings) => code `\`${this.name}(\${JSON.stringify(${propertiesToStrings})})\``;
+    const toStringReturnExpression = (propertiesToStrings) => code `\`${this.alias.unsafeCoerce()}(\${JSON.stringify(${propertiesToStrings})})\``;
     const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
     return [
         // Use overloads to allow the function to be attached to an instance or used freestanding
         code `\
-export function _propertiesToStrings(${this.thisVariable}: ${this.name}): Record<string, string> {
+export function _propertiesToStrings(${this.thisVariable}: ${this.expression}): Record<string, string> {
   return ${propertiesToStringsReturnExpression};
 }`,
         code `\
-export function ${syntheticNamePrefix}toString(${this.thisVariable}: ${this.name}): string {
+export function ${syntheticNamePrefix}toString(${this.thisVariable}: ${this.expression}): string {
   return ${toStringReturnExpression(code `_propertiesToStrings(${this.thisVariable})`)};
 }`,
     ];
 }
-//# sourceMappingURL=NamedObjectType_toStringFunctionDeclarations.js.map
+//# sourceMappingURL=ObjectType_toStringFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectType/ObjectType_valueSparqlConstructTriplesFunctionDeclaration.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_valueSparqlConstructTriplesFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_valueSparqlConstructTriplesFunctionDeclaration.d.ts.map

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

@@ -1,11 +1,11 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
-export function NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration() {
+export function ObjectType_valueSparqlConstructTriplesFunctionDeclaration() {
     if (!this.configuration.features.has("Object.SPARQL")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
 export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, valueVariable, variablePrefix }) =>
-  ${this.name}.focusSparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix });`);
+  ${this.alias.unsafeCoerce()}.focusSparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix });`);
 }
-//# sourceMappingURL=NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_valueSparqlConstructTriplesFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_valueSparqlWherePatternsFunctionDeclaration.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_valueSparqlWherePatternsFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_valueSparqlWherePatternsFunctionDeclaration.d.ts.map

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

@@ -1,13 +1,13 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
-export function NamedObjectType_valueSparqlWherePatternsFunctionDeclaration() {
+export function ObjectType_valueSparqlWherePatternsFunctionDeclaration() {
     if (!this.configuration.features.has("Object.SPARQL")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
 export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, preferredLanguages, propertyPatterns, valueVariable, variablePrefix }) =>
   (propertyPatterns as readonly ${this.reusables.snippets.SparqlPattern}[]).concat(
-    ${this.name}.focusSparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
+    ${this.alias.unsafeCoerce()}.focusSparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
   );`);
 }
-//# sourceMappingURL=NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_valueSparqlWherePatternsFunctionDeclaration.js.map

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

@@ -31,7 +31,7 @@ export class ShaclProperty extends AbstractProperty {
     get constructorParameter() {
         const conversionFunction = this.type.conversionFunction.extract();
         if (!conversionFunction) {
-            return Maybe.of(code `readonly ${this.name}: ${this.type.name};`);
+            return Maybe.of(code `readonly ${this.name}: ${this.type.expression};`);
         }
         let hasQuestionToken = false;
         const typeNames = [];
@@ -40,7 +40,7 @@ export class ShaclProperty extends AbstractProperty {
                 hasQuestionToken = true;
             }
             else {
-                typeNames.push(code `${type.name}`);
+                typeNames.push(code `${type.expression}`);
             }
         }
         return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeNames, { on: "|" })};`);
@@ -55,7 +55,7 @@ export class ShaclProperty extends AbstractProperty {
             .alt(this.description)
             .alt(this.label)
             .map(tsComment)
-            .orDefault("")}${joinCode(lhs, { on: " " })}: ${this.type.name};`;
+            .orDefault("")}${joinCode(lhs, { on: " " })}: ${this.type.expression};`;
     }
     get filterProperty() {
         return Maybe.of({
@@ -118,13 +118,13 @@ export class ShaclProperty extends AbstractProperty {
         const validationFunction = this.type.validationFunction.extract();
         let rhs;
         if (conversionFunction && validationFunction) {
-            rhs = code `${conversionFunction}(${parameterVariable}).chain(value => ${validationFunction}(${this.namedObjectType.name}.schema.properties.${this.name}.type, value))`;
+            rhs = code `${conversionFunction}(${parameterVariable}).chain(value => ${validationFunction}(${this.objectType.alias.unsafeCoerce()}.schema.properties.${this.name}.type, value))`;
         }
         else if (conversionFunction) {
             rhs = code `${conversionFunction}(${parameterVariable})`;
         }
         else if (validationFunction) {
-            rhs = code `${validationFunction}(${this.namedObjectType.name}.schema.properties.${this.name}.type, ${parameterVariable})`;
+            rhs = code `${validationFunction}(${this.objectType.alias.unsafeCoerce()}.schema.properties.${this.name}.type, ${parameterVariable})`;
         }
         else {
             rhs = code `${this.reusables.imports.Either}.of(${parameterVariable})`;
@@ -148,7 +148,7 @@ export class ShaclProperty extends AbstractProperty {
                 variables: {
                     ...variables,
                     ignoreRdfType: true,
-                    propertyPath: code `${this.namedObjectType.name}.schema.properties.${this.name}.path`,
+                    propertyPath: code `${this.objectType.alias.unsafeCoerce()}.schema.properties.${this.name}.path`,
                     resourceValues: code `resourceValues`,
                 },
             })})`,
@@ -209,7 +209,7 @@ export class ShaclProperty extends AbstractProperty {
             default:
                 return [];
         }
-        const propertyPath = code `${this.namedObjectType.name}.schema.properties.${this.name}.path`;
+        const propertyPath = code `${this.objectType.alias.unsafeCoerce()}.schema.properties.${this.name}.path`;
         return [
             code `${variables.resource}.add(${propertyPath}, ${this.type.toRdfResourceValuesExpression({
                 variables: { ...variables, propertyPath },

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

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

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

@@ -1,9 +1,11 @@
+import { codeEquals } from "../codeEquals.js";
 import { code } from "../ts-poet-wrapper.js";
 export function identifierTypeDeclarations() {
     if (!this.configuration.features.has("Object.type")) {
         return [];
     }
-    const ancestorObjectTypeWithSameIdentifierType = this.ancestorObjectTypes.find((ancestorObjectType) => ancestorObjectType.identifierType.name === this.identifierType.name);
+    const ancestorObjectTypeWithSameIdentifierType = this.ancestorObjectTypes.find((ancestorObjectType) => ancestorObjectType.identifierType.kind === this.identifierType.kind &&
+        codeEquals(ancestorObjectType.identifierType.expression, this.identifierType.expression));
     if (ancestorObjectTypeWithSameIdentifierType) {
         // This object type's identifier type has the same identifier type as an ancestor object type,
         // so just reuse the latter.
@@ -14,7 +16,7 @@ export function identifierTypeDeclarations() {
     }
     // Bespoke identifier type and associated functions
     return [
-        code `export type Identifier = ${this.identifierType.name};`,
+        code `export type Identifier = ${this.identifierType.expression};`,
         code `\
 export namespace Identifier {
   export const parse = ${this.identifierType.parseFunction};

package/dist/input/generated.d.ts

@@ -1297,7 +1297,7 @@ export declare namespace Shape {
     }
     function isShape(object: $Object): object is Shape;
     const schema: {
-        readonly kind: "NamedObjectUnion";
+        readonly kind: "ObjectUnion";
         readonly members: {
             readonly NodeShape: {
                 readonly discriminantValues: readonly ["NodeShape"];
@@ -2406,7 +2406,7 @@ export declare namespace $Object {
         const stringify: typeof NTriplesTerm.stringify;
     }
     const schema: {
-        readonly kind: "NamedObjectUnion";
+        readonly kind: "ObjectUnion";
         readonly members: {
             readonly NodeShape: {
                 readonly discriminantValues: readonly ["NodeShape"];

package/dist/input/generated.js

@@ -2995,7 +2995,7 @@ export var Shape;
     }
     Shape.isShape = isShape;
     Shape.schema = {
-        kind: "NamedObjectUnion",
+        kind: "ObjectUnion",
         members: {
             NodeShape: { discriminantValues: ["NodeShape"], type: NodeShape.schema },
             PropertyShape: {
@@ -3336,7 +3336,7 @@ export var $Object;
         Identifier.stringify = NTriplesTerm.stringify;
     })(Identifier = $Object.Identifier || ($Object.Identifier = {}));
     $Object.schema = {
-        kind: "NamedObjectUnion",
+        kind: "ObjectUnion",
         members: {
             NodeShape: { discriminantValues: ["NodeShape"], type: NodeShape.schema },
             Ontology: { discriminantValues: ["Ontology"], type: Ontology.schema },

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.39",
+    "@shaclmate/shacl-ast": "4.0.40",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
     "@rdfjs/term-map": "~2.0.2",
@@ -41,8 +41,8 @@
     "dist/generators/*.js",
     "dist/generators/ts/*.d.ts",
     "dist/generators/ts/*.js",
-    "dist/generators/ts/_NamedObjectType/*.d.ts",
-    "dist/generators/ts/_NamedObjectType/*.js",
+    "dist/generators/ts/_ObjectType/*.d.ts",
+    "dist/generators/ts/_ObjectType/*.js",
     "dist/generators/ts/_snippets/*.d.ts",
     "dist/generators/ts/_snippets/*.js",
     "dist/input/*.d.ts",
@@ -68,5 +68,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.39"
+  "version": "4.0.40"
 }

package/dist/generators/ts/AbstractNamedUnionType.d.ts

@@ -1,30 +0,0 @@
-import { Maybe } from "purify-ts";
-import { AbstractType } from "./AbstractType.js";
-import { AbstractUnionType } from "./AbstractUnionType.js";
-import type { Type } from "./Type.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare abstract class AbstractNamedUnionType<MemberTypeT extends Type> extends AbstractUnionType<MemberTypeT> {
-    protected readonly _name: string;
-    constructor({ name, ...superParameters }: {
-        name: string;
-    } & ConstructorParameters<typeof AbstractUnionType<MemberTypeT>>[0]);
-    get declaration(): Maybe<Code>;
-    get equalsFunction(): Code;
-    get filterFunction(): Code;
-    get filterType(): Code;
-    get hashFunction(): Code;
-    get jsonSchemaFunctionDeclaration(): Code;
-    get jsonTypeAliasDeclaration(): Code;
-    get name(): string;
-    get valueSparqlConstructTriplesFunction(): Code;
-    get valueSparqlWherePatternsFunction(): Code;
-    protected get staticModuleDeclarations(): Record<string, Code>;
-    fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
-    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
-    jsonSchema({ context, }: Parameters<AbstractType["jsonSchema"]>[0]): Code;
-    jsonType(): AbstractType.JsonType;
-    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
-    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
-    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
-}
-//# sourceMappingURL=AbstractNamedUnionType.d.ts.map