@shaclmate/compiler 4.0.97 → 4.0.99

package/dist/generators/ts/BigDecimalType.js

@@ -1,10 +1,17 @@
+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 { Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
 import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { code, literalOf } from "./ts-poet-wrapper.js";
 export class BigDecimalType extends AbstractTypedLiteralType {
     inlineExpression = code `${this.reusables.imports.BigDecimal}`;
-    jsonValueType = this.jsonTypeFactory.createJsonStringType();
     jsTypes = [
         {
             className: code `${this.reusables.imports.BigDecimal}`,
@@ -29,18 +36,25 @@ export class BigDecimalType extends AbstractTypedLiteralType {
             },
         ],
     });
-    filterFunction = new ReferenceCallable(this.reusables.snippets.filterBigDecimal);
+    filterFunction = new BuiltinCallable(this.reusables.snippets.filterBigDecimal);
     filterType = code `${this.reusables.snippets.NumericFilter}<${this.reusables.imports.BigDecimal}>`;
-    fromJsonValueFunction = new ReferenceCallable(this.reusables.snippets.bigDecimalFromJsonString);
-    fromJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.bigDecimalFromJsonObject);
-    fromRdfResourceValuesFunction = new ReferenceCallable(this.reusables.snippets.bigDecimalFromRdfResourceValues);
+    fromJsonObjectFunction = new BuiltinCallable(this.reusables.snippets.bigDecimalFromJsonObject);
+    fromJsonValueFunction = new BuiltinCallable(this.reusables.snippets.bigDecimalFromJsonString);
+    fromRdfResourceValuesFunction = new BuiltinCallable(this.reusables.snippets.bigDecimalFromRdfResourceValues);
     graphqlType = new AbstractTypedLiteralType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
-    hashFunction = new ReferenceCallable(this.reusables.snippets.hashBigDecimal);
+    hashFunction = new BuiltinCallable(this.reusables.snippets.hashBigDecimal);
+    jsonValueType = this.jsonTypeFactory.createJsonStringType();
     kind = "BigDecimal";
-    schemaType = code `${this.reusables.snippets.NumericSchema}<${this.reusables.imports.BigDecimal}>`;
-    toJsonValueFunction = new ReferenceCallable(this.reusables.snippets.bigDecimalToJsonString);
-    toJsonObjectFunction = new ReferenceCallable(code `${this.reusables.snippets.bigDecimalToJsonObject}(${this.rdfjsTermExpression(this.datatype)})`);
-    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.bigDecimalSparqlWherePatterns);
+    toJsonObjectFunction = new BuiltinCallable(code `${this.reusables.snippets.bigDecimalToJsonObject}(${this.rdfjsTermExpression(this.datatype)})`);
+    toJsonValueFunction = new BuiltinCallable(this.reusables.snippets.bigDecimalToJsonString);
+    valueSparqlWherePatternsFunction = new BuiltinCallable(this.reusables.snippets.bigDecimalSparqlWherePatterns);
+    get schema() {
+        return new SchemaObject({
+            properties: super.schema.properties,
+            type: new SchemaObject.BuiltinType(code `${this.reusables.snippets.NumericSchema}<${this.reusables.imports.BigDecimal}>`),
+            variable: super.schema.variable,
+        });
+    }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.toFixed()`;
     }
@@ -54,4 +68,7 @@ export class BigDecimalType extends AbstractTypedLiteralType {
         return code `new ${this.reusables.imports.BigDecimal}(${literalOf(literal.value)})`;
     }
 }
+__decorate([
+    Memoize()
+], BigDecimalType.prototype, "schema", null);
 //# sourceMappingURL=BigDecimalType.js.map

package/dist/generators/ts/BigIntType.js

@@ -8,7 +8,7 @@ import { LiteralDecoder } from "@rdfx/literal";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BigIntType extends AbstractNumericType {
     decodedIn = this.in_.map((in_) => LiteralDecoder.decodeBigIntLiteral(in_).unsafeCoerce());
@@ -38,19 +38,19 @@ export class BigIntType extends AbstractNumericType {
     });
     kind = "BigInt";
     get fromJsonObjectFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.bigIntFromJsonObject}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.bigIntFromJsonObject}<${this.expression}>`);
     }
     get fromJsonValueFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.bigIntFromJsonString}<${this.jsonValueType.expression}, ${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.bigIntFromJsonString}<${this.jsonValueType.expression}, ${this.expression}>`);
     }
     get fromRdfResourceValuesFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.bigIntFromRdfResourceValues}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.bigIntFromRdfResourceValues}<${this.expression}>`);
     }
     get toJsonObjectFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.bigIntToJsonObject}(${this.rdfjsTermExpression(this.datatype)})`);
+        return new BuiltinCallable(code `${this.reusables.snippets.bigIntToJsonObject}(${this.rdfjsTermExpression(this.datatype)})`);
     }
     get toJsonValueFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.bigIntToJsonString}`);
+        return new BuiltinCallable(code `${this.reusables.snippets.bigIntToJsonString}`);
     }
     valueExpression(literal) {
         return code `${typeof literal === "bigint" ? literal : LiteralDecoder.decodeBigIntLiteral(literal).unsafeCoerce()}n`;

package/dist/generators/ts/BlankNodeType.d.ts

@@ -1,22 +1,23 @@
 import type { BlankNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
     protected readonly inlineExpression: import("ts-poet/build/Code.js").Code;
     readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
-    readonly filterFunction: ReferenceCallable;
+    readonly filterFunction: BuiltinCallable;
     readonly filterType: import("ts-poet/build/Code.js").Code;
-    readonly fromJsonValueFunction: ReferenceCallable;
-    readonly fromJsonObjectFunction: ReferenceCallable;
-    readonly fromRdfResourceValuesFunction: ReferenceCallable;
+    readonly fromJsonObjectFunction: BuiltinCallable;
+    readonly fromJsonValueFunction: BuiltinCallable;
+    readonly fromRdfResourceValuesFunction: BuiltinCallable;
     readonly kind = "BlankNode";
     readonly nodeKinds: ReadonlySet<"BlankNode">;
-    readonly parseFunction: ReferenceCallable;
-    readonly schemaType: import("ts-poet/build/Code.js").Code;
-    readonly toJsonValueFunction: ReferenceCallable;
-    readonly toJsonObjectFunction: ReferenceCallable;
-    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
+    readonly parseFunction: BuiltinCallable;
+    readonly toJsonObjectFunction: BuiltinCallable;
+    readonly toJsonValueFunction: BuiltinCallable;
+    readonly valueSparqlWherePatternsFunction: BuiltinCallable;
     constructor(superParameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode>>[0], "hasValues" | "in_">);
+    get schema(): SchemaObject<SchemaObject.BuiltinType>;
 }
 //# sourceMappingURL=BlankNodeType.d.ts.map

package/dist/generators/ts/BlankNodeType.js

@@ -1,6 +1,14 @@
+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 { Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BlankNodeType extends AbstractIdentifierType {
     inlineExpression = code `${this.reusables.imports.BlankNode}`;
@@ -17,18 +25,17 @@ export class BlankNodeType extends AbstractIdentifierType {
             },
         ],
     });
-    filterFunction = new ReferenceCallable(this.reusables.snippets.filterBlankNode);
+    filterFunction = new BuiltinCallable(this.reusables.snippets.filterBlankNode);
     filterType = code `${this.reusables.snippets.BlankNodeFilter}`;
-    fromJsonValueFunction = new ReferenceCallable(this.reusables.snippets.blankNodeFromJsonString);
-    fromJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.blankNodeFromJsonObject);
-    fromRdfResourceValuesFunction = new ReferenceCallable(this.reusables.snippets.blankNodeFromRdfResourceValues);
+    fromJsonObjectFunction = new BuiltinCallable(this.reusables.snippets.blankNodeFromJsonObject);
+    fromJsonValueFunction = new BuiltinCallable(this.reusables.snippets.blankNodeFromJsonString);
+    fromRdfResourceValuesFunction = new BuiltinCallable(this.reusables.snippets.blankNodeFromRdfResourceValues);
     kind = "BlankNode";
     nodeKinds = nodeKinds;
-    parseFunction = new ReferenceCallable(this.reusables.snippets.parseBlankNode);
-    schemaType = code `${this.reusables.snippets.BlankNodeSchema}`;
-    toJsonValueFunction = new ReferenceCallable(this.reusables.snippets.blankNodeToJsonString);
-    toJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.blankNodeToJsonObject);
-    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.blankNodeSparqlWherePatterns);
+    parseFunction = new BuiltinCallable(this.reusables.snippets.parseBlankNode);
+    toJsonObjectFunction = new BuiltinCallable(this.reusables.snippets.blankNodeToJsonObject);
+    toJsonValueFunction = new BuiltinCallable(this.reusables.snippets.blankNodeToJsonString);
+    valueSparqlWherePatternsFunction = new BuiltinCallable(this.reusables.snippets.blankNodeSparqlWherePatterns);
     constructor(superParameters) {
         super({
             ...superParameters,
@@ -36,6 +43,16 @@ export class BlankNodeType extends AbstractIdentifierType {
             in_: [],
         });
     }
+    get schema() {
+        return new SchemaObject({
+            properties: super.schema.properties,
+            type: new SchemaObject.BuiltinType(this.reusables.snippets.BlankNodeSchema),
+            variable: super.schema.variable,
+        });
+    }
 }
+__decorate([
+    Memoize()
+], BlankNodeType.prototype, "schema", null);
 const nodeKinds = new Set(["BlankNode"]);
 //# sourceMappingURL=BlankNodeType.js.map

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

@@ -1,26 +1,27 @@
 import type { Literal } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
 import type { Callable } from "./Callable.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BooleanType extends AbstractPrimitiveType<boolean> {
     protected readonly decodedIn: boolean[];
     readonly conversionFunction: Maybe<AbstractPrimitiveType.ConversionFunction>;
-    readonly filterFunction: ReferenceCallable;
+    readonly filterFunction: BuiltinCallable;
     readonly filterType: Code;
     readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
-    readonly hashFunction: ReferenceCallable;
+    readonly hashFunction: BuiltinCallable;
     readonly jsTypes: readonly [{
         readonly typeof: "boolean";
     }];
     readonly jsonValueType: AbstractPrimitiveType.JsonType;
     readonly kind = "Boolean";
-    readonly schemaType: Code;
-    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
+    readonly valueSparqlWherePatternsFunction: BuiltinCallable;
     get fromJsonObjectFunction(): Callable;
     get fromJsonValueFunction(): Callable;
     get fromRdfResourceValuesFunction(): Callable;
+    get schema(): SchemaObject<SchemaObject.BuiltinType>;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<boolean>["toRdfResourceValuesExpression"]>[0]): Code;
     valueExpression(literal: boolean | Literal): Code;
 }

package/dist/generators/ts/BooleanType.js

@@ -8,28 +8,35 @@ import { LiteralDecoder } from "@rdfx/literal";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BooleanType extends AbstractPrimitiveType {
     decodedIn = this.in_.map((in_) => LiteralDecoder.decodeBooleanLiteral(in_).unsafeCoerce());
     conversionFunction = Maybe.empty();
-    filterFunction = new ReferenceCallable(this.reusables.snippets.filterBoolean);
+    filterFunction = new BuiltinCallable(this.reusables.snippets.filterBoolean);
     filterType = code `${this.reusables.snippets.BooleanFilter}`;
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLBoolean}`, this.reusables);
-    hashFunction = new ReferenceCallable(this.reusables.snippets.hashBoolean);
+    hashFunction = new BuiltinCallable(this.reusables.snippets.hashBoolean);
     jsTypes = [{ typeof: "boolean" }];
     jsonValueType = this.jsonTypeFactory.createJsonBooleanType({ in_: this.decodedIn });
     kind = "Boolean";
-    schemaType = code `${this.reusables.snippets.BooleanSchema}<${this.expression}>`;
-    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.booleanSparqlWherePatterns);
+    valueSparqlWherePatternsFunction = new BuiltinCallable(this.reusables.snippets.booleanSparqlWherePatterns);
     get fromJsonObjectFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.booleanFromJsonObject}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.booleanFromJsonObject}<${this.expression}>`);
     }
     get fromJsonValueFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.booleanFromJsonBoolean}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.booleanFromJsonBoolean}<${this.expression}>`);
     }
     get fromRdfResourceValuesFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.booleanFromRdfResourceValues}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.booleanFromRdfResourceValues}<${this.expression}>`);
+    }
+    get schema() {
+        return new SchemaObject({
+            properties: super.schema.properties,
+            type: new SchemaObject.BuiltinType(code `${this.reusables.snippets.BooleanSchema}<${this.expression}>`),
+            variable: super.schema.variable,
+        });
     }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.boolean(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
@@ -47,4 +54,7 @@ __decorate([
 __decorate([
     Memoize()
 ], BooleanType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], BooleanType.prototype, "schema", null);
 //# sourceMappingURL=BooleanType.js.map

package/dist/generators/ts/Callable.d.ts

@@ -1,5 +1,5 @@
+import type { BuiltinCallable } from "./BuiltinCallable.js";
 import type { DeclaredCallable } from "./DeclaredCallable.js";
 import type { InlineCallable } from "./InlineCallable.js";
-import type { ReferenceCallable } from "./ReferenceCallable.js";
-export type Callable = InlineCallable | DeclaredCallable | ReferenceCallable;
+export type Callable = InlineCallable | DeclaredCallable | BuiltinCallable;
 //# sourceMappingURL=Callable.d.ts.map

package/dist/generators/ts/DateTimeType.d.ts

@@ -1,16 +1,16 @@
 import type { Literal } from "@rdfjs/types";
 import { AbstractDateType } from "./AbstractDateType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateTimeType extends AbstractDateType {
-    readonly fromJsonObjectFunction: ReferenceCallable;
-    readonly fromRdfResourceValuesFunction: ReferenceCallable;
+    readonly fromJsonObjectFunction: BuiltinCallable;
+    readonly fromRdfResourceValuesFunction: BuiltinCallable;
     readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     protected readonly jsonStringFormat = "datetime";
-    readonly hashFunction: ReferenceCallable;
+    readonly hashFunction: BuiltinCallable;
     readonly kind = "DateTime";
-    readonly toJsonValueFunction: ReferenceCallable;
-    readonly toJsonObjectFunction: ReferenceCallable;
+    readonly toJsonValueFunction: BuiltinCallable;
+    readonly toJsonObjectFunction: BuiltinCallable;
     valueExpression(literal: Date | Literal): Code;
 }
 //# sourceMappingURL=DateTimeType.d.ts.map

package/dist/generators/ts/DateTimeType.js

@@ -1,16 +1,16 @@
 import { LiteralDecoder } from "@rdfx/literal";
 import { AbstractDateType } from "./AbstractDateType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
 import { code } from "./ts-poet-wrapper.js";
 export class DateTimeType extends AbstractDateType {
-    fromJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.dateTimeFromJsonObject);
-    fromRdfResourceValuesFunction = new ReferenceCallable(this.reusables.snippets.dateTimeFromRdfResourceValues);
+    fromJsonObjectFunction = new BuiltinCallable(this.reusables.snippets.dateTimeFromJsonObject);
+    fromRdfResourceValuesFunction = new BuiltinCallable(this.reusables.snippets.dateTimeFromRdfResourceValues);
     graphqlType = new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDateTime}`, this.reusables);
     jsonStringFormat = "datetime";
-    hashFunction = new ReferenceCallable(this.reusables.snippets.hashDateTime);
+    hashFunction = new BuiltinCallable(this.reusables.snippets.hashDateTime);
     kind = "DateTime";
-    toJsonValueFunction = new ReferenceCallable(this.reusables.snippets.dateTimeToJsonString);
-    toJsonObjectFunction = new ReferenceCallable(code `${this.reusables.snippets.dateToJsonObject}(${this.rdfjsTermExpression(this.datatype)})`);
+    toJsonValueFunction = new BuiltinCallable(this.reusables.snippets.dateTimeToJsonString);
+    toJsonObjectFunction = new BuiltinCallable(code `${this.reusables.snippets.dateToJsonObject}(${this.rdfjsTermExpression(this.datatype)})`);
     valueExpression(literal) {
         return code `new Date("${(literal instanceof Date ? literal : LiteralDecoder.decodeDateTimeLiteral(literal).unsafeCoerce()).toISOString()}")`;
     }

package/dist/generators/ts/DateType.d.ts

@@ -1,16 +1,16 @@
 import type { Literal } from "@rdfjs/types";
 import { AbstractDateType } from "./AbstractDateType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateType extends AbstractDateType {
-    readonly fromJsonObjectFunction: ReferenceCallable;
-    readonly fromRdfResourceValuesFunction: ReferenceCallable;
+    readonly fromJsonObjectFunction: BuiltinCallable;
+    readonly fromRdfResourceValuesFunction: BuiltinCallable;
     readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
-    readonly hashFunction: ReferenceCallable;
+    readonly hashFunction: BuiltinCallable;
     readonly kind = "Date";
     protected readonly jsonStringFormat = "date";
-    readonly toJsonValueFunction: ReferenceCallable;
-    readonly toJsonObjectFunction: ReferenceCallable;
+    readonly toJsonValueFunction: BuiltinCallable;
+    readonly toJsonObjectFunction: BuiltinCallable;
     valueExpression(literal: Date | Literal): Code;
 }
 //# sourceMappingURL=DateType.d.ts.map

package/dist/generators/ts/DateType.js

@@ -1,17 +1,17 @@
 import { LiteralDecoder } from "@rdfx/literal";
 import { AbstractDateType } from "./AbstractDateType.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
 import { DateTimeType } from "./DateTimeType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
 import { code } from "./ts-poet-wrapper.js";
 export class DateType extends AbstractDateType {
-    fromJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.dateFromJsonObject);
-    fromRdfResourceValuesFunction = new ReferenceCallable(this.reusables.snippets.dateFromRdfResourceValues);
+    fromJsonObjectFunction = new BuiltinCallable(this.reusables.snippets.dateFromJsonObject);
+    fromRdfResourceValuesFunction = new BuiltinCallable(this.reusables.snippets.dateFromRdfResourceValues);
     graphqlType = new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDate}`, this.reusables);
-    hashFunction = new ReferenceCallable(this.reusables.snippets.hashDate);
+    hashFunction = new BuiltinCallable(this.reusables.snippets.hashDate);
     kind = "Date";
     jsonStringFormat = "date";
-    toJsonValueFunction = new ReferenceCallable(this.reusables.snippets.dateToJsonString);
-    toJsonObjectFunction = new ReferenceCallable(code `${this.reusables.snippets.dateToJsonObject}(${this.rdfjsTermExpression(this.datatype)})`);
+    toJsonValueFunction = new BuiltinCallable(this.reusables.snippets.dateToJsonString);
+    toJsonObjectFunction = new BuiltinCallable(code `${this.reusables.snippets.dateToJsonObject}(${this.rdfjsTermExpression(this.datatype)})`);
     valueExpression(literal) {
         return code `new Date("${(literal instanceof Date ? literal : LiteralDecoder.decodeDateLiteral(literal).unsafeCoerce()).toISOString()}")`;
     }

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

@@ -3,6 +3,7 @@ import { Maybe } from "purify-ts";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import { InlineCallable } from "./InlineCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemType> extends AbstractContainerType<ItemTypeT> {
@@ -10,7 +11,6 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     readonly equalsFunction: import("./Callable.js").Callable;
     readonly filterFunction: import("./Callable.js").Callable;
     readonly filterType: Code;
-    readonly schemaType: Code;
     readonly fromRdfResourceValuesFunction: InlineCallable;
     readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
     readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
@@ -74,7 +74,7 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     get conversionFunction(): Maybe<AbstractContainerType.ConversionFunction>;
     get fromJsonObjectFunction(): AbstractContainerType<ItemTypeT>["fromJsonObjectFunction"];
     get fromJsonValueFunction(): AbstractContainerType<ItemTypeT>["fromJsonValueFunction"];
-    protected get schemaInitializers(): Code[];
+    get schema(): SchemaObject<SchemaObject.BuiltinType>;
     private get defaultValueExpression();
     graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
     toLoggableExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["toLoggableExpression"]>[0]): Code;

package/dist/generators/ts/DefaultValueType.js

@@ -8,16 +8,16 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractContainerType } from "./AbstractContainerType.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
 import { InlineCallable } from "./InlineCallable.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { code } from "./ts-poet-wrapper.js";
 export class DefaultValueType extends AbstractContainerType {
     defaultValue;
     equalsFunction = this.itemType.equalsFunction;
     filterFunction = this.itemType.filterFunction;
     filterType = this.itemType.filterType;
-    schemaType = code `${this.reusables.snippets.DefaultValueSchema}<${this.itemType.schemaType}>`;
-    fromRdfResourceValuesFunction = new InlineCallable(code `${this.reusables.snippets.defaultValueFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction.unannotatedUsage})`);
+    fromRdfResourceValuesFunction = new InlineCallable(code `${this.reusables.snippets.defaultValueFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schema.type.expression}>(${this.itemType.fromRdfResourceValuesFunction.unannotatedUsage})`);
     graphqlArgs = Maybe.empty();
     graphqlType = this.itemType.graphqlType;
     hashFunction = this.itemType.hashFunction;
@@ -32,7 +32,7 @@ export class DefaultValueType extends AbstractContainerType {
     toRdfResourceValueTypes = this.itemType.toRdfResourceValueTypes;
     validationFunction = this.itemType.validationFunction;
     valueSparqlConstructTriplesFunction = this.itemType.valueSparqlConstructTriplesFunction;
-    valueSparqlWherePatternsFunction = new InlineCallable(code `${this.reusables.snippets.defaultValueSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction.unannotatedUsage})`);
+    valueSparqlWherePatternsFunction = new InlineCallable(code `${this.reusables.snippets.defaultValueSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schema.type.expression}>(${this.itemType.valueSparqlWherePatternsFunction.unannotatedUsage})`);
     constructor({ defaultValue, ...superParameters }) {
         super(superParameters);
         this.defaultValue = defaultValue;
@@ -50,13 +50,20 @@ export class DefaultValueType extends AbstractContainerType {
         });
     }
     get fromJsonObjectFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.defaultValueFromJsonObject}(${this.itemType.fromJsonObjectFunction.annotatedUsage})`);
+        return new BuiltinCallable(code `${this.reusables.snippets.defaultValueFromJsonObject}(${this.itemType.fromJsonObjectFunction.annotatedUsage})`);
     }
     get fromJsonValueFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.defaultValueFromJsonValue}(${this.itemType.fromJsonValueFunction.annotatedUsage})`);
+        return new BuiltinCallable(code `${this.reusables.snippets.defaultValueFromJsonValue}(${this.itemType.fromJsonValueFunction.annotatedUsage})`);
     }
-    get schemaInitializers() {
-        return super.schemaInitializers.concat(code `defaultValue: ${this.rdfjsTermExpression(this.defaultValue)}`);
+    get schema() {
+        return new SchemaObject({
+            properties: {
+                ...super.schema.properties,
+                defaultValue: code `defaultValue: ${this.rdfjsTermExpression(this.defaultValue)}`,
+            },
+            type: new SchemaObject.BuiltinType(code `${this.reusables.snippets.DefaultValueSchema}<${this.itemType.schema.type.expression}>`),
+            variable: super.schema.variable,
+        });
     }
     get defaultValueExpression() {
         switch (this.itemType.kind) {
@@ -98,6 +105,9 @@ __decorate([
 __decorate([
     Memoize()
 ], DefaultValueType.prototype, "fromJsonValueFunction", null);
+__decorate([
+    Memoize()
+], DefaultValueType.prototype, "schema", null);
 __decorate([
     Memoize()
 ], DefaultValueType.prototype, "defaultValueExpression", null);

package/dist/generators/ts/FloatType.js

@@ -8,7 +8,7 @@ import { LiteralDecoder } from "@rdfx/literal";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
 import { code } from "./ts-poet-wrapper.js";
 export class FloatType extends AbstractNumericType {
     decodedIn = this.in_.map((in_) => LiteralDecoder.decodeFloatLiteral(in_).unsafeCoerce());
@@ -18,13 +18,13 @@ export class FloatType extends AbstractNumericType {
     jsonValueType = this.jsonTypeFactory.createJsonNumberType({ in_: this.decodedIn });
     kind = "Float";
     get fromJsonObjectFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.floatFromJsonObject}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.floatFromJsonObject}<${this.expression}>`);
     }
     get fromJsonValueFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.floatFromJsonNumber}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.floatFromJsonNumber}<${this.expression}>`);
     }
     get fromRdfResourceValuesFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.floatFromRdfResourceValues}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.floatFromRdfResourceValues}<${this.expression}>`);
     }
     valueExpression(literal) {
         return code `${typeof literal === "number" ? literal : LiteralDecoder.decodeFloatLiteral(literal).unsafeCoerce()}`;

package/dist/generators/ts/IdentifierType.d.ts

@@ -2,22 +2,23 @@ import type { BlankNode, NamedNode } from "@rdfjs/types";
 import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 export declare class IdentifierType extends AbstractIdentifierType<BlankNode | NamedNode> {
     protected readonly inlineExpression: import("ts-poet/build/Code.js").Code;
     readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
-    readonly filterFunction: ReferenceCallable;
-    readonly fromJsonValueFunction: ReferenceCallable;
-    readonly fromJsonObjectFunction: ReferenceCallable;
+    readonly filterFunction: BuiltinCallable;
+    readonly fromJsonValueFunction: BuiltinCallable;
+    readonly fromJsonObjectFunction: BuiltinCallable;
     readonly filterType: import("ts-poet/build/Code.js").Code;
-    readonly fromRdfResourceValuesFunction: ReferenceCallable;
+    readonly fromRdfResourceValuesFunction: BuiltinCallable;
     readonly kind = "Identifier";
     readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
-    readonly parseFunction: ReferenceCallable;
-    readonly schemaType: import("ts-poet/build/Code.js").Code;
-    readonly toJsonValueFunction: ReferenceCallable;
-    readonly toJsonObjectFunction: ReferenceCallable;
-    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
+    readonly parseFunction: BuiltinCallable;
+    readonly toJsonValueFunction: BuiltinCallable;
+    readonly toJsonObjectFunction: BuiltinCallable;
+    readonly valueSparqlWherePatternsFunction: BuiltinCallable;
     constructor(parameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode | NamedNode>>[0], "hasValues" | "in_">);
+    get schema(): SchemaObject<SchemaObject.BuiltinType>;
 }
 //# sourceMappingURL=IdentifierType.d.ts.map

package/dist/generators/ts/IdentifierType.js

@@ -1,6 +1,14 @@
+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 { Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { code } from "./ts-poet-wrapper.js";
 export class IdentifierType extends AbstractIdentifierType {
     inlineExpression = code `(${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode})`;
@@ -27,18 +35,17 @@ export class IdentifierType extends AbstractIdentifierType {
             },
         ],
     });
-    filterFunction = new ReferenceCallable(this.reusables.snippets.filterIdentifier);
-    fromJsonValueFunction = new ReferenceCallable(this.reusables.snippets.identifierFromJsonString);
-    fromJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.identifierFromJsonObject);
+    filterFunction = new BuiltinCallable(this.reusables.snippets.filterIdentifier);
+    fromJsonValueFunction = new BuiltinCallable(this.reusables.snippets.identifierFromJsonString);
+    fromJsonObjectFunction = new BuiltinCallable(this.reusables.snippets.identifierFromJsonObject);
     filterType = code `${this.reusables.snippets.IdentifierFilter}`;
-    fromRdfResourceValuesFunction = new ReferenceCallable(this.reusables.snippets.identifierFromRdfResourceValues);
+    fromRdfResourceValuesFunction = new BuiltinCallable(this.reusables.snippets.identifierFromRdfResourceValues);
     kind = "Identifier";
     nodeKinds = nodeKinds;
-    parseFunction = new ReferenceCallable(this.reusables.snippets.parseIdentifier);
-    schemaType = code `${this.reusables.snippets.IdentifierSchema}`;
-    toJsonValueFunction = new ReferenceCallable(this.reusables.snippets.identifierToJsonString);
-    toJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.identifierToJsonObject);
-    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.identifierSparqlWherePatterns);
+    parseFunction = new BuiltinCallable(this.reusables.snippets.parseIdentifier);
+    toJsonValueFunction = new BuiltinCallable(this.reusables.snippets.identifierToJsonString);
+    toJsonObjectFunction = new BuiltinCallable(this.reusables.snippets.identifierToJsonObject);
+    valueSparqlWherePatternsFunction = new BuiltinCallable(this.reusables.snippets.identifierSparqlWherePatterns);
     constructor(parameters) {
         super({
             ...parameters,
@@ -46,7 +53,17 @@ export class IdentifierType extends AbstractIdentifierType {
             in_: [],
         });
     }
+    get schema() {
+        return new SchemaObject({
+            properties: super.schema.properties,
+            type: new SchemaObject.BuiltinType(this.reusables.snippets.IdentifierSchema),
+            variable: super.schema.variable,
+        });
+    }
 }
+__decorate([
+    Memoize()
+], IdentifierType.prototype, "schema", null);
 const nodeKinds = new Set([
     "BlankNode",
     "IRI",

package/dist/generators/ts/Imports.d.ts

@@ -36,6 +36,7 @@ export declare class Imports {
     readonly NTriplesTerm: import("ts-poet/build/Import.js").Import;
     readonly Quad: import("ts-poet/build/Import.js").Import;
     readonly Quad_Graph: import("ts-poet/build/Import.js").Import;
+    readonly PrefixMap: import("ts-poet/build/Import.js").Import;
     readonly RdfxResourcePropertyPath: import("ts-poet/build/Import.js").Import;
     readonly Resource: import("ts-poet/build/Import.js").Import;
     readonly ResourceSet: import("ts-poet/build/Import.js").Import;

package/dist/generators/ts/Imports.js

@@ -37,6 +37,7 @@ export class Imports {
     NTriplesTerm = imp("NTriplesTerm@@rdfx/string");
     Quad = imp("t:Quad@@rdfjs/types");
     Quad_Graph = imp("t:Quad_Graph@@rdfjs/types");
+    PrefixMap = imp("t:PrefixMap@@rdfx/collection");
     RdfxResourcePropertyPath = imp("PropertyPath:RdfxResourcePropertyPath@@rdfx/resource");
     Resource = imp("Resource@@rdfx/resource");
     ResourceSet = imp("ResourceSet@@rdfx/resource");