@shaclmate/compiler 4.0.39 → 4.0.41

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();
     }
@@ -15,30 +15,11 @@ export function NamedObjectType_focusSparqlWherePatternsFunctionDeclaration() {
     const rdfTypeVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
     let patternsVariableDeclarationKeyword = "const";
     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 }}));`);
-        patternsVariableDeclarationKeyword = "let";
-    }
-    if (this.fromRdfType.isJust()) {
-        const fromRdfTypeVariables = this.fromRdfTypeVariable
-            .toList()
-            .concat(this.descendantFromRdfTypeVariables);
+    this.fromRdfTypeVariable.ifJust((fromRdfTypeVariable) => {
         statements.push(code `const rdfTypeVariable = ${rdfTypeVariable};`, code `\
 if (!parameters?.ignoreRdfType) {
   patterns.push(
-    ${fromRdfTypeVariables.length > 1
-            ? code `\
-    {
-      type: "values" as const,
-      values: [${joinCode(fromRdfTypeVariables, { on: "," })}].map((identifier) => {
-        const valuePatternRow: ${this.reusables.imports.sparqljs}.ValuePatternRow = {};
-        valuePatternRow[\`?\${${variables.variablePrefix}}FromRdfType\`] = identifier as ${this.reusables.imports.NamedNode};
-        return valuePatternRow;
-      }),
-    },
-    ${this.reusables.snippets.sparqlInstancesOfPattern}({ rdfType: ${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}FromRdfType\`), subject: ${variables.focusIdentifier} }),`
-            : code `${this.reusables.snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariables[0]}, subject: ${variables.focusIdentifier} }),`}
+    ${code `${this.reusables.snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariable}, subject: ${variables.focusIdentifier} }),`}
     {
       triples: [
         {
@@ -70,7 +51,7 @@ if (!parameters?.ignoreRdfType) {
     }
   );
 }`);
-    }
+    });
     for (const property of this.properties) {
         if (property.recursive) {
             continue;
@@ -99,4 +80,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/_ObjectType/ObjectType_fromJsonFunctionDeclaration.js

@@ -0,0 +1,18 @@
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_fromJsonFunctionDeclaration() {
+    if (!this.configuration.features.has("Object.fromJson")) {
+        return Maybe.empty();
+    }
+    const variables = {
+        jsonObject: code `${this.configuration.syntheticNamePrefix}json`,
+    };
+    const propertyInitializers = this.properties.flatMap((property) => property.fromJsonInitializer({ variables }).toList());
+    invariant(propertyInitializers.length > 0);
+    return Maybe.of(code `\
+export function fromJson(${variables.jsonObject}: ${this.jsonType().expression}): ${this.reusables.imports.Either}<Error, ${this.expression}> {
+  return ${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} }).chain(create);
+}`);
+}
+//# 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/_ObjectType/ObjectType_fromRdfResourceFunctionDeclaration.js

@@ -0,0 +1,51 @@
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { arrayOf, code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_fromRdfResourceFunctionDeclaration() {
+    if (!this.configuration.features.has("Object.fromRdf")) {
+        return Maybe.empty();
+    }
+    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+    const optionsVariable = `_${syntheticNamePrefix}options`;
+    const variables = {
+        context: code `${optionsVariable}.context`,
+        graph: code `${optionsVariable}.graph`,
+        ignoreRdfType: code `${optionsVariable}.ignoreRdfType`,
+        objectSet: code `${optionsVariable}.objectSet`,
+        preferredLanguages: code `${optionsVariable}.preferredLanguages`,
+        resource: code `${syntheticNamePrefix}resource`,
+    };
+    const propertyFromRdfResourceValuesExpressionVariable = {
+        context: variables.context,
+        graph: variables.graph,
+        objectSet: variables.objectSet,
+        preferredLanguages: variables.preferredLanguages,
+        resource: variables.resource,
+    };
+    const chains = [];
+    this.fromRdfTypeVariable.ifJust((fromRdfTypeVariable) => {
+        chains.push({
+            expression: code `!${variables.ignoreRdfType} ? ${this.reusables.snippets.ensureRdfResourceType}(${variables.resource}, ${arrayOf(fromRdfTypeVariable)}, ${{ graph: variables.graph }}) : ${this.reusables.imports.Right}(true as const)`,
+            variable: `_rdfTypeCheck`,
+        });
+    });
+    const propertyFromRdfResourceValuesInitializers = this.properties.flatMap((property) => property
+        .fromRdfResourceValuesInitializer({
+        variables: propertyFromRdfResourceValuesExpressionVariable,
+    })
+        .toList());
+    invariant(Object.keys(propertyFromRdfResourceValuesInitializers).length > 0);
+    chains.push({
+        expression: code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyFromRdfResourceValuesInitializers, { on: ", " })} })`,
+        variable: "properties",
+    });
+    return Maybe.of(code `\
+export const _fromRdfResource: ${this.reusables.snippets._FromRdfResourceFunction}<${this.expression}> = (${variables.resource}, ${optionsVariable}) => {
+  return ${chains
+        .reverse()
+        .reduce((acc, { expression, variable }) => code `(${expression}).chain(${variable} => ${acc})`, code `(create(properties))`)};
+}
+
+export const fromRdfResource = ${this.reusables.snippets.wrap_FromRdfResourceFunction}(_fromRdfResource);`);
+}
+//# 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/_ObjectType/ObjectType_hashFunctionDeclarations.js

@@ -0,0 +1,41 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+const hasherVariable = code `hasher`;
+export function ObjectType_hashFunctionDeclarations() {
+    if (!this.configuration.features.has("Object.hash")) {
+        return [];
+    }
+    return [
+        code `\
+export function hash<HasherT extends ${this.reusables.snippets.Hasher}>(${hasherVariable}: HasherT, ${this.thisVariable}: ${this.expression}): HasherT {
+  ${joinCode([
+            code `${this.alias.unsafeCoerce()}.hashShaclProperties(${hasherVariable}, ${this.thisVariable});`,
+            ...this.properties
+                .filter((property) => property.kind !== "Shacl")
+                .flatMap((property) => property.hashStatements({
+                variables: {
+                    hasher: hasherVariable,
+                    value: code `${property.accessExpression({ variables: { object: this.thisVariable } })}`,
+                },
+            })),
+            code `return ${hasherVariable};`,
+        ])}
+}`,
+        code `\
+export function hashShaclProperties<HasherT extends ${this.reusables.snippets.Hasher}>(${hasherVariable}: HasherT, ${this.thisVariable}: ${this.expression}): HasherT {
+  ${joinCode([
+            ...this.properties.flatMap((property) => property.kind === "Shacl"
+                ? property.hashStatements({
+                    variables: {
+                        hasher: hasherVariable,
+                        value: property.accessExpression({
+                            variables: { object: this.thisVariable },
+                        }),
+                    },
+                })
+                : []),
+            code `return ${hasherVariable};`,
+        ])}
+}`,
+    ];
+}
+//# 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/_ObjectType/ObjectType_interfaceDeclaration.js

@@ -0,0 +1,12 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+import { tsComment } from "../tsComment.js";
+export function ObjectType_interfaceDeclaration() {
+    return code `\
+${this.comment
+        .alt(this.label)
+        .map(tsComment)
+        .orDefault("")}export interface ${this.alias.unsafeCoerce()} {
+  ${joinCode(this.properties.map((property) => property.declaration), { on: "\n\n" })}
+}`;
+}
+//# 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/_ObjectType/ObjectType_isTypeFunctionDeclaration.js

@@ -0,0 +1,20 @@
+import { Maybe } from "purify-ts";
+import { code, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectType_isTypeFunctionDeclaration() {
+    if (!this.configuration.features.has("Object.type")) {
+        return Maybe.empty();
+    }
+    if (this.synthetic) {
+        return Maybe.empty();
+    }
+    const alias = this.alias.extract();
+    const discriminantProperty = this.discriminantProperty.extract();
+    if (!alias || !discriminantProperty) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function is${alias}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${alias} {
+  return object.${discriminantProperty.name} === ${literalOf(discriminantProperty.value)};
+}`);
+}
+//# 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,18 +1,12 @@
 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();
     }
-    let properties = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        properties.push(code `...${parentObjectType.jsonSchema({ context: "type" })}.shape`);
-    }
-    if (this.properties.length > 0) {
-        properties = properties.concat(this.properties
-            .flatMap((property) => property.jsonSchema.toList())
-            .map(({ key, schema }) => code `"${key}": ${schema}`));
-    }
+    const properties = this.properties
+        .flatMap((property) => property.jsonSchema.toList())
+        .map(({ key, schema }) => code `"${key}": ${schema}`);
     const meta = {
     // id: this.name,
     };
@@ -28,4 +22,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/_ObjectType/ObjectType_jsonTypeAliasDeclaration.js

@@ -0,0 +1,9 @@
+import { Maybe } from "purify-ts";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_jsonTypeAliasDeclaration() {
+    if (!this.configuration.features.has("Object.JSON.type")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `export type Json = { ${joinCode(this.properties.flatMap((property) => property.jsonSignature.toList()), { on: ";" })} }`);
+}
+//# 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,15 @@
 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 })`)
-        .concat(this.properties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
+    const elements = 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,12 @@
+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.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/_ObjectType/ObjectType_toJsonFunctionDeclaration.js

@@ -0,0 +1,20 @@
+import { Maybe } from "purify-ts";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_toJsonFunctionDeclaration() {
+    if (!this.configuration.features.has("Object.toJson")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function toJson(${this.thisVariable}: ${this.expression}): ${this.jsonType().expression} {
+  return JSON.parse(JSON.stringify({ ${joinCode(this.properties.flatMap((property) => property
+        .toJsonInitializer({
+        variables: {
+            value: property.accessExpression({
+                variables: { object: this.thisVariable },
+            }),
+        },
+    })
+        .toList()), { on: "," })} } satisfies ${this.jsonType().expression}));
+}`);
+}
+//# 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