@shaclmate/compiler 4.0.98 → 4.0.99

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

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

@@ -10,22 +10,21 @@ import { ObjectType_IdentifierProperty } from "./_ObjectType/ObjectType_Identifi
 import type { ObjectType_Property } from "./_ObjectType/ObjectType_Property.js";
 import { ObjectType_RdfTypeProperty } from "./_ObjectType/ObjectType_RdfTypeProperty.js";
 import { ObjectType_ShaclProperty } from "./_ObjectType/ObjectType_ShaclProperty.js";
-import { ObjectType_schemaExpression } from "./_ObjectType/ObjectType_schemaExpression.js";
-import { ObjectType_schemaTypeExpression } from "./_ObjectType/ObjectType_schemaTypeExpression.js";
 import { ObjectType_toJsonObjectFunctionExpression, ObjectType_toJsonObjectFunctionType } from "./_ObjectType/ObjectType_toJsonObjectFunction.js";
 import { ObjectType_toLoggableFunctionExpression, ObjectType_toLoggableFunctionType } from "./_ObjectType/ObjectType_toLoggableFunction.js";
 import { ObjectType_toRdfResourceValuesFunctionExpression, ObjectType_toRdfResourceValuesFunctionType } from "./_ObjectType/ObjectType_toRdfResourceValuesFunction.js";
 import { ObjectType_toStringFunctionExpression, ObjectType_toStringFunctionType } from "./_ObjectType/ObjectType_toStringFunction.js";
 import { ObjectType_valueSparqlConstructTriplesFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlConstructTriplesFunction.js";
 import { ObjectType_valueSparqlWherePatternsFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlWherePatternsFunction.js";
-import { AbstractStructuredType } from "./AbstractStructuredType.js";
+import { AbstractUserDefinedType } from "./AbstractUserDefinedType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { Callable } from "./Callable.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
+import { SchemaObject } from "./SchemaObject.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare class ObjectType extends AbstractStructuredType {
+export declare class ObjectType extends AbstractUserDefinedType {
     private readonly rdfTypeProperty;
     protected equalsFunctionExpression: typeof ObjectType_equalsFunctionExpression;
     protected equalsFunctionType: typeof ObjectType_equalsFunctionType;
@@ -38,8 +37,6 @@ export declare class ObjectType extends AbstractStructuredType {
     protected fromRdfResourceValuesFunctionType: typeof ObjectType_fromRdfResourceValuesFunctionType;
     protected hashFunctionExpression: typeof ObjectType_hashFunctionExpression;
     protected hashFunctionType: typeof ObjectType_hashFunctionType;
-    protected schemaExpression: typeof ObjectType_schemaExpression;
-    protected schemaTypeExpression: typeof ObjectType_schemaTypeExpression;
     protected toJsonObjectFunctionExpression: typeof ObjectType_toJsonObjectFunctionExpression;
     protected toJsonObjectFunctionType: typeof ObjectType_toJsonObjectFunctionType;
     protected toLoggableFunctionExpression: typeof ObjectType_toLoggableFunctionExpression;
@@ -50,9 +47,9 @@ export declare class ObjectType extends AbstractStructuredType {
     protected toStringFunctionType: typeof ObjectType_toStringFunctionType;
     protected valueSparqlConstructTriplesFunctionExpression: typeof ObjectType_valueSparqlConstructTriplesFunctionExpression;
     protected valueSparqlWherePatternsFunctionExpression: typeof ObjectType_valueSparqlWherePatternsFunctionExpression;
-    readonly discriminatedType: Maybe<AbstractStructuredType.DiscriminatedType>;
+    readonly discriminatedType: Maybe<AbstractUserDefinedType.DiscriminatedType>;
     readonly extern: boolean;
-    readonly graphqlArgs: AbstractStructuredType["graphqlArgs"];
+    readonly graphqlArgs: AbstractUserDefinedType["graphqlArgs"];
     readonly identifierProperty: Maybe<ObjectType.IdentifierProperty>;
     readonly identifierType: BlankNodeType | IdentifierType | IriType;
     readonly jsTypes: readonly [{
@@ -62,7 +59,7 @@ export declare class ObjectType extends AbstractStructuredType {
     readonly kind = "Object";
     readonly recursive: boolean;
     readonly synthetic: boolean;
-    readonly validationFunction: AbstractStructuredType["validationFunction"];
+    readonly validationFunction: AbstractUserDefinedType["validationFunction"];
     constructor({ discriminantProperty, extern, identifierProperty, identifierType, lazyProperties, rdfTypeProperty, recursive, synthetic, ...superParameters }: {
         discriminantProperty: Maybe<ObjectType.DiscriminantProperty>;
         comment: Maybe<string>;
@@ -74,21 +71,22 @@ export declare class ObjectType extends AbstractStructuredType {
         rdfTypeProperty: Maybe<ObjectType.RdfTypeProperty>;
         recursive: boolean;
         synthetic: boolean;
-    } & ConstructorParameters<typeof AbstractStructuredType>[0]);
+    } & ConstructorParameters<typeof AbstractUserDefinedType>[0]);
     get _fromRdfResourceFunction(): Callable;
     get _toRdfResourceFunction(): Callable;
-    get jsonValueType(): AbstractStructuredType["jsonObjectType"];
-    get conversionFunction(): Maybe<AbstractStructuredType.ConversionFunction>;
+    get jsonValueType(): AbstractUserDefinedType["jsonObjectType"];
+    get conversionFunction(): Maybe<AbstractUserDefinedType.ConversionFunction>;
     get createFunction(): Callable;
     get createFunctionParameters(): ObjectType.CreateFunctionParameters;
     get createUnsafeFunction(): Callable;
     get declaration(): Maybe<Code>;
-    get jsonObjectType(): AbstractStructuredType["jsonObjectType"];
+    get jsonObjectType(): AbstractUserDefinedType["jsonObjectType"];
+    get schema(): SchemaObject<SchemaObject.UserDefinedType>;
     get focusSparqlConstructTriplesFunction(): Callable;
     get focusSparqlWherePatternsFunction(): Callable;
     get fromRdfResourceFunction(): Callable;
     get fromRdfTypeVariable(): Maybe<Code>;
-    get graphqlType(): AbstractStructuredType.GraphqlType;
+    get graphqlType(): AbstractUserDefinedType.GraphqlType;
     get identifierTypeAlias(): Code;
     get mutable(): boolean;
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
@@ -97,7 +95,7 @@ export declare class ObjectType extends AbstractStructuredType {
     get sparqlConstructQueryFunction(): Callable;
     get sparqlConstructQueryStringFunction(): Callable;
     get toRdfResourceFunction(): Callable;
-    get toRdfResourceValueTypes(): AbstractStructuredType["toRdfResourceValueTypes"];
+    get toRdfResourceValueTypes(): AbstractUserDefinedType["toRdfResourceValueTypes"];
     get toRdfjsResourceType(): Code;
     get toStringRecordFunction(): Callable;
     get typeGuardFunction(): Maybe<Callable>;

package/dist/generators/ts/ObjectType.js

@@ -28,11 +28,10 @@ import { ObjectType_graphqlTypeExpression } from "./_ObjectType/ObjectType_graph
 import { ObjectType_hashFunctionExpression, ObjectType_hashFunctionType, } from "./_ObjectType/ObjectType_hashFunction.js";
 import { ObjectType_IdentifierProperty } from "./_ObjectType/ObjectType_IdentifierProperty.js";
 import { ObjectType_identifierTypeDeclarations } from "./_ObjectType/ObjectType_identifierTypeDeclarations.js";
+import { ObjectType_jsonObjectType } from "./_ObjectType/ObjectType_jsonObjectType.js";
 import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
 import { ObjectType_RdfTypeProperty } from "./_ObjectType/ObjectType_RdfTypeProperty.js";
 import { ObjectType_ShaclProperty } from "./_ObjectType/ObjectType_ShaclProperty.js";
-import { ObjectType_schemaExpression } from "./_ObjectType/ObjectType_schemaExpression.js";
-import { ObjectType_schemaTypeExpression } from "./_ObjectType/ObjectType_schemaTypeExpression.js";
 import { ObjectType_sparqlConstructQueryFunction } from "./_ObjectType/ObjectType_sparqlConstructQueryFunction.js";
 import { ObjectType_sparqlConstructQueryStringFunction } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunction.js";
 import { ObjectType_toJsonObjectFunctionExpression, ObjectType_toJsonObjectFunctionType, } from "./_ObjectType/ObjectType_toJsonObjectFunction.js";
@@ -44,10 +43,11 @@ import { ObjectType_toStringRecordFunction } from "./_ObjectType/ObjectType_toSt
 import { ObjectType_typeGuardFunction } from "./_ObjectType/ObjectType_typeGuardFunction.js";
 import { ObjectType_valueSparqlConstructTriplesFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlConstructTriplesFunction.js";
 import { ObjectType_valueSparqlWherePatternsFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlWherePatternsFunction.js";
-import { AbstractStructuredType } from "./AbstractStructuredType.js";
+import { AbstractUserDefinedType } from "./AbstractUserDefinedType.js";
 import { DeclaredCallable } from "./DeclaredCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
-export class ObjectType extends AbstractStructuredType {
+export class ObjectType extends AbstractUserDefinedType {
     rdfTypeProperty;
     equalsFunctionExpression = ObjectType_equalsFunctionExpression;
     equalsFunctionType = ObjectType_equalsFunctionType;
@@ -60,8 +60,6 @@ export class ObjectType extends AbstractStructuredType {
     fromRdfResourceValuesFunctionType = ObjectType_fromRdfResourceValuesFunctionType;
     hashFunctionExpression = ObjectType_hashFunctionExpression;
     hashFunctionType = ObjectType_hashFunctionType;
-    schemaExpression = ObjectType_schemaExpression;
-    schemaTypeExpression = ObjectType_schemaTypeExpression;
     toJsonObjectFunctionExpression = ObjectType_toJsonObjectFunctionExpression;
     toJsonObjectFunctionType = ObjectType_toJsonObjectFunctionType;
     toLoggableFunctionExpression = ObjectType_toLoggableFunctionExpression;
@@ -125,8 +123,30 @@ export class ObjectType extends AbstractStructuredType {
         return !this.extern ? super.declaration : Maybe.empty();
     }
     get jsonObjectType() {
-        return this.jsonTypeFactory.createJsonObjectType(this.properties.flatMap((property) => property.jsonObjectMember.toList()), {
-            name: this.name.map((name) => [name, "Json"]).extract(),
+        return ObjectType_jsonObjectType.call(this);
+    }
+    get schema() {
+        return new SchemaObject({
+            properties: {
+                ...super.schema.properties,
+                properties: () => code `properties: { ${joinCode(this.properties.flatMap((property) => property.schema
+                    .map((propertySchema) => [
+                    code `${property.name}: ${propertySchema.literalExpression}`,
+                ])
+                    .orDefault([])), { on: "," })} }`,
+            },
+            type: new SchemaObject.UserDefinedType({
+                members: {
+                    ...super.schema.type.members,
+                    properties: () => code `properties: { ${joinCode(this.properties.flatMap((property) => property.schema
+                        .map((propertySchema) => [
+                        code `${property.name}: ${propertySchema.type.literalExpression}`,
+                    ])
+                        .orDefault([])), { on: "," })} }`,
+                },
+                name: super.schema.type.name,
+            }),
+            variable: super.schema.variable,
         });
     }
     get focusSparqlConstructTriplesFunction() {
@@ -144,7 +164,7 @@ export class ObjectType extends AbstractStructuredType {
             .orDefaultLazy(() => this.rdfjsTermExpression(rdfTypeProperty.fromRdfType)));
     }
     get graphqlType() {
-        return new AbstractStructuredType.GraphqlType(this.name
+        return new AbstractUserDefinedType.GraphqlType(this.name
             .map((name) => code `${name}.GraphQL`)
             .orDefaultLazy(() => ObjectType_graphqlTypeExpression.call(this)), this.reusables);
     }
@@ -343,6 +363,9 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType.prototype, "jsonObjectType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "schema", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "focusSparqlConstructTriplesFunction", null);

package/dist/generators/ts/OptionType.d.ts

@@ -1,6 +1,7 @@
 import { Maybe } from "purify-ts";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import type { Callable } from "./Callable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends AbstractContainerType<ItemTypeT> {
     readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
@@ -21,7 +22,7 @@ export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends A
     get graphqlType(): AbstractContainerType.GraphqlType;
     get hashFunction(): Callable;
     get mutable(): boolean;
-    get schemaType(): Code;
+    get schema(): SchemaObject<SchemaObject.BuiltinType>;
     get toJsonValueFunction(): AbstractContainerType<ItemTypeT>["toJsonValueFunction"];
     get toJsonObjectFunction(): AbstractContainerType<ItemTypeT>["toJsonObjectFunction"];
     get toRdfResourceValueTypes(): AbstractContainerType<ItemTypeT>["toRdfResourceValueTypes"];