@shaclmate/compiler 4.0.98 → 4.0.100

package/dist/generators/ts/{AbstractStructuredType.js → AbstractUserDefinedType.js}

@@ -9,11 +9,12 @@ import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
 import { DeclaredCallable } from "./DeclaredCallable.js";
 import { InlineCallable } from "./InlineCallable.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
+import { SchemaObject } from "./SchemaObject.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 /**
- * Abstract base class for AbstractCompoundType and StructType.
+ * Abstract base class for user-defined types (compound types, object types).
  */
-export class AbstractStructuredType extends AbstractType {
+export class AbstractUserDefinedType extends AbstractType {
     get equalsFunction() {
         return this._function({
             type: () => this.equalsFunctionType(),
@@ -28,6 +29,16 @@ export class AbstractStructuredType extends AbstractType {
             unqualifiedName: "filter",
         });
     }
+    get schema() {
+        return new SchemaObject({
+            properties: super.schema.properties,
+            type: new SchemaObject.UserDefinedType({
+                members: { kind: code `kind: ${literalOf(this.kind)}` },
+                name: this.name.map((name) => code `${name}.Schema`),
+            }),
+            variable: this.name.map((name) => code `${name}.schema`),
+        });
+    }
     get filterType() {
         return this.name
             .map((name) => code `${name}.Filter`)
@@ -57,11 +68,6 @@ export class AbstractStructuredType extends AbstractType {
             unqualifiedName: "hash",
         });
     }
-    get schemaType() {
-        return this.name
-            .map((name) => code `${name}.Schema`)
-            .orDefaultLazy(() => this.schemaTypeExpression());
-    }
     get toJsonValueFunction() {
         return this.toJsonObjectFunction;
     }
@@ -154,7 +160,7 @@ export class AbstractStructuredType extends AbstractType {
         return code `${this.reusables.snippets.FromJsonFunction}<${this.jsonObjectType.expression}, ${this.expression}, undefined>`;
     }
     fromRdfResourceValuesFunctionType() {
-        return code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>`;
+        return code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schema.type.expression}>`;
     }
     hashFunctionType() {
         return code `${this.reusables.snippets.HashFunction}<${this.expression}>`;
@@ -191,6 +197,12 @@ export class AbstractStructuredType extends AbstractType {
         if (this.configuration.features.has("Object.fromRdf")) {
             addFunctionDeclaration(this.fromRdfResourceValuesFunction);
         }
+        if (this.configuration.features.has("Object.schema")) {
+            staticModuleDeclarations["schema"] =
+                code `export const schema = ${this.schema.literalExpression};`;
+            staticModuleDeclarations["Schema"] =
+                code `export type Schema = typeof schema;`;
+        }
         if (this.configuration.features.has("Object.SPARQL")) {
             addFunctionDeclaration(this.valueSparqlConstructTriplesFunction);
             addFunctionDeclaration(this.valueSparqlWherePatternsFunction);
@@ -222,52 +234,52 @@ export class AbstractStructuredType extends AbstractType {
         return code `${this.reusables.snippets.ToStringFunction}<${this.expression}>`;
     }
     valueSparqlConstructTriplesType() {
-        return code `${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>`;
+        return code `${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schema.type.expression}>`;
     }
     valueSparqlWherePatternsFunctionType() {
-        return code `${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>`;
+        return code `${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schema.type.expression}>`;
     }
 }
 __decorate([
     Memoize()
-], AbstractStructuredType.prototype, "equalsFunction", null);
+], AbstractUserDefinedType.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
-], AbstractStructuredType.prototype, "filterFunction", null);
+], AbstractUserDefinedType.prototype, "filterFunction", null);
 __decorate([
     Memoize()
-], AbstractStructuredType.prototype, "filterType", null);
+], AbstractUserDefinedType.prototype, "schema", null);
 __decorate([
     Memoize()
-], AbstractStructuredType.prototype, "fromJsonObjectFunction", null);
+], AbstractUserDefinedType.prototype, "filterType", null);
 __decorate([
     Memoize()
-], AbstractStructuredType.prototype, "fromRdfResourceValuesFunction", null);
+], AbstractUserDefinedType.prototype, "fromJsonObjectFunction", null);
 __decorate([
     Memoize()
-], AbstractStructuredType.prototype, "hashFunction", null);
+], AbstractUserDefinedType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
-], AbstractStructuredType.prototype, "schemaType", null);
+], AbstractUserDefinedType.prototype, "hashFunction", null);
 __decorate([
     Memoize()
-], AbstractStructuredType.prototype, "toJsonObjectFunction", null);
+], AbstractUserDefinedType.prototype, "toJsonObjectFunction", null);
 __decorate([
     Memoize()
-], AbstractStructuredType.prototype, "toLoggableFunction", null);
+], AbstractUserDefinedType.prototype, "toLoggableFunction", null);
 __decorate([
     Memoize()
-], AbstractStructuredType.prototype, "toRdfResourceValuesFunction", null);
+], AbstractUserDefinedType.prototype, "toRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
-], AbstractStructuredType.prototype, "toStringFunction", null);
+], AbstractUserDefinedType.prototype, "toStringFunction", null);
 __decorate([
     Memoize()
-], AbstractStructuredType.prototype, "valueSparqlConstructTriplesFunction", null);
+], AbstractUserDefinedType.prototype, "valueSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], AbstractStructuredType.prototype, "valueSparqlWherePatternsFunction", null);
+], AbstractUserDefinedType.prototype, "valueSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
-], AbstractStructuredType.prototype, "toRdfResourceValueTypesExpression", null);
-//# sourceMappingURL=AbstractStructuredType.js.map
+], AbstractUserDefinedType.prototype, "toRdfResourceValueTypesExpression", null);
+//# sourceMappingURL=AbstractUserDefinedType.js.map

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

@@ -2,29 +2,30 @@ import type { Literal } from "@rdfjs/types";
 import type { Decimal } from "decimal.js";
 import { Maybe } from "purify-ts";
 import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigDecimalType extends AbstractTypedLiteralType<Decimal> {
     protected readonly inlineExpression: Code;
-    readonly jsonValueType: AbstractTypedLiteralType.JsonType;
     readonly jsTypes: readonly [{
         readonly className: Code;
         readonly instanceof: "class";
         readonly typeof: "object";
     }];
     readonly conversionFunction: Maybe<AbstractTypedLiteralType.ConversionFunction>;
-    readonly filterFunction: ReferenceCallable;
+    readonly filterFunction: BuiltinCallable;
     readonly filterType: Code;
-    readonly fromJsonValueFunction: ReferenceCallable;
-    readonly fromJsonObjectFunction: ReferenceCallable;
-    readonly fromRdfResourceValuesFunction: ReferenceCallable;
+    readonly fromJsonObjectFunction: BuiltinCallable;
+    readonly fromJsonValueFunction: BuiltinCallable;
+    readonly fromRdfResourceValuesFunction: BuiltinCallable;
     readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
-    readonly hashFunction: ReferenceCallable;
+    readonly hashFunction: BuiltinCallable;
+    readonly jsonValueType: AbstractTypedLiteralType.JsonType;
     readonly kind = "BigDecimal";
-    readonly schemaType: Code;
-    readonly toJsonValueFunction: ReferenceCallable;
-    readonly toJsonObjectFunction: ReferenceCallable;
-    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
+    readonly toJsonObjectFunction: BuiltinCallable;
+    readonly toJsonValueFunction: BuiltinCallable;
+    readonly valueSparqlWherePatternsFunction: BuiltinCallable;
+    get schema(): SchemaObject<SchemaObject.BuiltinType>;
     graphqlResolveExpression({ variables, }: Parameters<AbstractTypedLiteralType<Decimal>["graphqlResolveExpression"]>[0]): Code;
     toLoggableExpression({ variables, }: Parameters<AbstractTypedLiteralType<Decimal>["toLoggableExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractTypedLiteralType<Decimal>["toRdfResourceValuesExpression"]>[0]): Code;

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/{ReferenceCallable.d.ts → BuiltinCallable.d.ts}

@@ -2,13 +2,13 @@ import { AbstractCallable } from "./AbstractCallable.js";
 import type { Snippet } from "./Snippet.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
- * A callable that's a reference to a snippet, an import, or a global function.
+ * A callable that's a reference to a built-in snippet, an import, or a global function.
  *
  * Callers assume the referent carries its own type annotations, so there's no distinction between annotated and unannotated usage.
  */
-export declare class ReferenceCallable extends AbstractCallable {
+export declare class BuiltinCallable extends AbstractCallable {
     readonly annotatedUsage: Code;
     readonly unannotatedUsage: Code;
     constructor(reference: Code | Snippet);
 }
-//# sourceMappingURL=ReferenceCallable.d.ts.map
+//# sourceMappingURL=BuiltinCallable.d.ts.map

package/dist/generators/ts/{ReferenceCallable.js → BuiltinCallable.js}

@@ -1,11 +1,11 @@
 import { AbstractCallable } from "./AbstractCallable.js";
 import { code } from "./ts-poet-wrapper.js";
 /**
- * A callable that's a reference to a snippet, an import, or a global function.
+ * A callable that's a reference to a built-in snippet, an import, or a global function.
  *
  * Callers assume the referent carries its own type annotations, so there's no distinction between annotated and unannotated usage.
  */
-export class ReferenceCallable extends AbstractCallable {
+export class BuiltinCallable extends AbstractCallable {
     annotatedUsage;
     unannotatedUsage;
     constructor(reference) {
@@ -13,4 +13,4 @@ export class ReferenceCallable extends AbstractCallable {
         this.annotatedUsage = this.unannotatedUsage = code `${reference}`;
     }
 }
-//# sourceMappingURL=ReferenceCallable.js.map
+//# sourceMappingURL=BuiltinCallable.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;