@shaclmate/compiler 4.0.38 → 4.0.40

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

@@ -1,7 +1,6 @@
-import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
+import { arrayOf, code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_fromRdfResourceFunctionDeclaration() {
     if (!this.configuration.features.has("Object.fromRdf")) {
         return Maybe.empty();
     }
@@ -26,37 +25,14 @@ 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}`);
     });
-    this.fromRdfType.ifJust((fromRdfType) => {
-        const fromRdfTypeVariable = this.fromRdfTypeVariable.unsafeCoerce();
-        const predicate = this.rdfjsTermExpression(rdf.type);
-        // Check the expected type and its known subtypes
-        const cases = new Set();
-        cases.add(fromRdfType.value);
-        for (const descendantFromRdfType of this.descendantFromRdfTypes) {
-            cases.add(descendantFromRdfType.value);
-        }
+    this.fromRdfTypeVariable.ifJust((fromRdfTypeVariable) => {
         chains.push({
-            expression: code `!${variables.ignoreRdfType} ? ${variables.resource}.value(${predicate}, ${{ graph: variables.graph }})
-    .chain(actualRdfType => actualRdfType.toIri())
-    .chain((actualRdfType) => {
-      // Check the expected type and its known subtypes
-      switch (actualRdfType.value) {
-        ${[...cases].map((fromRdfType) => `case "${fromRdfType}":`).join("\n")}
-          return ${this.reusables.imports.Right}(true as const);
-      }
-
-      // Check arbitrary rdfs:subClassOf's of the expected type
-      if (${variables.resource}.isInstanceOf(${fromRdfTypeVariable}, ${{ graph: variables.graph }})) {
-        return ${this.reusables.imports.Right}(true as const);
-      }
-
-      return ${this.reusables.imports.Left}(new Error(\`\${${variables.resource}.identifier} has unexpected RDF type (actual: \${actualRdfType.value}, expected: ${fromRdfType.value})\`));
-    }) : ${this.reusables.imports.Right}(true as const)`,
+            expression: code `!${variables.ignoreRdfType} ? ${this.reusables.snippets.ensureRdfResourceType}(${variables.resource}, ${arrayOf(fromRdfTypeVariable, ...this.descendantFromRdfTypeVariables)}, ${{ graph: variables.graph }}) : ${this.reusables.imports.Right}(true as const)`,
             variable: `_rdfTypeCheck`,
         });
     });
@@ -95,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,10 +1,10 @@
 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 [];
     }
-    const hashOwnShaclPropertiesStatements = this.properties.flatMap((property) => property.kind === "ShaclProperty"
+    const hashOwnShaclPropertiesStatements = this.properties.flatMap((property) => property.kind === "Shacl"
         ? property.hashStatements({
             variables: {
                 hasher: hasherVariable,
@@ -17,13 +17,13 @@ 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
-        .filter((property) => property.kind !== "ShaclProperty")
+        .filter((property) => property.kind !== "Shacl")
         .flatMap((property) => property.hashStatements({
         variables: {
             hasher: hasherVariable,
@@ -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))}
+  ${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

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