@shaclmate/compiler 4.0.90 → 4.0.91

package/dist/generators/ts/ObjectType.d.ts

@@ -1,8 +1,8 @@
-import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { ObjectType_DiscriminantProperty } from "./_ObjectType/ObjectType_DiscriminantProperty.js";
 import { ObjectType_IdentifierProperty } from "./_ObjectType/ObjectType_IdentifierProperty.js";
 import type { ObjectType_Property } from "./_ObjectType/ObjectType_Property.js";
+import { ObjectType_RdfTypeProperty } from "./_ObjectType/ObjectType_RdfTypeProperty.js";
 import { ObjectType_ShaclProperty } from "./_ObjectType/ObjectType_ShaclProperty.js";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
@@ -11,10 +11,8 @@ import type { IriType } from "./IriType.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class ObjectType extends AbstractType {
-    protected readonly toRdfTypes: readonly NamedNode[];
     readonly discriminantProperty: Maybe<ObjectType.DiscriminantProperty>;
     readonly extern: boolean;
-    readonly fromRdfType: Maybe<NamedNode>;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly identifierType: BlankNodeType | IdentifierType | IriType;
     readonly jsTypes: readonly [{
@@ -22,20 +20,20 @@ export declare class ObjectType extends AbstractType {
         readonly typeof: "object";
     }];
     readonly kind = "Object";
+    readonly rdfTypeProperty: Maybe<ObjectType.RdfTypeProperty>;
     readonly recursive: boolean;
     readonly synthetic: boolean;
     readonly validationFunction: Maybe<Code>;
-    constructor({ discriminantProperty, extern, fromRdfType, identifierType, lazyProperties, recursive, synthetic, toRdfTypes, ...superParameters }: {
+    constructor({ discriminantProperty, extern, identifierType, lazyProperties, rdfTypeProperty, recursive, synthetic, ...superParameters }: {
         discriminantProperty: Maybe<ObjectType.DiscriminantProperty>;
         comment: Maybe<string>;
         extern: boolean;
-        fromRdfType: Maybe<NamedNode>;
         identifierType: BlankNodeType | IdentifierType | IriType;
         label: Maybe<string>;
         lazyProperties: (objectType: ObjectType) => readonly ObjectType.Property[];
+        rdfTypeProperty: Maybe<ObjectType.RdfTypeProperty>;
         recursive: boolean;
         synthetic: boolean;
-        toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof AbstractType>[0]);
     get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
     protected staticModuleDeclarations(name: string): Record<string, Code>;
@@ -53,6 +51,7 @@ export declare class ObjectType extends AbstractType {
     get properties(): readonly ObjectType.Property[];
     get referencesNamedType(): boolean;
     get schemaExpression(): Code;
+    get schemaVariable(): Maybe<Code>;
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get toRdfjsResourceType(): Code;
@@ -102,5 +101,7 @@ export declare namespace ObjectType {
     type ShaclProperty<TypeT extends Type> = ObjectType_ShaclProperty<TypeT>;
     const DiscriminantProperty: typeof ObjectType_DiscriminantProperty;
     type DiscriminantProperty = ObjectType_DiscriminantProperty;
+    const RdfTypeProperty: typeof ObjectType_RdfTypeProperty;
+    type RdfTypeProperty = ObjectType_RdfTypeProperty;
 }
 //# sourceMappingURL=ObjectType.d.ts.map

package/dist/generators/ts/ObjectType.js

@@ -27,6 +27,7 @@ import { ObjectType_jsonSchemaExpression } from "./_ObjectType/ObjectType_jsonSc
 import { ObjectType_jsonTypeExpression } from "./_ObjectType/ObjectType_jsonTypeExpression.js";
 import { ObjectType_jsonUiSchemaFunctionExpression } from "./_ObjectType/ObjectType_jsonUiSchemaFunctionExpression.js";
 import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
+import { ObjectType_RdfTypeProperty } from "./_ObjectType/ObjectType_RdfTypeProperty.js";
 import { ObjectType_ShaclProperty } from "./_ObjectType/ObjectType_ShaclProperty.js";
 import { ObjectType_schemaExpression } from "./_ObjectType/ObjectType_schemaExpression.js";
 import { ObjectType_schemaTypeExpression } from "./_ObjectType/ObjectType_schemaTypeExpression.js";
@@ -42,30 +43,28 @@ import { ObjectType_valueSparqlWherePatternsFunctionExpression } from "./_Object
 import { AbstractType } from "./AbstractType.js";
 import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
 export class ObjectType extends AbstractType {
-    toRdfTypes;
     discriminantProperty;
     extern;
-    fromRdfType;
     graphqlArgs = Maybe.empty();
     identifierType;
     jsTypes = [
         { instanceof: "Object", typeof: "object" },
     ];
     kind = "Object";
+    rdfTypeProperty;
     recursive;
     synthetic;
     validationFunction = Maybe.empty();
-    constructor({ discriminantProperty, extern, fromRdfType, identifierType, lazyProperties, recursive, synthetic, toRdfTypes, ...superParameters }) {
+    constructor({ discriminantProperty, extern, identifierType, lazyProperties, rdfTypeProperty, recursive, synthetic, ...superParameters }) {
         super(superParameters);
         this.discriminantProperty = discriminantProperty;
         this.extern = extern;
-        this.fromRdfType = fromRdfType;
         this.identifierType = identifierType;
         // Lazily initialize some members in getters to avoid recursive construction
         this.lazyProperties = lazyProperties;
+        this.rdfTypeProperty = rdfTypeProperty;
         this.recursive = recursive;
         this.synthetic = synthetic;
-        this.toRdfTypes = toRdfTypes;
     }
     get conversionFunction() {
         if (this.name.isJust()) {
@@ -260,9 +259,9 @@ export class ObjectType extends AbstractType {
             .orDefaultLazy(() => code `((values, options) => values.chainMap(value => value.toResource().chain(resource => ${ObjectType_fromRdfResourceFunctionExpression.call(this)}(resource, options))))`);
     }
     get fromRdfTypeVariable() {
-        return this.fromRdfType.map((fromRdfType) => this.name
-            .map((name) => code `${name}.schema.fromRdfType`)
-            .orDefaultLazy(() => this.rdfjsTermExpression(fromRdfType)));
+        return this.rdfTypeProperty.map((rdfTypeProperty) => this.name
+            .map((name) => code `${name}.schema.properties.${rdfTypeProperty.name}.fromRdfType`)
+            .orDefaultLazy(() => this.rdfjsTermExpression(rdfTypeProperty.fromRdfType)));
     }
     get graphqlType() {
         return new AbstractType.GraphqlType(this.name
@@ -306,6 +305,9 @@ export class ObjectType extends AbstractType {
     get schemaExpression() {
         return ObjectType_schemaExpression.call(this);
     }
+    get schemaVariable() {
+        return this.name.map((name) => code `${name}.schema`);
+    }
     get schemaType() {
         return this.name
             .map((name) => code `${name}.Schema`)
@@ -369,12 +371,9 @@ export class ObjectType extends AbstractType {
             .orDefaultLazy(() => ObjectType_toJsonFunctionExpression.call(this));
     }
     get toRdfTypesVariable() {
-        if (this.toRdfTypes.length === 0) {
-            return Maybe.empty();
-        }
-        return Maybe.of(this.name
-            .map((name) => code `${name}.schema.toRdfTypes`)
-            .orDefaultLazy(() => code `${arrayOf(...this.toRdfTypes.map((toRdfType) => this.rdfjsTermExpression(toRdfType)))}`));
+        return this.rdfTypeProperty.map((rdfTypeProperty) => this.schemaVariable
+            .map((schemaVariable) => code `${schemaVariable}.properties.${rdfTypeProperty.name}.toRdfTypes`)
+            .orDefaultLazy(() => code `${arrayOf(...rdfTypeProperty.toRdfTypes.map((toRdfType) => this.rdfjsTermExpression(toRdfType)))}`));
     }
     get toStringFunction() {
         return this.name
@@ -382,7 +381,7 @@ export class ObjectType extends AbstractType {
             .orDefaultLazy(() => ObjectType_toStringFunctionExpression.call(this));
     }
     get inlineExpression() {
-        return code `{ ${joinCode(this.properties.map((property) => property.declaration), { on: "\n\n" })} }`;
+        return code `{ ${joinCode(this.properties.flatMap((property) => property.declaration.toList()), { on: "\n\n" })} }`;
     }
     fromJsonExpression({ variables, }) {
         // Assumes the JSON object has been recursively validated already.
@@ -434,9 +433,7 @@ export class ObjectType extends AbstractType {
         return code `${this.reusables.snippets.compactRecord}({${joinCode(this.properties.flatMap((property) => property
             .toStringInitializer({
             variables: {
-                value: property.accessExpression({
-                    variables: { object: variables.value },
-                }),
+                object: variables.value,
             },
         })
             .toList()), { on: "," })}})`;
@@ -485,6 +482,9 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType.prototype, "schemaExpression", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "schemaVariable", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "schemaType", null);
@@ -528,5 +528,6 @@ __decorate([
     ObjectType.IdentifierProperty = ObjectType_IdentifierProperty;
     ObjectType.ShaclProperty = ObjectType_ShaclProperty;
     ObjectType.DiscriminantProperty = ObjectType_DiscriminantProperty;
+    ObjectType.RdfTypeProperty = ObjectType_RdfTypeProperty;
 })(ObjectType || (ObjectType = {}));
 //# sourceMappingURL=ObjectType.js.map

package/dist/generators/ts/TypeFactory.js

@@ -56,13 +56,20 @@ export class TypeFactory {
             reusables: this.reusables,
             value: name,
         }));
+        const rdfTypeProperty = astType.fromRdfType.map((fromRdfType) => new ObjectType.RdfTypeProperty({
+            configuration: this.configuration,
+            fromRdfType,
+            logger: this.logger,
+            objectType: { name: astType.name },
+            reusables: this.reusables,
+            toRdfTypes: astType.toRdfTypes,
+        }));
         const identifierType = this.createIdentifierType(astType.identifierType);
         const objectType = new ObjectType({
             discriminantProperty,
             comment: astType.comment,
             configuration: this.configuration,
             extern: astType.extern,
-            fromRdfType: astType.fromRdfType,
             identifierType,
             label: astType.label,
             lazyProperties: (objectType) => {
@@ -83,6 +90,9 @@ export class TypeFactory {
                 discriminantProperty.ifJust((discriminantProperty) => {
                     properties.splice(0, 0, discriminantProperty);
                 });
+                rdfTypeProperty.ifJust((rdfTypeProperty) => {
+                    properties.splice(0, 0, rdfTypeProperty);
+                });
                 properties.splice(0, 0, new ObjectType.IdentifierProperty({
                     configuration: this.configuration,
                     logger: this.logger,
@@ -95,11 +105,11 @@ export class TypeFactory {
             },
             logger: this.logger,
             name: astType.name.map((name) => this.tsName(name, { synthetic: astType.synthetic })),
+            rdfTypeProperty,
             recursive: astType.recursive,
             reusables: this.reusables,
             shapeIdentifier: astType.shapeIdentifier,
             synthetic: astType.synthetic,
-            toRdfTypes: astType.toRdfTypes,
         });
         this.cachedObjectTypesByShapeIdentifier.set(astType.shapeIdentifier, objectType);
         return objectType;

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

@@ -4,8 +4,8 @@ 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";
-export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Type, "expression" | "filterFunction" | "mutable" | "schema">> {
+import type { Code } from "../ts-poet-wrapper.js";
+export declare abstract class ObjectType_AbstractProperty {
     protected readonly configuration: TsGenerator.Configuration;
     protected readonly logger: Logger;
     protected readonly objectType: {
@@ -22,7 +22,7 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
     /**
      * Property declaration to include in the type declaration of the ObjectType.
      */
-    abstract readonly declaration: Code;
+    abstract readonly declaration: Maybe<Code>;
     /**
      * Optional property in the ObjectType's filter.
      */
@@ -47,7 +47,7 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
      *
      * Only specified if different from declaration.
      */
-    abstract readonly hashFunctionParameter: Code;
+    abstract readonly hashFunctionParameter: Maybe<Code>;
     /**
      * zod object key: schema.
      */
@@ -83,11 +83,7 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
      * TypeScript type describing .schema.
      */
     abstract readonly schemaType: Maybe<Code>;
-    /**
-     * Property type
-  .   */
-    readonly type: TypeT;
-    constructor({ configuration, logger, name, objectType, reusables, type, }: {
+    constructor({ configuration, logger, name, objectType, reusables, }: {
         configuration: TsGenerator.Configuration;
         logger: Logger;
         name: string;
@@ -95,22 +91,36 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
             readonly name: Maybe<string>;
         };
         reusables: Reusables;
-        type: TypeT;
     });
     /**
-     * Expression to access the value of this property on an object instance. May evaluate a thunk.
+     * Initializer (name: value) from a constructor parameter.
      */
-    accessExpression({ variables }: {
+    abstract constructorInitializer(parameters: {
         variables: {
-            object: Code;
+            parameters: Code;
         };
-    }): Code;
+    }): Maybe<Code>;
     /**
-     * Initializer (name: value) from a constructor parameter.
+     * An expression that compares two values of this property, returning a $EqualsResult.
      */
-    abstract constructorInitializer(parameters: {
+    abstract equalsExpression(parameters: {
         variables: {
-            parameters: Code;
+            leftObject: Code;
+            rightObject: Code;
+        };
+    }): Maybe<Code>;
+    /**
+     * Expression to filter this property using an instance of the ObjectType's filter.
+     *
+     * Parameters:
+     *   variables: runtime variables
+     *     - filter: an instance of the object's filterType or undefined
+     *     - object: an instance of the object
+     */
+    abstract filterExpression(parameters: {
+        variables: {
+            filter: Code;
+            object: Code;
         };
     }): Maybe<Code>;
     /**
@@ -136,7 +146,7 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
     abstract hashStatements(parameters: {
         variables: {
             hasher: Code;
-            value: Code;
+            object: Code;
         };
     }): readonly Code[];
     /**
@@ -154,6 +164,7 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
      *   variables: runtime variables
      *     - filter: an instance of the object's filterType or undefined
      *     - focusIdentifier: identifier (rdfjs.NamedNode or rdfjs.Variable) of the object that is the focus of the patterns
+     *     - ignoreRdfType: whether the RDF type of objects/object unions should be ignored
      *     - variablePrefix: prefix to use for new SPARQL variables
      *
      * Returns a (runtime) array of sparqljs.Triple.
@@ -162,6 +173,7 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
         variables: {
             filter: Code;
             focusIdentifier: Code;
+            ignoreRdfType: Code;
             variablePrefix: Code;
         };
     }): Maybe<Code>;
@@ -172,6 +184,8 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
      *   variables: (at runtime)
      *     - filter: an instance of the object's filterType or undefined
      *     - focusIdentifier: identifier (rdfjs.NamedNode or rdfjs.Variable) of the object that is the focus of the patterns
+     *     - ignoreRdfType: whether the RDF type of objects/object unions should be ignored
+     *     - schema: an instance of the object's schema if available
      *     - preferredLanguages: array of preferred language code (strings)
      *     - variablePrefix: prefix to use for new SPARQL variables
      *
@@ -183,7 +197,9 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
         variables: {
             filter: Code;
             focusIdentifier: Code;
+            ignoreRdfType: Code;
             preferredLanguages: Code;
+            schema: Maybe<Code>;
             variablePrefix: Code;
         };
     }): Maybe<{
@@ -195,21 +211,23 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
      */
     abstract toJsonInitializer(parameters: {
         variables: {
-            value: Code;
+            object: Code;
         };
     }): Maybe<Code>;
     /**
      * Statements to serialize this property to an RDF resource.
      */
     abstract toRdfRdfResourceValuesStatements(parameters: {
-        variables: Omit<Parameters<Type["toRdfResourceValuesExpression"]>[0]["variables"], "propertyPath">;
+        variables: Omit<Parameters<Type["toRdfResourceValuesExpression"]>[0]["variables"], "propertyPath" | "value"> & {
+            object: Code;
+        };
     }): readonly Code[];
     /**
      * Initializer (name: value) to serialize this property to a human-readable string (toString).
      */
     abstract toStringInitializer(parameters: {
         variables: {
-            value: Code;
+            object: Code;
         };
     }): Maybe<Code>;
     protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;

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

@@ -1,5 +1,4 @@
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { code } from "../ts-poet-wrapper.js";
 export class ObjectType_AbstractProperty {
     configuration;
     logger;
@@ -9,29 +8,18 @@ export class ObjectType_AbstractProperty {
      * TypeScript identifier-safe name of the property.
      */
     name;
-    /**
-     * Property type
-  .   */
-    type;
-    constructor({ configuration, logger, name, objectType, reusables, type, }) {
+    constructor({ configuration, logger, name, objectType, reusables, }) {
         this.configuration = configuration;
         this.logger = logger;
         this.name = name;
         this.objectType = objectType;
         this.reusables = reusables;
-        this.type = type;
         this.rdfjsTermExpression = rdfjsTermExpression.bind({
             imports: this.reusables.imports,
             logger: this.logger,
             snippets: this.reusables.snippets,
         });
     }
-    /**
-     * Expression to access the value of this property on an object instance. May evaluate a thunk.
-     */
-    accessExpression({ variables }) {
-        return code `${variables.object}.${this.name}`;
-    }
     rdfjsTermExpression;
 }
 //# sourceMappingURL=ObjectType_AbstractProperty.js.map

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

@@ -1,45 +1,37 @@
 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<ObjectType_DiscriminantProperty.Type> {
-    readonly constructorParameter: ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["constructorParameter"];
-    readonly declaration: Code;
-    readonly filterProperty: ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["filterProperty"];
-    readonly graphqlField: ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["graphqlField"];
-    readonly hashFunctionParameter: Code;
+export declare class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty {
+    readonly constructorParameter: ObjectType_AbstractProperty["constructorParameter"];
+    readonly filterProperty: ObjectType_AbstractProperty["filterProperty"];
+    readonly graphqlField: ObjectType_AbstractProperty["graphqlField"];
     readonly kind = "Discriminant";
     readonly mutable = false;
     readonly recursive = false;
     readonly value: string;
     constructor({ configuration, value, ...superParameters }: {
         value: string;
-    } & Omit<ConstructorParameters<typeof ObjectType_AbstractProperty>[0], "name" | "type">);
+    } & Omit<ConstructorParameters<typeof ObjectType_AbstractProperty>[0], "name">);
+    get declaration(): Maybe<Code>;
+    get hashFunctionParameter(): Maybe<Code>;
     get jsonName(): string;
-    get jsonSchema(): ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["jsonSchema"];
+    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>;
+    equalsExpression(): Maybe<Code>;
+    filterExpression(): Maybe<Code>;
     fromJsonInitializer(): Maybe<Code>;
     fromRdfResourceValuesInitializer(): Maybe<Code>;
-    hashStatements({ variables, }: Parameters<ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["hashStatements"]>[0]): readonly Code[];
-    jsonUiSchemaElement({ variables, }: Parameters<ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    hashStatements({ variables, }: Parameters<ObjectType_AbstractProperty["hashStatements"]>[0]): readonly Code[];
+    jsonUiSchemaElement({ variables, }: Parameters<ObjectType_AbstractProperty["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     sparqlConstructTriplesExpression(): Maybe<Code>;
-    sparqlWherePatternsExpression(): ReturnType<ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["sparqlWherePatternsExpression"]>;
-    toJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["toJsonInitializer"]>[0]): Maybe<Code>;
+    sparqlWherePatternsExpression(): ReturnType<ObjectType_AbstractProperty["sparqlWherePatternsExpression"]>;
+    toJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["toJsonInitializer"]>[0]): Maybe<Code>;
     toRdfRdfResourceValuesStatements(): readonly Code[];
     toStringInitializer(): Maybe<Code>;
 }
-export declare namespace ObjectType_DiscriminantProperty {
-    class Type {
-        readonly value: string;
-        readonly filterFunction: Code;
-        readonly mutable = false;
-        constructor(value: string);
-        get expression(): Code;
-        get schema(): Code;
-    }
-}
 //# sourceMappingURL=ObjectType_DiscriminantProperty.d.ts.map

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

@@ -10,10 +10,8 @@ import { code, literalOf } from "../ts-poet-wrapper.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
 export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty {
     constructorParameter = Maybe.empty();
-    declaration = code `readonly ${this.name}: ${this.type.expression};`;
     filterProperty = Maybe.empty();
     graphqlField = Maybe.empty();
-    hashFunctionParameter = code `readonly ${this.name}?: ${this.type.expression};`;
     kind = "Discriminant";
     mutable = false;
     recursive = false;
@@ -23,10 +21,15 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
             ...superParameters,
             configuration,
             name: configuration.objectDiscriminantProperty.name,
-            type: new ObjectType_DiscriminantProperty.Type(value),
         });
         this.value = value;
     }
+    get declaration() {
+        return Maybe.of(code `readonly ${this.name}: ${literalOf(this.value)};`);
+    }
+    get hashFunctionParameter() {
+        return Maybe.of(code `readonly ${this.name}?: ${literalOf(this.value)};`);
+    }
     get jsonName() {
         return this.configuration.objectDiscriminantProperty.jsonName;
     }
@@ -37,7 +40,7 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
         });
     }
     get jsonSignature() {
-        return Maybe.of(code `readonly "${this.jsonName}": ${this.type.expression}`);
+        return Maybe.of(code `readonly "${this.jsonName}": ${literalOf(this.value)}`);
     }
     get schema() {
         return Maybe.of(code `${{ kind: this.kind, value: this.value }}`);
@@ -54,6 +57,12 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
     constructorInitializer() {
         return Maybe.empty();
     }
+    equalsExpression() {
+        return Maybe.empty();
+    }
+    filterExpression() {
+        return Maybe.empty();
+    }
     fromJsonInitializer() {
         return Maybe.empty();
     }
@@ -62,7 +71,7 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
     }
     hashStatements({ variables, }) {
         return [
-            code `if (${variables.value}) { ${variables.hasher}.update(${variables.value}); }`,
+            code `if (${variables.object}.${this.name}) { ${variables.hasher}.update(${variables.object}.${this.name}); }`,
         ];
     }
     jsonUiSchemaElement({ variables, }) {
@@ -76,7 +85,7 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
         return Maybe.empty();
     }
     toJsonInitializer({ variables, }) {
-        return Maybe.of(code `"${this.jsonName}": ${variables.value}`);
+        return Maybe.of(code `"${this.jsonName}": ${variables.object}.${this.name}`);
     }
     toRdfRdfResourceValuesStatements() {
         return [];
@@ -85,6 +94,12 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
         return Maybe.empty();
     }
 }
+__decorate([
+    Memoize()
+], ObjectType_DiscriminantProperty.prototype, "declaration", null);
+__decorate([
+    Memoize()
+], ObjectType_DiscriminantProperty.prototype, "hashFunctionParameter", null);
 __decorate([
     Memoize()
 ], ObjectType_DiscriminantProperty.prototype, "jsonName", null);
@@ -97,27 +112,10 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType_DiscriminantProperty.prototype, "values", null);
-(function (ObjectType_DiscriminantProperty) {
-    class Type {
-        value;
-        filterFunction = code `nonextant`;
-        mutable = false;
-        constructor(value) {
-            this.value = value;
-        }
-        get expression() {
-            return code `${literalOf(this.value)}`;
-        }
-        get schema() {
-            throw new Error("should never be called");
-        }
-    }
-    __decorate([
-        Memoize()
-    ], Type.prototype, "expression", null);
-    __decorate([
-        Memoize()
-    ], Type.prototype, "schema", null);
-    ObjectType_DiscriminantProperty.Type = Type;
-})(ObjectType_DiscriminantProperty || (ObjectType_DiscriminantProperty = {}));
+__decorate([
+    Memoize()
+], ObjectType_DiscriminantProperty.prototype, "equalsExpression", null);
+__decorate([
+    Memoize()
+], ObjectType_DiscriminantProperty.prototype, "filterExpression", null);
 //# sourceMappingURL=ObjectType_DiscriminantProperty.js.map

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

@@ -4,40 +4,45 @@ import type { IdentifierType } from "../IdentifierType.js";
 import type { IriType } from "../IriType.js";
 import { type Code } from "../ts-poet-wrapper.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
-export declare class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty<BlankNodeType | IdentifierType | IriType> {
+export declare class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
     readonly kind = "Identifier";
     readonly mutable = false;
     readonly recursive = false;
+    readonly type: BlankNodeType | IdentifierType | IriType;
+    constructor({ type, ...superParameters }: {
+        type: BlankNodeType | IdentifierType | IriType;
+    } & ConstructorParameters<typeof ObjectType_AbstractProperty>[0]);
     get constructorParameter(): Maybe<{
         hasQuestionToken: boolean;
         signature: Code;
     }>;
-    get declaration(): Code;
+    get declaration(): Maybe<Code>;
+    equalsExpression({ variables, }: Parameters<ObjectType_AbstractProperty["equalsExpression"]>[0]): Maybe<Code>;
     get filterProperty(): Maybe<{
         name: string;
         type: Code;
     }>;
-    get graphqlField(): ObjectType_AbstractProperty<IdentifierType>["graphqlField"];
-    get hashFunctionParameter(): Code;
-    get jsonSchema(): ObjectType_AbstractProperty<IdentifierType>["jsonSchema"];
+    filterExpression({ variables, }: Parameters<ObjectType_AbstractProperty["filterExpression"]>[0]): Maybe<Code>;
+    get graphqlField(): ObjectType_AbstractProperty["graphqlField"];
+    get hashFunctionParameter(): Maybe<Code>;
+    get jsonSchema(): ObjectType_AbstractProperty["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
     get schema(): Maybe<Code>;
     get schemaType(): Maybe<Code>;
     private get typeExpression();
     private get typeSchemaVariable();
-    accessExpression({ variables, }: Parameters<ObjectType_AbstractProperty<BlankNodeType | IdentifierType | IriType>["accessExpression"]>[0]): Code;
-    constructorInitializer({ variables, }: Parameters<ObjectType_AbstractProperty<IdentifierType>["constructorInitializer"]>[0]): Maybe<Code>;
-    fromJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty<IdentifierType>["fromJsonInitializer"]>[0]): Maybe<Code>;
-    fromRdfResourceValuesInitializer({ variables, }: Parameters<ObjectType_AbstractProperty<IdentifierType>["fromRdfResourceValuesInitializer"]>[0]): Maybe<Code>;
-    hashStatements({ variables, }: Parameters<ObjectType_AbstractProperty<IdentifierType>["hashStatements"]>[0]): readonly Code[];
-    jsonUiSchemaElement({ variables, }: Parameters<ObjectType_AbstractProperty<IdentifierType>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    constructorInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["constructorInitializer"]>[0]): Maybe<Code>;
+    fromJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["fromJsonInitializer"]>[0]): Maybe<Code>;
+    fromRdfResourceValuesInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["fromRdfResourceValuesInitializer"]>[0]): Maybe<Code>;
+    hashStatements({ variables, }: Parameters<ObjectType_AbstractProperty["hashStatements"]>[0]): readonly Code[];
+    jsonUiSchemaElement({ variables, }: Parameters<ObjectType_AbstractProperty["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     sparqlConstructTriplesExpression(): Maybe<Code>;
-    sparqlWherePatternsExpression({ variables, }: Parameters<ObjectType_AbstractProperty<IdentifierType>["sparqlWherePatternsExpression"]>[0]): Maybe<{
+    sparqlWherePatternsExpression({ variables, }: Parameters<ObjectType_AbstractProperty["sparqlWherePatternsExpression"]>[0]): Maybe<{
         condition: Code;
         patterns: Code;
     }>;
-    toJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty<IdentifierType>["toJsonInitializer"]>[0]): Maybe<Code>;
+    toJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["toJsonInitializer"]>[0]): Maybe<Code>;
     toRdfRdfResourceValuesStatements(): readonly Code[];
-    toStringInitializer(parameters: Parameters<ObjectType_AbstractProperty<IdentifierType>["toStringInitializer"]>[0]): Maybe<Code>;
+    toStringInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["toStringInitializer"]>[0]): Maybe<Code>;
 }
 //# sourceMappingURL=ObjectType_IdentifierProperty.d.ts.map