@shaclmate/compiler 4.0.98 → 4.0.100

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/IntType.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 IntType extends AbstractNumericType {
     decodedIn = this.in_.map((in_) => LiteralDecoder.decodeFloatLiteral(in_).unsafeCoerce());
@@ -17,13 +17,13 @@ export class IntType extends AbstractNumericType {
     jsonValueType = this.jsonTypeFactory.createJsonNumberType({ in_: this.decodedIn });
     kind = "Int";
     get fromJsonObjectFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.intFromJsonObject}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.intFromJsonObject}<${this.expression}>`);
     }
     get fromJsonValueFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.intFromJsonNumber}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.intFromJsonNumber}<${this.expression}>`);
     }
     get fromRdfResourceValuesFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.intFromRdfResourceValues}<${this.expression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.intFromRdfResourceValues}<${this.expression}>`);
     }
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLInt}`, this.reusables);

package/dist/generators/ts/IriType.d.ts

@@ -1,16 +1,16 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.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 IriType extends AbstractIdentifierType<NamedNode> {
-    readonly filterFunction: ReferenceCallable;
+    readonly filterFunction: BuiltinCallable;
     readonly filterType: Code;
     readonly kind = "Iri";
     readonly nodeKinds: ReadonlySet<"IRI">;
-    readonly schemaType: Code;
-    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
+    readonly valueSparqlWherePatternsFunction: BuiltinCallable;
     get fromJsonValueFunction(): AbstractIdentifierType<NamedNode>["fromJsonValueFunction"];
     get fromJsonObjectFunction(): AbstractIdentifierType<NamedNode>["fromJsonObjectFunction"];
     get toJsonValueFunction(): AbstractIdentifierType<NamedNode>["toJsonValueFunction"];
@@ -22,7 +22,7 @@ export declare class IriType extends AbstractIdentifierType<NamedNode> {
     get parseFunction(): Callable;
     protected get inlineExpression(): Code;
     protected staticModuleDeclarations(name: string): Record<string, Code>;
-    protected get schemaInitializers(): readonly Code[];
+    get schema(): SchemaObject<SchemaObject.BuiltinType>;
     protected get inlineValueTypeExpression(): Code;
     private get valueTypeExpression();
 }

package/dist/generators/ts/IriType.js

@@ -8,37 +8,37 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
 import { InlineCallable } from "./InlineCallable.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
-import { arrayOf, code, joinCode, literalOf, } from "./ts-poet-wrapper.js";
+import { SchemaObject } from "./SchemaObject.js";
+import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
 export class IriType extends AbstractIdentifierType {
-    filterFunction = new ReferenceCallable(this.reusables.snippets.filterIri);
+    filterFunction = new BuiltinCallable(this.reusables.snippets.filterIri);
     filterType = code `${this.reusables.snippets.IriFilter}`;
     kind = "Iri";
     nodeKinds = nodeKinds;
-    schemaType = code `${this.reusables.snippets.IriSchema}<${this.valueTypeExpression}>`;
-    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.iriSparqlWherePatterns);
+    valueSparqlWherePatternsFunction = new BuiltinCallable(this.reusables.snippets.iriSparqlWherePatterns);
     get fromJsonValueFunction() {
         if (this.in_.length > 0) {
-            return new ReferenceCallable(code `${this.reusables.snippets.iriLiteralFromJsonString}<${this.valueTypeExpression}>`);
+            return new BuiltinCallable(code `${this.reusables.snippets.iriLiteralFromJsonString}<${this.valueTypeExpression}>`);
         }
         else {
-            return new ReferenceCallable(this.reusables.snippets.iriFromJsonString);
+            return new BuiltinCallable(this.reusables.snippets.iriFromJsonString);
         }
     }
     get fromJsonObjectFunction() {
         if (this.in_.length > 0) {
-            return new ReferenceCallable(code `${this.reusables.snippets.iriLiteralFromJsonObject}<${this.valueTypeExpression}>`);
+            return new BuiltinCallable(code `${this.reusables.snippets.iriLiteralFromJsonObject}<${this.valueTypeExpression}>`);
         }
         else {
-            return new ReferenceCallable(this.reusables.snippets.iriFromJsonObject);
+            return new BuiltinCallable(this.reusables.snippets.iriFromJsonObject);
         }
     }
     get toJsonValueFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.iriToJsonString}<${this.valueTypeExpression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.iriToJsonString}<${this.valueTypeExpression}>`);
     }
     get toJsonObjectFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.iriToJsonObject}<${this.valueTypeExpression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.iriToJsonObject}<${this.valueTypeExpression}>`);
     }
     get jsonValueType() {
         if (this.in_.length === 0) {
@@ -80,13 +80,13 @@ export class IriType extends AbstractIdentifierType {
         });
     }
     get fromRdfResourceValuesFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.iriFromRdfResourceValues}<${this.valueTypeExpression}>`);
+        return new BuiltinCallable(code `${this.reusables.snippets.iriFromRdfResourceValues}<${this.valueTypeExpression}>`);
     }
     get parseFunction() {
         if (this.in_.length > 0) {
             return new InlineCallable(code `(identifier: string) => ${this.reusables.snippets.parseIri}(identifier).chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${this.reusables.imports.Right}(identifier as ${this.expression});`))} default: return ${this.reusables.imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`);
         }
-        return new ReferenceCallable(this.reusables.snippets.parseIri);
+        return new BuiltinCallable(this.reusables.snippets.parseIri);
     }
     get inlineExpression() {
         if (this.in_.length > 0) {
@@ -103,16 +103,18 @@ export class IriType extends AbstractIdentifierType {
             inValues: code `const inValues = ${arrayOf(...this.in_.map((in_) => in_.value))} as const;`,
         };
     }
-    get schemaInitializers() {
-        if (this.in_.length === 0 || this.name.isNothing()) {
-            return super.schemaInitializers;
+    get schema() {
+        const thisProperties = {};
+        if (this.in_.length > 0 && this.name.isJust()) {
+            thisProperties["in"] =
+                code `in: inValues.map(inValue => ${this.reusables.imports.dataFactory}.namedNode(inValue))`;
+            thisProperties["inValues"] = code `inValues`;
         }
-        let initializers = [code `kind: ${literalOf(this.kind)} as const`];
-        if (this.hasValues.length > 0) {
-            initializers = initializers.concat(code `hasValues: ${arrayOf(...this.hasValues.map((hasValue) => this.rdfjsTermExpression(hasValue)))}`);
-        }
-        initializers = initializers.concat(code `in: inValues.map(inValue => ${this.reusables.imports.dataFactory}.namedNode(inValue))`, code `inValues`);
-        return initializers;
+        return new SchemaObject({
+            properties: { ...super.schema.properties, ...thisProperties },
+            type: new SchemaObject.BuiltinType(code `${this.reusables.snippets.IriSchema}<${this.valueTypeExpression}>`),
+            variable: super.schema.variable,
+        });
     }
     get inlineValueTypeExpression() {
         if (this.in_.length === 0) {
@@ -161,6 +163,9 @@ __decorate([
 __decorate([
     Memoize()
 ], IriType.prototype, "inlineExpression", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "schema", null);
 __decorate([
     Memoize()
 ], IriType.prototype, "inlineValueTypeExpression", null);

package/dist/generators/ts/LangStringType.d.ts

@@ -1,17 +1,18 @@
 import type { Literal } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.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 LangStringType extends AbstractLiteralType {
     private readonly languageIn;
     protected readonly inlineExpression: Code;
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
-    readonly filterFunction: ReferenceCallable;
+    readonly filterFunction: BuiltinCallable;
     readonly filterType: Code;
-    readonly fromJsonObjectFunction: ReferenceCallable;
-    readonly fromJsonValueFunction: ReferenceCallable;
-    readonly fromRdfResourceValuesFunction: ReferenceCallable;
+    readonly fromJsonObjectFunction: BuiltinCallable;
+    readonly fromJsonValueFunction: BuiltinCallable;
+    readonly fromRdfResourceValuesFunction: BuiltinCallable;
     readonly jsTypes: readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";
@@ -19,16 +20,15 @@ export declare class LangStringType extends AbstractLiteralType {
     readonly jsonObjectType: AbstractLiteralType["jsonObjectType"];
     readonly jsonValueType: AbstractLiteralType["jsonValueType"];
     readonly kind = "LangString";
-    readonly schemaType: Code;
-    readonly toJsonObjectFunction: ReferenceCallable;
-    readonly toJsonValueFunction: ReferenceCallable;
-    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
+    readonly toJsonObjectFunction: BuiltinCallable;
+    readonly toJsonValueFunction: BuiltinCallable;
+    readonly valueSparqlWherePatternsFunction: BuiltinCallable;
     constructor({ languageIn, ...superParameters }: {
         languageIn: readonly string[];
     } & ConstructorParameters<typeof AbstractLiteralType>[0]);
     get discriminatedType(): Maybe<AbstractLiteralType.DiscriminatedType>;
     get graphqlType(): AbstractLiteralType.GraphqlType;
-    protected get schemaInitializers(): readonly Code[];
+    get schema(): SchemaObject<SchemaObject.BuiltinType>;
     graphqlResolveExpression(_parameters: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     toLoggableExpression({ variables, }: Parameters<AbstractLiteralType["toLoggableExpression"]>[0]): Code;
     valueExpression(literal: Literal): Code;

package/dist/generators/ts/LangStringType.js

@@ -7,7 +7,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class LangStringType extends AbstractLiteralType {
     languageIn;
@@ -21,11 +22,11 @@ export class LangStringType extends AbstractLiteralType {
             },
         ],
     });
-    filterFunction = new ReferenceCallable(this.reusables.snippets.filterLiteral);
+    filterFunction = new BuiltinCallable(this.reusables.snippets.filterLiteral);
     filterType = code `${this.reusables.snippets.LiteralFilter}`;
-    fromJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.langStringFromJsonObject);
+    fromJsonObjectFunction = new BuiltinCallable(this.reusables.snippets.langStringFromJsonObject);
     fromJsonValueFunction = this.fromJsonObjectFunction;
-    fromRdfResourceValuesFunction = new ReferenceCallable(this.reusables.snippets.langStringFromRdfResourceValues);
+    fromRdfResourceValuesFunction = new BuiltinCallable(this.reusables.snippets.langStringFromRdfResourceValues);
     jsTypes = [
         { instanceof: "Object", typeof: "object" },
     ];
@@ -37,10 +38,9 @@ export class LangStringType extends AbstractLiteralType {
     }, { snippet: this.reusables.snippets.LangStringJsonObject });
     jsonValueType = this.jsonObjectType;
     kind = "LangString";
-    schemaType = code `${this.reusables.snippets.LangStringSchema}`;
-    toJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.langStringToJsonObject);
+    toJsonObjectFunction = new BuiltinCallable(this.reusables.snippets.langStringToJsonObject);
     toJsonValueFunction = this.toJsonObjectFunction;
-    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.langStringSparqlWherePatterns);
+    valueSparqlWherePatternsFunction = new BuiltinCallable(this.reusables.snippets.langStringSparqlWherePatterns);
     constructor({ languageIn, ...superParameters }) {
         super(superParameters);
         this.languageIn = languageIn;
@@ -58,12 +58,17 @@ export class LangStringType extends AbstractLiteralType {
     get graphqlType() {
         throw new Error("not implemented");
     }
-    get schemaInitializers() {
-        let initializers = super.schemaInitializers;
-        if (this.languageIn.length > 0) {
-            initializers = initializers.concat(code `languageIn: ${arrayOf(...this.languageIn)}`);
-        }
-        return initializers;
+    get schema() {
+        return new SchemaObject({
+            properties: this.languageIn.length > 0
+                ? {
+                    ...super.schema.properties,
+                    languageIn: code `languageIn: ${arrayOf(...this.languageIn)}`,
+                }
+                : super.schema.properties,
+            type: new SchemaObject.BuiltinType(this.reusables.snippets.LangStringSchema),
+            variable: super.schema.variable,
+        });
     }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
@@ -78,4 +83,7 @@ export class LangStringType extends AbstractLiteralType {
 __decorate([
     Memoize()
 ], LangStringType.prototype, "discriminatedType", null);
+__decorate([
+    Memoize()
+], LangStringType.prototype, "schema", null);
 //# sourceMappingURL=LangStringType.js.map

package/dist/generators/ts/ListType.js

@@ -8,8 +8,8 @@ import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
 import { InlineCallable } from "./InlineCallable.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class ListType extends AbstractCollectionType {
     identifierNodeKind;
@@ -44,16 +44,16 @@ export class ListType extends AbstractCollectionType {
         });
     }
     get fromJsonValueFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.arrayFromJsonArray}(${this.itemType.fromJsonValueFunction.annotatedUsage})`);
+        return new BuiltinCallable(code `${this.reusables.snippets.arrayFromJsonArray}(${this.itemType.fromJsonValueFunction.annotatedUsage})`);
     }
     get fromJsonObjectFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.listFromJsonObject}(${this.itemType.fromJsonValueFunction.annotatedUsage})`);
+        return new BuiltinCallable(code `${this.reusables.snippets.listFromJsonObject}(${this.itemType.fromJsonValueFunction.annotatedUsage})`);
     }
     get fromRdfResourceValuesFunction() {
-        return new InlineCallable(code `${this._mutable ? this.reusables.snippets.mutableListFromRdfResourceValues : this.reusables.snippets.listFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction.unannotatedUsage})`);
+        return new InlineCallable(code `${this._mutable ? this.reusables.snippets.mutableListFromRdfResourceValues : this.reusables.snippets.listFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schema.type.expression}>(${this.itemType.fromRdfResourceValuesFunction.unannotatedUsage})`);
     }
     get toJsonValueFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.arrayToJsonArray}(${this.itemType.toJsonValueFunction.annotatedUsage})`);
+        return new BuiltinCallable(code `${this.reusables.snippets.arrayToJsonArray}(${this.itemType.toJsonValueFunction.annotatedUsage})`);
     }
     get toJsonObjectFunction() {
         return new InlineCallable(code `${this.reusables.snippets.listToJsonObject}(${this.itemType.toJsonValueFunction.annotatedUsage})`);
@@ -62,10 +62,10 @@ export class ListType extends AbstractCollectionType {
         return new Set(["BlankNode", "NamedNode"]); // List or rdf:nil
     }
     get valueSparqlConstructTriplesFunction() {
-        return new InlineCallable(code `${this.reusables.snippets.listSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction.unannotatedUsage})`);
+        return new InlineCallable(code `${this.reusables.snippets.listSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schema.type.expression}>(${this.itemType.valueSparqlConstructTriplesFunction.unannotatedUsage})`);
     }
     get valueSparqlWherePatternsFunction() {
-        return new InlineCallable(code `${this.reusables.snippets.listSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction.unannotatedUsage})`);
+        return new InlineCallable(code `${this.reusables.snippets.listSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schema.type.expression}>(${this.itemType.valueSparqlWherePatternsFunction.unannotatedUsage})`);
     }
     toRdfResourceValuesExpression({ variables, }) {
         let mintListIdentifierFunction;

package/dist/generators/ts/LiteralType.d.ts

@@ -1,33 +1,33 @@
 import type { Literal } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.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 LiteralType extends AbstractLiteralType {
     private readonly languageIn;
     protected readonly inlineExpression: Code;
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
-    readonly filterFunction: ReferenceCallable;
+    readonly filterFunction: BuiltinCallable;
     readonly filterType: Code;
-    readonly fromJsonObjectFunction: ReferenceCallable;
-    readonly fromJsonValueFunction: ReferenceCallable;
-    readonly fromRdfResourceValuesFunction: ReferenceCallable;
+    readonly fromJsonObjectFunction: BuiltinCallable;
+    readonly fromJsonValueFunction: BuiltinCallable;
+    readonly fromRdfResourceValuesFunction: BuiltinCallable;
     readonly jsTypes: readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";
     }];
     readonly jsonValueType: AbstractLiteralType["jsonValueType"];
     readonly kind = "Literal";
-    readonly schemaType: Code;
-    readonly toJsonObjectFunction: ReferenceCallable;
-    readonly toJsonValueFunction: ReferenceCallable;
-    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
+    readonly toJsonObjectFunction: BuiltinCallable;
+    readonly toJsonValueFunction: BuiltinCallable;
+    readonly valueSparqlWherePatternsFunction: BuiltinCallable;
     constructor({ languageIn, ...superParameters }: {
         languageIn: readonly string[];
     } & ConstructorParameters<typeof AbstractLiteralType>[0]);
     get discriminatedType(): Maybe<AbstractLiteralType.DiscriminatedType>;
     get graphqlType(): AbstractLiteralType.GraphqlType;
-    protected get schemaInitializers(): readonly Code[];
+    get schema(): SchemaObject<SchemaObject.BuiltinType>;
     graphqlResolveExpression(_parameters: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     toLoggableExpression({ variables, }: Parameters<AbstractLiteralType["toLoggableExpression"]>[0]): Code;
     valueExpression(literal: Literal): Code;

package/dist/generators/ts/LiteralType.js

@@ -7,7 +7,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class LiteralType extends AbstractLiteralType {
     languageIn;
@@ -29,20 +30,19 @@ export class LiteralType extends AbstractLiteralType {
             },
         ],
     });
-    filterFunction = new ReferenceCallable(this.reusables.snippets.filterLiteral);
+    filterFunction = new BuiltinCallable(this.reusables.snippets.filterLiteral);
     filterType = code `${this.reusables.snippets.LiteralFilter}`;
-    fromJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.literalFromJsonObject);
+    fromJsonObjectFunction = new BuiltinCallable(this.reusables.snippets.literalFromJsonObject);
     fromJsonValueFunction = this.fromJsonObjectFunction;
-    fromRdfResourceValuesFunction = new ReferenceCallable(this.reusables.snippets.literalFromRdfResourceValues);
+    fromRdfResourceValuesFunction = new BuiltinCallable(this.reusables.snippets.literalFromRdfResourceValues);
     jsTypes = [
         { instanceof: "Object", typeof: "object" },
     ];
     jsonValueType = this.jsonObjectType;
     kind = "Literal";
-    schemaType = code `${this.reusables.snippets.LiteralSchema}`;
-    toJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.literalToJsonObject);
+    toJsonObjectFunction = new BuiltinCallable(this.reusables.snippets.literalToJsonObject);
     toJsonValueFunction = this.toJsonObjectFunction;
-    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.literalSparqlWherePatterns);
+    valueSparqlWherePatternsFunction = new BuiltinCallable(this.reusables.snippets.literalSparqlWherePatterns);
     constructor({ languageIn, ...superParameters }) {
         super(superParameters);
         this.languageIn = languageIn;
@@ -60,12 +60,17 @@ export class LiteralType extends AbstractLiteralType {
     get graphqlType() {
         throw new Error("not implemented");
     }
-    get schemaInitializers() {
-        let initializers = super.schemaInitializers;
-        if (this.languageIn.length > 0) {
-            initializers = initializers.concat(code `languageIn: ${arrayOf(...this.languageIn)}`);
-        }
-        return initializers;
+    get schema() {
+        return new SchemaObject({
+            properties: this.languageIn.length > 0
+                ? {
+                    ...super.schema.properties,
+                    languageIn: code `languageIn: ${arrayOf(...this.languageIn)}`,
+                }
+                : super.schema.properties,
+            type: new SchemaObject.BuiltinType(this.reusables.snippets.LiteralSchema),
+            variable: super.schema.variable,
+        });
     }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
@@ -80,4 +85,7 @@ export class LiteralType extends AbstractLiteralType {
 __decorate([
     Memoize()
 ], LiteralType.prototype, "discriminatedType", null);
+__decorate([
+    Memoize()
+], LiteralType.prototype, "schema", null);
 //# sourceMappingURL=LiteralType.js.map