@shaclmate/compiler 4.0.90 → 4.0.92

package/dist/generators/ts/AbstractNumericType.d.ts

@@ -13,6 +13,7 @@ export declare abstract class AbstractNumericType<ValueT extends bigint | number
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
 }
 export declare namespace AbstractNumericType {
+    type ConversionFunction = AbstractPrimitiveType.ConversionFunction;
     const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractPrimitiveType.JsonType;
 }

package/dist/generators/ts/AbstractPrimitiveType.d.ts

@@ -1,5 +1,4 @@
 import type { Primitive } from "@rdfx/literal";
-import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
@@ -7,12 +6,6 @@ import { type Code } from "./ts-poet-wrapper.js";
  * Abstract base class of typed literals whose datatype corresponds to a JavaScript primitive type.
  */
 export declare abstract class AbstractPrimitiveType<ValueT extends Primitive> extends AbstractTypedLiteralType<ValueT> {
-    /**
-     * Primitive types have no conversion functions to avoid source type overlap with other primitive types.
-     *
-     * A property that can take on multiple primitive types should be a union.
-     */
-    readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly equalsFunction: Code;
     protected get inlineExpression(): Code;
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;

package/dist/generators/ts/AbstractPrimitiveType.js

@@ -4,7 +4,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
@@ -13,12 +12,6 @@ import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
  * Abstract base class of typed literals whose datatype corresponds to a JavaScript primitive type.
  */
 export class AbstractPrimitiveType extends AbstractTypedLiteralType {
-    /**
-     * Primitive types have no conversion functions to avoid source type overlap with other primitive types.
-     *
-     * A property that can take on multiple primitive types should be a union.
-     */
-    conversionFunction = Maybe.empty();
     equalsFunction = code `${this.reusables.snippets.strictEquals}`;
     get inlineExpression() {
         if (this.in_.length > 0) {

package/dist/generators/ts/BigDecimalType.d.ts

@@ -6,18 +6,16 @@ import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigDecimalType extends AbstractTypedLiteralType<Decimal> {
     protected readonly inlineExpression: Code;
-    /**
-     * BigDecimal has no conversion function to avoid source type overlap with other types (e.g., string).
-     */
+    readonly jsTypes: readonly [{
+        readonly className: Code;
+        readonly instanceof: "class";
+        readonly typeof: "object";
+    }];
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly fromRdfResourceValuesFunction: Code;
     readonly hashFunction: Code;
-    readonly jsTypes: readonly [{
-        readonly instanceof: "Object";
-        readonly typeof: "object";
-    }];
     readonly kind = "BigDecimal";
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
@@ -26,8 +24,8 @@ export declare class BigDecimalType extends AbstractTypedLiteralType<Decimal> {
     graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     jsonSchema(): Code;
     jsonType(): AbstractLiteralType.JsonType;
-    valueExpression(literal: Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractTypedLiteralType<Decimal>["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractLiteralType["toRdfResourceValuesExpression"]>[0]): Code;
+    valueExpression(literal: Literal): Code;
 }
 //# sourceMappingURL=BigDecimalType.d.ts.map

package/dist/generators/ts/BigDecimalType.js

@@ -11,17 +11,34 @@ import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
 import { code, literalOf } from "./ts-poet-wrapper.js";
 export class BigDecimalType extends AbstractTypedLiteralType {
     inlineExpression = code `${this.reusables.imports.BigDecimal}`;
-    /**
-     * BigDecimal has no conversion function to avoid source type overlap with other types (e.g., string).
-     */
-    conversionFunction = Maybe.empty();
+    jsTypes = [
+        {
+            className: code `${this.reusables.imports.BigDecimal}`,
+            instanceof: "class",
+            typeof: "object",
+        },
+    ];
+    conversionFunction = Maybe.of({
+        code: code `${this.reusables.snippets.convertToBigDecimal}`,
+        sourceTypes: [
+            {
+                expression: code `${this.reusables.imports.BigDecimal}`,
+                jsType: this.jsTypes[0],
+            },
+            {
+                expression: code `number`,
+                jsType: { typeof: "number" },
+            },
+            {
+                expression: code `string`,
+                jsType: { typeof: "string" },
+            },
+        ],
+    });
     filterFunction = code `${this.reusables.snippets.filterBigDecimal}`;
     filterType = code `${this.reusables.snippets.NumericFilter}<${this.reusables.imports.BigDecimal}>`;
     fromRdfResourceValuesFunction = code `${this.reusables.snippets.bigDecimalFromRdfResourceValues}`;
     hashFunction = code `${this.reusables.snippets.hashBigDecimal}`;
-    jsTypes = [
-        { instanceof: "Object", typeof: "object" },
-    ];
     kind = "BigDecimal";
     schemaType = code `${this.reusables.snippets.NumericSchema}<${this.reusables.imports.BigDecimal}>`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.bigDecimalSparqlWherePatterns}`;
@@ -40,15 +57,15 @@ export class BigDecimalType extends AbstractTypedLiteralType {
     jsonType() {
         return new AbstractLiteralType.JsonType(code `{ readonly "@type": ${literalOf(this.datatype.value)}, readonly "@value": string }`);
     }
-    valueExpression(literal) {
-        return code `new ${this.reusables.imports.BigDecimal}(${literalOf(literal.value)})`;
-    }
     toJsonExpression({ variables, }) {
         return code `{ "@type": ${literalOf(this.datatype.value)} as const, "@value": ${variables.value}.toFixed() }`;
     }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.bigDecimalLiteral}(${variables.value})]`;
     }
+    valueExpression(literal) {
+        return code `new ${this.reusables.imports.BigDecimal}(${literalOf(literal.value)})`;
+    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/BigIntType.d.ts

@@ -1,4 +1,5 @@
 import type { Literal } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigIntType extends AbstractNumericType<bigint> {
@@ -6,6 +7,7 @@ export declare class BigIntType extends AbstractNumericType<bigint> {
         readonly typeof: "bigint";
     }[];
     readonly kind = "BigInt";
+    get conversionFunction(): Maybe<AbstractNumericType.ConversionFunction>;
     get fromRdfResourceValuesFunction(): Code;
     get graphqlType(): import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     private get decodedIn();

package/dist/generators/ts/BigIntType.js

@@ -5,12 +5,35 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { LiteralDecoder } from "@rdfx/literal";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { arrayOf, code, joinCode, literalOf, } from "./ts-poet-wrapper.js";
 export class BigIntType extends AbstractNumericType {
     jsTypes = [{ typeof: "bigint" }];
     kind = "BigInt";
+    get conversionFunction() {
+        if (this.in_.length > 0) {
+            return Maybe.empty();
+        }
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertToBigInt}`,
+            sourceTypes: [
+                {
+                    expression: code `bigint`,
+                    jsType: this.jsTypes[0],
+                },
+                {
+                    expression: code `number`,
+                    jsType: { typeof: "number" },
+                },
+                {
+                    expression: code `string`,
+                    jsType: { typeof: "string" },
+                },
+            ],
+        });
+    }
     get fromRdfResourceValuesFunction() {
         return code `${this.reusables.snippets.bigIntFromRdfResourceValues}<${this.expression}>`;
     }
@@ -58,6 +81,9 @@ export class BigIntType extends AbstractNumericType {
         return code `${typeof literal === "bigint" ? literal : LiteralDecoder.decodeBigIntLiteral(literal).unsafeCoerce()}n`;
     }
 }
+__decorate([
+    Memoize()
+], BigIntType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], BigIntType.prototype, "fromRdfResourceValuesFunction", null);

package/dist/generators/ts/BooleanType.d.ts

@@ -1,7 +1,9 @@
 import type { Literal } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BooleanType extends AbstractPrimitiveType<boolean> {
+    readonly conversionFunction: Maybe<AbstractPrimitiveType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;

package/dist/generators/ts/BooleanType.js

@@ -5,10 +5,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { LiteralDecoder } from "@rdfx/literal";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BooleanType extends AbstractPrimitiveType {
+    conversionFunction = Maybe.empty();
     filterFunction = code `${this.reusables.snippets.filterBoolean}`;
     filterType = code `${this.reusables.snippets.BooleanFilter}`;
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLBoolean}`, this.reusables);

package/dist/generators/ts/DefaultValueType.d.ts

@@ -19,7 +19,8 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
         readonly instanceof: "Object";
         readonly typeof: "object";
     }] | readonly [{
-        readonly instanceof: "Object";
+        readonly className: Code;
+        readonly instanceof: "class";
         readonly typeof: "object";
     }] | {
         readonly typeof: "bigint";

package/dist/generators/ts/FloatType.d.ts

@@ -1,7 +1,9 @@
 import type { Literal } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class FloatType extends AbstractNumericType<number> {
+    readonly conversionFunction: Maybe<AbstractNumericType.ConversionFunction>;
     readonly jsTypes: readonly [{
         readonly typeof: "number";
     }];

package/dist/generators/ts/FloatType.js

@@ -5,10 +5,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { LiteralDecoder } from "@rdfx/literal";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class FloatType extends AbstractNumericType {
+    conversionFunction = Maybe.empty();
     jsTypes = [{ typeof: "number" }];
     kind = "Float";
     get fromRdfResourceValuesFunction() {

package/dist/generators/ts/IntType.d.ts

@@ -1,7 +1,9 @@
 import type { Literal } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class IntType extends AbstractNumericType<number> {
+    readonly conversionFunction: Maybe<AbstractNumericType.ConversionFunction>;
     readonly jsTypes: readonly [{
         readonly typeof: "number";
     }];

package/dist/generators/ts/IntType.js

@@ -5,10 +5,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { LiteralDecoder } from "@rdfx/literal";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class IntType extends AbstractNumericType {
+    conversionFunction = Maybe.empty();
     jsTypes = [{ typeof: "number" }];
     kind = "Int";
     get fromRdfResourceValuesFunction() {

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/Snippets.d.ts

@@ -77,6 +77,8 @@ export declare class Snippets {
     get booleanSparqlWherePatterns(): Snippet;
     get compactRecord(): Snippet;
     get convertToArraySet(): Snippet;
+    get convertToBigDecimal(): Snippet;
+    get convertToBigInt(): Snippet;
     get convertToBlankNode(): Snippet;
     get convertToBlankNodeIdentifierProperty(): Snippet;
     get convertToIdentifier(): Snippet;

package/dist/generators/ts/Snippets.js

@@ -28,6 +28,8 @@ import { snippets_CollectionSchema } from "./_snippets/snippets_CollectionSchema
 import { snippets_ConversionFunction } from "./_snippets/snippets_ConversionFunction.js";
 import { snippets_compactRecord } from "./_snippets/snippets_compactRecord.js";
 import { snippets_convertToArraySet } from "./_snippets/snippets_convertToArraySet.js";
+import { snippets_convertToBigDecimal } from "./_snippets/snippets_convertToBigDecimal.js";
+import { snippets_convertToBigInt } from "./_snippets/snippets_convertToBigInt.js";
 import { snippets_convertToBlankNode } from "./_snippets/snippets_convertToBlankNode.js";
 import { snippets_convertToBlankNodeIdentifierProperty } from "./_snippets/snippets_convertToBlankNodeIdentifierProperty.js";
 import { snippets_convertToIdentifier } from "./_snippets/snippets_convertToIdentifier.js";
@@ -383,6 +385,12 @@ export class Snippets {
     get convertToArraySet() {
         return this.snippet(snippets_convertToArraySet);
     }
+    get convertToBigDecimal() {
+        return this.snippet(snippets_convertToBigDecimal);
+    }
+    get convertToBigInt() {
+        return this.snippet(snippets_convertToBigInt);
+    }
     get convertToBlankNode() {
         return this.snippet(snippets_convertToBlankNode);
     }
@@ -933,6 +941,12 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToArraySet", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "convertToBigDecimal", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "convertToBigInt", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToBlankNode", null);

package/dist/generators/ts/StringType.d.ts

@@ -1,8 +1,10 @@
 import type { Literal } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class StringType extends AbstractPrimitiveType<string> {
     private readonly languageIn;
+    readonly conversionFunction: Maybe<AbstractPrimitiveType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
@@ -19,7 +21,7 @@ export declare class StringType extends AbstractPrimitiveType<string> {
     get schemaType(): Code;
     protected get schemaInitializers(): readonly Code[];
     jsonSchema(parameters: Parameters<AbstractPrimitiveType<string>["jsonSchema"]>[0]): Code;
-    valueExpression(literal: Literal | string): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
+    valueExpression(literal: Literal | string): Code;
 }
 //# sourceMappingURL=StringType.d.ts.map

package/dist/generators/ts/StringType.js

@@ -5,11 +5,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { xsd } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { arrayOf, code, literalOf } from "./ts-poet-wrapper.js";
 export class StringType extends AbstractPrimitiveType {
     languageIn;
+    conversionFunction = Maybe.empty();
     filterFunction = code `${this.reusables.snippets.filterString}`;
     filterType = code `${this.reusables.snippets.StringFilter}`;
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
@@ -51,12 +53,12 @@ export class StringType extends AbstractPrimitiveType {
         }
         return super.jsonSchema(parameters);
     }
-    valueExpression(literal) {
-        return code `${literalOf(typeof literal === "string" ? literal : literal.value)}`;
-    }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.string(${variables.value}${!this.datatype.equals(xsd.string) ? `, ${this.rdfjsTermExpression(this.datatype)}` : ""})]`;
     }
+    valueExpression(literal) {
+        return code `${literalOf(typeof literal === "string" ? literal : literal.value)}`;
+    }
 }
 __decorate([
     Memoize()

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/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_conversionFunctionExpression.js

@@ -5,6 +5,8 @@ import { code, joinCode } from "../ts-poet-wrapper.js";
 export function AbstractDiscriminatedUnionType_conversionFunctionExpression() {
     if (this.discriminant.kind === "Typeof") {
         // If the members are discriminated by typeof, they can all be used as source types.
+        // Don't consider the member types' conversion functions, since the source types might overlap.
+        // Only consider the member types' declared type(s) (e.g., type.jsTypes).
         return Maybe.of({
             code: code `${this.reusables.snippets.identityConversionFunction}`,
             sourceTypes: this.members.flatMap(({ type }) => type.jsTypes.map((jsType) => ({