@shaclmate/compiler 4.0.94 → 4.0.96

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType__toRdfResourceFunction.d.ts

@@ -0,0 +1,4 @@
+import type { Callable } from "../Callable.js";
+import type { ObjectIntersectionType } from "../ObjectIntersectionType.js";
+export declare function ObjectIntersectionType__toRdfResourceFunction(this: ObjectIntersectionType): Callable;
+//# sourceMappingURL=ObjectIntersectionType__toRdfResourceFunction.d.ts.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType__toRdfResourceFunction.js

@@ -0,0 +1,18 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+function ObjectIntersectionType__toRdfResourceFunctionExpression() {
+    return code `\
+(parameters) => {
+  ${joinCode(this.members.map((member) => code `${member.type._toRdfResourceFunction.unannotatedUsage}(parameters);`))}
+}`;
+}
+export function ObjectIntersectionType__toRdfResourceFunction() {
+    const identifierTypeExpression = this.name
+        .map(() => this.identifierTypeAlias)
+        .orDefault(this.identifierType.expression);
+    return this._function({
+        type: code `${this.reusables.snippets._ToRdfResourceFunction}<${identifierTypeExpression}, ${this.expression}>`,
+        unannotatedExpression: () => ObjectIntersectionType__toRdfResourceFunctionExpression.call(this),
+        unqualifiedName: "_toRdfResource",
+    });
+}
+//# sourceMappingURL=ObjectIntersectionType__toRdfResourceFunction.js.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_createFunction.d.ts

@@ -0,0 +1,4 @@
+import type { Callable } from "../Callable.js";
+import type { ObjectIntersectionType } from "../ObjectIntersectionType.js";
+export declare function ObjectIntersectionType_createFunction(this: ObjectIntersectionType): Callable;
+//# sourceMappingURL=ObjectIntersectionType_createFunction.d.ts.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_createFunction.js

@@ -0,0 +1,30 @@
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+function ObjectIntersectionType_createFunctionExpression() {
+    const parametersVariable = this.createFunctionParameters.variable;
+    let returnExpression = code `\
+    ${joinCode(this.members.map((member, memberI) => code `(${member.type.createFunction.unannotatedUsage})(${parametersVariable}).${memberI + 1 < this.members.length ? "chain" : "map"}(member${memberI} =>`))} ({ ${joinCode(this.members
+        .map((_, memberI) => code `...member${memberI}`)
+        .concat(this.discriminatedType
+        .map(({ discriminantProperty }) => code `${discriminantProperty.name}: ${literalOf(discriminantProperty.values[0])} as const`)
+        .toList()), { on: "," })} }) ${")".repeat(this.members.length)}`;
+    const monkeyPatchMethods = {};
+    if (this.configuration.features.has("Object.toJson")) {
+        monkeyPatchMethods["toJson"] = this.toJsonObjectFunction.annotatedUsage;
+    }
+    if (this.configuration.features.has("Object.toString")) {
+        monkeyPatchMethods[`${this.configuration.syntheticNamePrefix}toString`] =
+            this.toStringFunction.annotatedUsage;
+    }
+    if (Object.keys(monkeyPatchMethods).length > 0) {
+        returnExpression = code `${returnExpression}.map(object => ${this.reusables.snippets.monkeyPatchObject}(object, ${monkeyPatchMethods}))`;
+    }
+    return code `(${parametersVariable}) => ${returnExpression}`;
+}
+export function ObjectIntersectionType_createFunction() {
+    return this._function({
+        type: code `<${this.configuration.syntheticNamePrefix}DefaultNamespaceT extends ${this.reusables.snippets.NamespaceBuilder} = ${this.reusables.snippets.NamespaceBuilder}>(${this.createFunctionParameters.signature}) => ${this.reusables.imports.Either}<Error, ${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}>`,
+        unannotatedExpression: () => ObjectIntersectionType_createFunctionExpression.call(this),
+        unqualifiedName: "create",
+    });
+}
+//# sourceMappingURL=ObjectIntersectionType_createFunction.js.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_createFunctionParameters.d.ts

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

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_createFunctionParameters.js

@@ -0,0 +1,25 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectIntersectionType_createFunctionParameters() {
+    let hasQuestionToken = true;
+    const memberTypeExpressions = [];
+    for (const member of this.members) {
+        if (!member.type.createFunctionParameters.hasQuestionToken) {
+            hasQuestionToken = false;
+        }
+        memberTypeExpressions.push(member.type.createFunctionParameters.type.expression);
+    }
+    const typeInlineExpression = joinCode(memberTypeExpressions, { on: " & " });
+    const type = {
+        expression: this.name
+            .map((name) => code `${name}.CreateParameters<${this.configuration.syntheticNamePrefix}DefaultNamespaceT>`)
+            .orDefault(typeInlineExpression),
+        inlineExpression: typeInlineExpression,
+    };
+    return {
+        hasQuestionToken,
+        signature: code `parameters${hasQuestionToken ? "?" : ""}: ${type.expression}`,
+        type,
+        variable: code `parameters`,
+    };
+}
+//# sourceMappingURL=ObjectIntersectionType_createFunctionParameters.js.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_createUnsafeFunction.d.ts

@@ -0,0 +1,4 @@
+import type { Callable } from "../Callable.js";
+import type { ObjectIntersectionType } from "../ObjectIntersectionType.js";
+export declare function ObjectIntersectionType_createUnsafeFunction(this: ObjectIntersectionType): Callable;
+//# sourceMappingURL=ObjectIntersectionType_createUnsafeFunction.d.ts.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_createUnsafeFunction.js

@@ -0,0 +1,10 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectIntersectionType_createUnsafeFunction() {
+    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+    return this._function({
+        type: code `<${syntheticNamePrefix}DefaultNamespaceT extends ${this.reusables.snippets.NamespaceBuilder} = ${this.reusables.snippets.NamespaceBuilder}>(${this.createFunctionParameters.signature}) => ${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}`,
+        unannotatedExpression: () => code `(${this.createFunctionParameters.variable}) => create(${this.createFunctionParameters.variable}).unsafeCoerce()`,
+        unqualifiedName: "createUnsafe",
+    });
+}
+//# sourceMappingURL=ObjectIntersectionType_createUnsafeFunction.js.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_focusSparqlConstructTriplesFunction.d.ts

@@ -0,0 +1,4 @@
+import type { Callable } from "../Callable.js";
+import type { ObjectIntersectionType } from "../ObjectIntersectionType.js";
+export declare function ObjectIntersectionType_focusSparqlConstructTriplesFunction(this: ObjectIntersectionType): Callable;
+//# sourceMappingURL=ObjectIntersectionType_focusSparqlConstructTriplesFunction.d.ts.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_focusSparqlConstructTriplesFunction.js

@@ -0,0 +1,19 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+function ObjectIntersectionType_focusSparqlConstructTriplesFunctionExpression() {
+    return code `\
+(parameters) => {
+${joinCode([
+        code `let triples: ${this.reusables.imports.sparqljs}.Triple[] = [];`,
+        ...this.members.map((member) => code `triples = triples.concat((${member.type.focusSparqlConstructTriplesFunction.unannotatedUsage})(parameters));`),
+        code `return triples;`,
+    ])}
+}`;
+}
+export function ObjectIntersectionType_focusSparqlConstructTriplesFunction() {
+    return this._function({
+        type: code `${this.reusables.snippets.FocusSparqlConstructTriplesFunction}<${this.filterType}>`,
+        unannotatedExpression: () => ObjectIntersectionType_focusSparqlConstructTriplesFunctionExpression.call(this),
+        unqualifiedName: "focusSparqlConstructTriples",
+    });
+}
+//# sourceMappingURL=ObjectIntersectionType_focusSparqlConstructTriplesFunction.js.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_focusSparqlWherePatternsFunction.d.ts

@@ -0,0 +1,4 @@
+import type { Callable } from "../Callable.js";
+import type { ObjectIntersectionType } from "../ObjectIntersectionType.js";
+export declare function ObjectIntersectionType_focusSparqlWherePatternsFunction(this: ObjectIntersectionType): Callable;
+//# sourceMappingURL=ObjectIntersectionType_focusSparqlWherePatternsFunction.d.ts.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_focusSparqlWherePatternsFunction.js

@@ -0,0 +1,19 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+function ObjectIntersectionType_focusSparqlWherePatternsFunctionExpression() {
+    return code `\
+(parameters) => {
+${joinCode([
+        code `let patterns: ${this.reusables.snippets.SparqlPattern}[] = [];`,
+        ...this.members.map((member) => code `patterns = patterns.concat((${member.type.focusSparqlWherePatternsFunction.unannotatedUsage})(parameters));`),
+        code `return patterns;`,
+    ])}
+}`;
+}
+export function ObjectIntersectionType_focusSparqlWherePatternsFunction() {
+    return this._function({
+        type: code `${this.reusables.snippets.FocusSparqlWherePatternsFunction}<${this.filterType}>`,
+        unannotatedExpression: () => ObjectIntersectionType_focusSparqlWherePatternsFunctionExpression.call(this),
+        unqualifiedName: "focusSparqlWherePatterns",
+    });
+}
+//# sourceMappingURL=ObjectIntersectionType_focusSparqlWherePatternsFunction.js.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_fromJsonObjectFunction.d.ts

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

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_fromJsonObjectFunction.js

@@ -0,0 +1,15 @@
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectIntersectionType_fromJsonObjectFunctionExpression() {
+    return code `\
+(jsonObject) =>
+    ${joinCode(this.members.map((member, memberI) => code `
+${member.type.fromJsonObjectFunction.unannotatedUsage}(jsonObject).${memberI + 1 < this.members.length ? "chain" : "map"}(member${memberI} =>`))} ({ ${joinCode(this.members
+        .map((_, memberI) => code `...member${memberI}`)
+        .concat(this.discriminatedType
+        .map(({ discriminantProperty }) => code `${discriminantProperty.name}: ${literalOf(discriminantProperty.values[0])} as const`)
+        .toList()), { on: "," })} }) ${")".repeat(this.members.length)}`;
+}
+export function ObjectIntersectionType_fromJsonObjectFunctionType() {
+    return code `${this.reusables.snippets.FromJsonObjectFunction}<${this.jsonObjectType.expression}, ${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}, undefined>`;
+}
+//# sourceMappingURL=ObjectIntersectionType_fromJsonObjectFunction.js.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_fromRdfResourceFunction.d.ts

@@ -0,0 +1,4 @@
+import type { Callable } from "../Callable.js";
+import type { ObjectIntersectionType } from "../ObjectIntersectionType.js";
+export declare function ObjectIntersectionType_fromRdfResourceFunction(this: ObjectIntersectionType): Callable;
+//# sourceMappingURL=ObjectIntersectionType_fromRdfResourceFunction.d.ts.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_fromRdfResourceFunction.js

@@ -0,0 +1,9 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectIntersectionType_fromRdfResourceFunction() {
+    return this._function({
+        type: code `${this.reusables.snippets.FromRdfResourceFunction}<${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}>`,
+        unannotatedExpression: () => code `${this.reusables.snippets.wrap_FromRdfResourceFunction}(${this._fromRdfResourceFunction.annotatedUsage})`,
+        unqualifiedName: "fromRdfResource",
+    });
+}
+//# sourceMappingURL=ObjectIntersectionType_fromRdfResourceFunction.js.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_fromRdfResourceValuesFunction.d.ts

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

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_fromRdfResourceValuesFunction.js

@@ -0,0 +1,8 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectIntersectionType_fromRdfResourceValuesFunctionExpression() {
+    return code `(values, options) => values.chainMap(value => value.toResource().chain(resource => ${this.fromRdfResourceFunction.annotatedUsage}(resource, options)))`;
+}
+export function ObjectIntersectionType_fromRdfResourceValuesFunctionType() {
+    return code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}, ${this.schemaType}>`;
+}
+//# sourceMappingURL=ObjectIntersectionType_fromRdfResourceValuesFunction.js.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_toJsonObjectFunction.d.ts

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

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_toJsonObjectFunction.js

@@ -0,0 +1,7 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectIntersectionType_toJsonObjectFunctionExpression() {
+    return code `\
+(value) => ({
+${joinCode(this.members.map(({ type }) => code `...${type.toJsonObjectFunction.unannotatedUsage}(value)`), { on: "," })}})`;
+}
+//# sourceMappingURL=ObjectIntersectionType_toJsonObjectFunction.js.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_toRdfResourceFunction.d.ts

@@ -0,0 +1,4 @@
+import type { Callable } from "../Callable.js";
+import type { ObjectIntersectionType } from "../ObjectIntersectionType.js";
+export declare function ObjectIntersectionType_toRdfResourceFunction(this: ObjectIntersectionType): Callable;
+//# sourceMappingURL=ObjectIntersectionType_toRdfResourceFunction.d.ts.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_toRdfResourceFunction.js

@@ -0,0 +1,12 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectIntersectionType_toRdfResourceFunction() {
+    const identifierTypeExpression = this.name
+        .map(() => this.identifierTypeAlias)
+        .orDefault(this.identifierType.expression);
+    return this._function({
+        type: code `${this.reusables.snippets.ToRdfResourceFunction}<${identifierTypeExpression}, ${this.expression}>`,
+        unannotatedExpression: () => code `${this.reusables.snippets.wrap_ToRdfResourceFunction}<${identifierTypeExpression}, ${this.expression}>(${this._toRdfResourceFunction.annotatedUsage})`,
+        unqualifiedName: "toRdfResource",
+    });
+}
+//# sourceMappingURL=ObjectIntersectionType_toRdfResourceFunction.js.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_toRdfResourceValuesFunction.d.ts

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

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_toRdfResourceValuesFunction.js

@@ -0,0 +1,5 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectIntersectionType_toRdfResourceValuesFunctionExpression() {
+    return code `(value, options) => [${this.toRdfResourceFunction.unannotatedUsage}(value, { graph: options.graph, resourceSet: options.resourceSet }).identifier]`;
+}
+//# sourceMappingURL=ObjectIntersectionType_toRdfResourceValuesFunction.js.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_typeGuardFunction.d.ts

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

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType_typeGuardFunction.js

@@ -0,0 +1,18 @@
+import { Maybe } from "purify-ts";
+import { code, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectIntersectionType_typeGuardFunction() {
+    const discriminatedType = this.discriminatedType.extract();
+    if (!discriminatedType) {
+        return Maybe.empty();
+    }
+    const name = this.name.extract();
+    if (!name) {
+        return Maybe.empty();
+    }
+    return Maybe.of(this._function({
+        type: code `${this.reusables.snippets.ObjectTypeGuardFunction}<${discriminatedType.expression}>`,
+        unannotatedExpression: code `(object): object is ${discriminatedType.expression} => object.${discriminatedType.discriminantProperty.name} === ${literalOf(discriminatedType.discriminantProperty.values[0])}`,
+        unqualifiedName: `is${name}`,
+    }));
+}
+//# sourceMappingURL=ObjectIntersectionType_typeGuardFunction.js.map

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

@@ -1,12 +1,14 @@
 import type { Logger } from "@rdfx/logger";
 import type { Maybe } from "purify-ts";
+import type { AbstractType } from "../AbstractType.js";
 import type { Reusables } from "../Reusables.js";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import type { TsGenerator } from "../TsGenerator.js";
 import type { Type } from "../Type.js";
-import type { Code } from "../ts-poet-wrapper.js";
+import { type Code } from "../ts-poet-wrapper.js";
 export declare abstract class ObjectType_AbstractProperty {
     protected readonly configuration: TsGenerator.Configuration;
+    protected readonly jsonTypeFactory: AbstractType.JsonTypeFactory;
     protected readonly logger: Logger;
     protected readonly objectType: {
         readonly name: Maybe<string>;
@@ -15,7 +17,7 @@ export declare abstract class ObjectType_AbstractProperty {
     /**
      * Optional parameter to include in the parameters object of constructor function.
      */
-    abstract readonly constructorParameter: Maybe<{
+    abstract readonly createFunctionParameter: Maybe<{
         readonly hasQuestionToken: boolean;
         readonly signature: Code;
     }>;
@@ -49,16 +51,21 @@ export declare abstract class ObjectType_AbstractProperty {
      */
     abstract readonly hashFunctionParameter: Maybe<Code>;
     /**
-     * zod object key: schema.
+     * This property as a Member of a JsonObjectType.
      */
-    abstract readonly jsonSchema: Maybe<{
-        readonly key: string;
-        readonly schema: Code;
+    abstract readonly jsonObjectMember: Maybe<{
+        readonly description: Maybe<string>;
+        readonly label: Maybe<string>;
+        readonly name: string;
+        readonly optional: boolean;
+        readonly recursive: boolean;
+        readonly type: AbstractType.JsonType | (() => AbstractType.JsonType);
+        readonly uiSchemaElement: Maybe<(parameters: {
+            variables: {
+                scopePrefix: Code;
+            };
+        }) => Code>;
     }>;
-    /**
-     * Signature of the property when serialized to JSON.
-     */
-    abstract readonly jsonSignature: Maybe<Code>;
     /**
      * Property type discriminant e.g., "Shacl".
      */
@@ -83,8 +90,9 @@ export declare abstract class ObjectType_AbstractProperty {
      * TypeScript type describing .schema.
      */
     abstract readonly schemaType: Maybe<Code>;
-    constructor({ configuration, logger, name, objectType, reusables, }: {
+    constructor({ configuration, jsonTypeFactory, logger, name, objectType, reusables, }: {
         configuration: TsGenerator.Configuration;
+        jsonTypeFactory: AbstractType.JsonTypeFactory;
         logger: Logger;
         name: string;
         objectType: {
@@ -95,7 +103,7 @@ export declare abstract class ObjectType_AbstractProperty {
     /**
      * Initializer (name: value) from a constructor parameter.
      */
-    abstract constructorInitializer(parameters: {
+    abstract createInitializer(parameters: {
         variables: {
             parameters: Code;
         };
@@ -126,9 +134,11 @@ export declare abstract class ObjectType_AbstractProperty {
     /**
      * Initializer (name: value) from a JSON object.
      */
-    abstract fromJsonInitializer(parameters: {
+    abstract fromJsonObjectInitializer(parameters: {
         variables: {
+            context: Code;
             jsonObject: Code;
+            options: Code;
         };
     }): Maybe<Code>;
     /**
@@ -137,6 +147,8 @@ export declare abstract class ObjectType_AbstractProperty {
     abstract fromRdfResourceValuesInitializer(parameters: {
         variables: {
             focusResource: Code;
+            graph: Code;
+            ignoreRdfType: Code;
             options: Code;
         };
     }): Maybe<Code>;
@@ -149,14 +161,6 @@ export declare abstract class ObjectType_AbstractProperty {
             object: Code;
         };
     }): readonly Code[];
-    /**
-     * Element object (usually a control https://jsonforms.io/docs/uischema/controls) for a JSON Forms UI schema.
-     */
-    abstract jsonUiSchemaElement(parameters: {
-        variables: {
-            scopePrefix: Code;
-        };
-    }): Maybe<Code>;
     /**
      * SPARQL.js CONSTRUCT template triples for this property.
      *
@@ -209,7 +213,15 @@ export declare abstract class ObjectType_AbstractProperty {
     /**
      * Initializer (name: value) to JSON.
      */
-    abstract toJsonInitializer(parameters: {
+    abstract toJsonObjectInitializer(parameters: {
+        variables: {
+            object: Code;
+        };
+    }): Maybe<Code>;
+    /**
+     * Initializer (name: value) to serialize this property to a loggable value.
+     */
+    abstract toLoggableInitializer(parameters: {
         variables: {
             object: Code;
         };
@@ -217,8 +229,9 @@ export declare abstract class ObjectType_AbstractProperty {
     /**
      * Statements to serialize this property to an RDF resource.
      */
-    abstract toRdfRdfResourceValuesStatements(parameters: {
+    abstract toRdfResourceValuesStatements(parameters: {
         variables: Omit<Parameters<Type["toRdfResourceValuesExpression"]>[0]["variables"], "propertyPath" | "value"> & {
+            ignoreRdfType: Code;
             object: Code;
         };
     }): readonly Code[];
@@ -231,5 +244,6 @@ export declare abstract class ObjectType_AbstractProperty {
         };
     }): Maybe<Code>;
     protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;
+    protected get schemaVariable(): Code;
 }
 //# sourceMappingURL=ObjectType_AbstractProperty.d.ts.map

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

@@ -1,6 +1,15 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Memoize } from "typescript-memoize";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { code } from "../ts-poet-wrapper.js";
 export class ObjectType_AbstractProperty {
     configuration;
+    jsonTypeFactory;
     logger;
     objectType;
     reusables;
@@ -8,8 +17,9 @@ export class ObjectType_AbstractProperty {
      * TypeScript identifier-safe name of the property.
      */
     name;
-    constructor({ configuration, logger, name, objectType, reusables, }) {
+    constructor({ configuration, jsonTypeFactory, logger, name, objectType, reusables, }) {
         this.configuration = configuration;
+        this.jsonTypeFactory = jsonTypeFactory;
         this.logger = logger;
         this.name = name;
         this.objectType = objectType;
@@ -21,5 +31,13 @@ export class ObjectType_AbstractProperty {
         });
     }
     rdfjsTermExpression;
+    get schemaVariable() {
+        return this.objectType.name
+            .map((name) => code `${name}.schema.properties.${this.name}`)
+            .orDefaultLazy(() => this.schema.unsafeCoerce());
+    }
 }
+__decorate([
+    Memoize()
+], ObjectType_AbstractProperty.prototype, "schemaVariable", null);
 //# sourceMappingURL=ObjectType_AbstractProperty.js.map

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

@@ -2,36 +2,36 @@ import { Maybe } from "purify-ts";
 import { type Code } from "../ts-poet-wrapper.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
 export declare class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty {
-    readonly constructorParameter: ObjectType_AbstractProperty["constructorParameter"];
+    readonly createFunctionParameter: ObjectType_AbstractProperty["createFunctionParameter"];
+    /**
+     * The discriminant property is not declared in the object type. It's only added on construction.
+     */
+    readonly declaration: ObjectType_AbstractProperty["declaration"];
     readonly filterProperty: ObjectType_AbstractProperty["filterProperty"];
     readonly graphqlField: ObjectType_AbstractProperty["graphqlField"];
+    readonly hashFunctionParameter: ObjectType_AbstractProperty["hashFunctionParameter"];
+    readonly jsonObjectMember: ObjectType_AbstractProperty["jsonObjectMember"];
     readonly kind = "Discriminant";
     readonly mutable = false;
     readonly recursive = false;
+    readonly schema: ObjectType_AbstractProperty["schema"];
+    readonly schemaType: ObjectType_AbstractProperty["schemaType"];
     readonly value: string;
     constructor({ configuration, value, ...superParameters }: {
         value: string;
     } & Omit<ConstructorParameters<typeof ObjectType_AbstractProperty>[0], "name">);
-    get declaration(): Maybe<Code>;
-    get hashFunctionParameter(): Maybe<Code>;
-    get jsonName(): string;
-    get jsonSchema(): ObjectType_AbstractProperty["jsonSchema"];
-    get jsonSignature(): Maybe<Code>;
-    get schema(): Maybe<Code>;
-    get schemaType(): Maybe<Code>;
     get values(): readonly string[];
-    private get constValue();
-    constructorInitializer(): Maybe<Code>;
+    createInitializer(): Maybe<Code>;
     equalsExpression(): Maybe<Code>;
     filterExpression(): Maybe<Code>;
-    fromJsonInitializer(): Maybe<Code>;
+    fromJsonObjectInitializer(): Maybe<Code>;
     fromRdfResourceValuesInitializer(): Maybe<Code>;
-    hashStatements({ variables, }: Parameters<ObjectType_AbstractProperty["hashStatements"]>[0]): readonly Code[];
-    jsonUiSchemaElement({ variables, }: Parameters<ObjectType_AbstractProperty["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    hashStatements(): readonly Code[];
     sparqlConstructTriplesExpression(): Maybe<Code>;
     sparqlWherePatternsExpression(): ReturnType<ObjectType_AbstractProperty["sparqlWherePatternsExpression"]>;
-    toJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["toJsonInitializer"]>[0]): Maybe<Code>;
-    toRdfRdfResourceValuesStatements(): readonly Code[];
+    toJsonObjectInitializer(): Maybe<Code>;
+    toLoggableInitializer(): Maybe<Code>;
+    toRdfResourceValuesStatements(): readonly Code[];
     toStringInitializer(): Maybe<Code>;
 }
 //# sourceMappingURL=ObjectType_DiscriminantProperty.d.ts.map