@shaclmate/compiler 4.0.50 → 4.0.52

package/dist/generators/ts/BigIntType.js

@@ -0,0 +1,56 @@
+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 { LiteralDecoder } from "@rdfx/literal";
+import { Memoize } from "typescript-memoize";
+import { AbstractNumericType } from "./AbstractNumericType.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+export class BigIntType extends AbstractNumericType {
+    jsTypes = [{ typeof: "bigint" }];
+    kind = "BigInt";
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.bigIntFromRdfResourceValues}<${this.expression}>`;
+    }
+    get graphqlType() {
+        return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLBigInt}`, this.reusables);
+    }
+    fromJsonExpression({ variables, }) {
+        let expression = code `BigInt(${variables.value})`;
+        if (this.primitiveIn.length > 0) {
+            expression = code `${expression} as ${this.expression}`;
+        }
+        return code `${this.reusables.imports.Either}.encase<Error, ${this.expression}>(() => ${expression})`;
+    }
+    jsonSchema(_parameters) {
+        switch (this.primitiveIn.length) {
+            case 0:
+                return code `${this.reusables.imports.z}.string()`;
+            case 1:
+                return code `${this.reusables.imports.z}.literal(${literalOf(this.primitiveIn[0].toString())})`;
+            default:
+                return code `${this.reusables.imports.z}.enum([${joinCode(this.primitiveIn.map((value) => code `${literalOf(value.toString())}`), { on: "," })}])`;
+        }
+    }
+    jsonType() {
+        return new AbstractNumericType.JsonType(code `string`);
+    }
+    literalValueExpression(literal) {
+        return code `${typeof literal === "bigint" ? literal : LiteralDecoder.decodeBigIntLiteral(literal).unsafeCoerce()}n`;
+    }
+    toJsonExpression({ variables, }) {
+        return code `${variables.value}.toString()`;
+    }
+}
+__decorate([
+    Memoize()
+], BigIntType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], BigIntType.prototype, "graphqlType", null);
+__decorate([
+    Memoize()
+], BigIntType.prototype, "jsonType", null);
+//# sourceMappingURL=BigIntType.js.map

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

@@ -0,0 +1,22 @@
+import type { BlankNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
+    protected readonly inlineExpression: Code;
+    readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
+    readonly filterFunction: Code;
+    readonly filterType: Code;
+    readonly fromRdfResourceValuesFunction: Code;
+    readonly kind = "BlankNode";
+    readonly nodeKinds: ReadonlySet<"BlankNode">;
+    readonly parseFunction: Code;
+    readonly schemaType: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
+    constructor(superParameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode>>[0], "hasValues" | "in_">);
+    fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<BlankNode>["fromJsonExpression"]>[0]): Code;
+    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<BlankNode>["jsonSchema"]>[0]): Code;
+    jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
+    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<BlankNode>["toJsonExpression"]>[0]): Code;
+}
+//# sourceMappingURL=BlankNodeType.d.ts.map

package/dist/generators/ts/BlankNodeType.js

@@ -0,0 +1,67 @@
+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 { code } from "./ts-poet-wrapper.js";
+export class BlankNodeType extends AbstractIdentifierType {
+    inlineExpression = code `${this.reusables.imports.BlankNode}`;
+    conversionFunction = Maybe.of({
+        code: code `${this.reusables.snippets.convertToBlankNode}`,
+        sourceTypes: [
+            {
+                expression: code `${this.reusables.imports.BlankNode}`,
+                jsType: this.jsTypes[0],
+            },
+            {
+                expression: code `undefined`,
+                jsType: { typeof: "undefined" },
+            },
+        ],
+    });
+    filterFunction = code `${this.reusables.snippets.filterBlankNode}`;
+    filterType = code `${this.reusables.snippets.BlankNodeFilter}`;
+    fromRdfResourceValuesFunction = code `${this.reusables.snippets.blankNodeFromRdfResourceValues}`;
+    kind = "BlankNode";
+    nodeKinds = nodeKinds;
+    parseFunction = code `${this.reusables.snippets.parseBlankNode};`;
+    schemaType = code `${this.reusables.snippets.BlankNodeSchema}`;
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.blankNodeSparqlWherePatterns}`;
+    constructor(superParameters) {
+        super({
+            ...superParameters,
+            hasValues: [],
+            in_: [],
+        });
+    }
+    fromJsonExpression({ variables, }) {
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)))`;
+    }
+    jsonSchema({ includeDiscriminantProperty, }) {
+        const discriminantProperty = includeDiscriminantProperty
+            ? code `, termType: ${this.reusables.imports.z}.literal("BlankNode")`
+            : "";
+        return code `${this.reusables.imports.z}.object({ "@id": ${this.reusables.imports.z}.string().min(1)${discriminantProperty} })`;
+    }
+    jsonType(parameters) {
+        const discriminantProperty = parameters?.includeDiscriminantProperty
+            ? `, readonly termType: "BlankNode"`
+            : "";
+        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+    }
+    toJsonExpression({ includeDiscriminantProperty, variables, }) {
+        const discriminantProperty = includeDiscriminantProperty
+            ? code `, termType: ${variables.value}.termType`
+            : "";
+        return code `{ "@id": \`_:\${${variables.value}.value}\`${discriminantProperty} }`;
+    }
+}
+__decorate([
+    Memoize()
+], BlankNodeType.prototype, "jsonType", null);
+const nodeKinds = new Set(["BlankNode"]);
+//# sourceMappingURL=BlankNodeType.js.map

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

@@ -0,0 +1,21 @@
+import type { Literal } from "@rdfjs/types";
+import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class BooleanType extends AbstractPrimitiveType<boolean> {
+    readonly filterFunction: Code;
+    readonly filterType: Code;
+    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
+    readonly hashFunction: Code;
+    readonly jsTypes: readonly [{
+        readonly typeof: "boolean";
+    }];
+    readonly kind = "Boolean";
+    readonly valueSparqlWherePatternsFunction: Code;
+    get fromRdfResourceValuesFunction(): Code;
+    get schemaType(): Code;
+    protected get inlineExpression(): Code;
+    jsonSchema(_parameters: Parameters<AbstractPrimitiveType<number>["jsonSchema"]>[0]): Code;
+    literalValueExpression(literal: boolean | Literal): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<boolean>["toRdfResourceValuesExpression"]>[0]): Code;
+}
+//# sourceMappingURL=BooleanType.d.ts.map

package/dist/generators/ts/BooleanType.js

@@ -0,0 +1,53 @@
+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 { LiteralDecoder } from "@rdfx/literal";
+import { Memoize } from "typescript-memoize";
+import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { code } from "./ts-poet-wrapper.js";
+export class BooleanType extends AbstractPrimitiveType {
+    filterFunction = code `${this.reusables.snippets.filterBoolean}`;
+    filterType = code `${this.reusables.snippets.BooleanFilter}`;
+    graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLBoolean}`, this.reusables);
+    hashFunction = code `${this.reusables.snippets.hashBoolean}`;
+    jsTypes = [{ typeof: "boolean" }];
+    kind = "Boolean";
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.booleanSparqlWherePatterns}`;
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.booleanFromRdfResourceValues}<${this.expression}>`;
+    }
+    get schemaType() {
+        return code `${this.reusables.snippets.BooleanSchema}<${this.expression}>`;
+    }
+    get inlineExpression() {
+        if (this.primitiveIn.length > 0) {
+            return code `${this.primitiveIn.map((value) => value.toString()).join(" | ")}`;
+        }
+        return code `boolean`;
+    }
+    jsonSchema(_parameters) {
+        if (this.primitiveIn.length === 1) {
+            return code `${this.reusables.imports.z}.literal(${this.primitiveIn[0]})`;
+        }
+        return code `${this.reusables.imports.z}.boolean()`;
+    }
+    literalValueExpression(literal) {
+        return code `${typeof literal === "boolean" ? literal : LiteralDecoder.decodeBooleanLiteral(literal).unsafeCoerce()}`;
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        return code `[${this.reusables.snippets.literalFactory}.boolean(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
+    }
+}
+__decorate([
+    Memoize()
+], BooleanType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], BooleanType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], BooleanType.prototype, "inlineExpression", null);
+//# sourceMappingURL=BooleanType.js.map

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

@@ -0,0 +1,13 @@
+import type { Literal } from "@rdfjs/types";
+import { AbstractDateType } from "./AbstractDateType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class DateTimeType extends AbstractDateType {
+    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
+    readonly hashFunction: Code;
+    readonly kind = "DateTime";
+    get fromRdfResourceValuesFunction(): Code;
+    jsonSchema(_parameters: Parameters<AbstractDateType["jsonSchema"]>[0]): Code;
+    literalValueExpression(literal: Date | Literal): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
+}
+//# sourceMappingURL=DateTimeType.d.ts.map

package/dist/generators/ts/DateTimeType.js

@@ -0,0 +1,31 @@
+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 { LiteralDecoder } from "@rdfx/literal";
+import { Memoize } from "typescript-memoize";
+import { AbstractDateType } from "./AbstractDateType.js";
+import { code } from "./ts-poet-wrapper.js";
+export class DateTimeType extends AbstractDateType {
+    graphqlType = new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDateTime}`, this.reusables);
+    hashFunction = code `${this.reusables.snippets.hashDateTime}`;
+    kind = "DateTime";
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.dateTimeFromRdfResourceValues}`;
+    }
+    jsonSchema(_parameters) {
+        return code `${this.reusables.imports.z}.iso.datetime()`;
+    }
+    literalValueExpression(literal) {
+        return code `new Date("${(literal instanceof Date ? literal : LiteralDecoder.decodeDateTimeLiteral(literal).unsafeCoerce()).toISOString()}")`;
+    }
+    toJsonExpression({ variables, }) {
+        return code `${variables.value}.toISOString()`;
+    }
+}
+__decorate([
+    Memoize()
+], DateTimeType.prototype, "fromRdfResourceValuesFunction", null);
+//# sourceMappingURL=DateTimeType.js.map

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

@@ -0,0 +1,14 @@
+import type { Literal } from "@rdfjs/types";
+import { AbstractDateType } from "./AbstractDateType.js";
+import { DateTimeType } from "./DateTimeType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class DateType extends AbstractDateType {
+    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
+    readonly hashFunction: Code;
+    readonly kind = "Date";
+    get fromRdfResourceValuesFunction(): Code;
+    jsonSchema(_parameters: Parameters<DateTimeType["jsonSchema"]>[0]): Code;
+    literalValueExpression(literal: Date | Literal): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
+}
+//# sourceMappingURL=DateType.d.ts.map

package/dist/generators/ts/DateType.js

@@ -0,0 +1,32 @@
+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 { LiteralDecoder } from "@rdfx/literal";
+import { Memoize } from "typescript-memoize";
+import { AbstractDateType } from "./AbstractDateType.js";
+import { DateTimeType } from "./DateTimeType.js";
+import { code } from "./ts-poet-wrapper.js";
+export class DateType extends AbstractDateType {
+    graphqlType = new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDate}`, this.reusables);
+    hashFunction = code `${this.reusables.snippets.hashDate}`;
+    kind = "Date";
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.dateFromRdfResourceValues}`;
+    }
+    jsonSchema(_parameters) {
+        return code `${this.reusables.imports.z}.iso.date()`;
+    }
+    literalValueExpression(literal) {
+        return code `new Date("${(literal instanceof Date ? literal : LiteralDecoder.decodeDateLiteral(literal).unsafeCoerce()).toISOString()}")`;
+    }
+    toJsonExpression({ variables, }) {
+        return code `${this.reusables.snippets.toIsoDateString}(${variables.value})`;
+    }
+}
+__decorate([
+    Memoize()
+], DateType.prototype, "fromRdfResourceValuesFunction", null);
+//# sourceMappingURL=DateType.js.map

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

@@ -0,0 +1,83 @@
+import type { Literal, NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { AbstractContainerType } from "./AbstractContainerType.js";
+import type { AbstractType } from "./AbstractType.js";
+import type { BlankNodeType } from "./BlankNodeType.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> {
+    readonly defaultValue: Literal | NamedNode;
+    readonly discriminantProperty: Maybe<AbstractType.DiscriminantProperty>;
+    readonly graphqlArgs: AbstractType["graphqlArgs"];
+    readonly jsTypes: readonly AbstractType.JsType[] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }] | {
+        readonly typeof: "bigint";
+    }[] | readonly [{
+        readonly typeof: "boolean";
+    }] | readonly [{
+        readonly instanceof: "Date";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly instanceof: "Date";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly typeof: "number";
+    }] | readonly [{
+        readonly typeof: "number";
+    }] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly typeof: "string";
+    }] | readonly [{
+        readonly instanceof: "Array";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }];
+    readonly kind = "DefaultValue";
+    readonly validationFunction: Maybe<Code>;
+    constructor({ defaultValue, ...superParameters }: {
+        defaultValue: Literal | NamedNode;
+    } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
+    get conversionFunction(): Maybe<AbstractContainerType.ConversionFunction>;
+    get equalsFunction(): Code;
+    get expression(): Code;
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get fromRdfResourceValuesFunction(): Code;
+    get graphqlType(): AbstractContainerType.GraphqlType;
+    get hashFunction(): Code;
+    get mutable(): boolean;
+    get schemaType(): Code;
+    get toRdfResourceValueTypes(): AbstractContainerType<ItemTypeT>["toRdfResourceValueTypes"];
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
+    protected get schemaInitializers(): Code[];
+    private get defaultValueExpression();
+    fromJsonExpression(parameters: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
+    graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
+    jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
+    jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractType.JsonType;
+    jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    toJsonExpression(parameters: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
+    toRdfResourceValuesExpression(parameters: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression(parameters: Parameters<AbstractType["toStringExpression"]>[0]): Code;
+}
+export declare namespace DefaultValueType {
+    type ItemType = Exclude<AbstractContainerType.ItemType, BlankNodeType>;
+    function isItemType(type: Type): type is ItemType;
+}
+//# sourceMappingURL=DefaultValueType.d.ts.map

package/dist/generators/ts/DefaultValueType.js

@@ -0,0 +1,143 @@
+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 { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractContainerType } from "./AbstractContainerType.js";
+import { code } from "./ts-poet-wrapper.js";
+export class DefaultValueType extends AbstractContainerType {
+    defaultValue;
+    discriminantProperty = Maybe.empty();
+    graphqlArgs = Maybe.empty();
+    jsTypes = this.itemType.jsTypes;
+    kind = "DefaultValue";
+    validationFunction = this.itemType.validationFunction;
+    constructor({ defaultValue, ...superParameters }) {
+        super(superParameters);
+        this.defaultValue = defaultValue;
+    }
+    get conversionFunction() {
+        const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertWithDefaultValue}(${itemConversionFunction.code}, ${this.defaultValueExpression})`,
+            sourceTypes: itemConversionFunction.sourceTypes
+                .filter((sourceType) => sourceType.jsType.typeof !== "undefined")
+                .concat({
+                expression: code `undefined`,
+                jsType: { typeof: "undefined" },
+            }),
+        });
+    }
+    get equalsFunction() {
+        return this.itemType.equalsFunction;
+    }
+    get expression() {
+        return this.itemType.expression;
+    }
+    get filterFunction() {
+        return this.itemType.filterFunction;
+    }
+    get filterType() {
+        return this.itemType.filterType;
+    }
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.defaultValueFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction})`;
+    }
+    get graphqlType() {
+        return this.itemType.graphqlType;
+    }
+    get hashFunction() {
+        return this.itemType.hashFunction;
+    }
+    get mutable() {
+        return this.itemType.mutable;
+    }
+    get schemaType() {
+        return code `${this.reusables.snippets.DefaultValueSchema}<${this.itemType.schemaType}>`;
+    }
+    get toRdfResourceValueTypes() {
+        return this.itemType.toRdfResourceValueTypes;
+    }
+    get valueSparqlConstructTriplesFunction() {
+        return this.itemType.valueSparqlConstructTriplesFunction;
+    }
+    get valueSparqlWherePatternsFunction() {
+        return code `${this.reusables.snippets.defaultValueSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
+    }
+    get schemaInitializers() {
+        return super.schemaInitializers.concat(code `defaultValue: ${this.rdfjsTermExpression(this.defaultValue)}`);
+    }
+    get defaultValueExpression() {
+        switch (this.itemType.kind) {
+            case "Identifier":
+            case "Iri":
+            case "Literal":
+            case "Term":
+                return this.rdfjsTermExpression(this.defaultValue);
+            case "List":
+            case "Object":
+            case "ObjectUnion":
+            case "Union":
+                throw new RangeError(`not implemented ${this.itemType.kind}`);
+        }
+        invariant(this.defaultValue.termType === "Literal");
+        return this.itemType.literalValueExpression(this.defaultValue);
+    }
+    fromJsonExpression(parameters) {
+        return this.itemType.fromJsonExpression(parameters);
+    }
+    graphqlResolveExpression(parameters) {
+        return this.itemType.graphqlResolveExpression(parameters);
+    }
+    jsonSchema(parameters) {
+        return this.itemType.jsonSchema(parameters);
+    }
+    jsonType(parameters) {
+        return this.itemType.jsonType(parameters);
+    }
+    jsonUiSchemaElement(parameters) {
+        return this.itemType.jsonUiSchemaElement(parameters);
+    }
+    toJsonExpression(parameters) {
+        return this.itemType.toJsonExpression(parameters);
+    }
+    toRdfResourceValuesExpression(parameters) {
+        const { variables } = parameters;
+        return code `${this.itemType.equalsFunction}(${variables.value}, ${this.defaultValueExpression}).isLeft() ? ${this.itemType.toRdfResourceValuesExpression(parameters)} : []`;
+    }
+    toStringExpression(parameters) {
+        return this.itemType.toStringExpression(parameters);
+    }
+}
+__decorate([
+    Memoize()
+], DefaultValueType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], DefaultValueType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], DefaultValueType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], DefaultValueType.prototype, "valueSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], DefaultValueType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], DefaultValueType.prototype, "defaultValueExpression", null);
+(function (DefaultValueType) {
+    function isItemType(type) {
+        if (type.kind === "BlankNode") {
+            return false;
+        }
+        return AbstractContainerType.isItemType(type);
+    }
+    DefaultValueType.isItemType = isItemType;
+})(DefaultValueType || (DefaultValueType = {}));
+//# sourceMappingURL=DefaultValueType.js.map

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

@@ -0,0 +1,13 @@
+import type { Literal } from "@rdfjs/types";
+import { AbstractNumericType } from "./AbstractNumericType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class FloatType extends AbstractNumericType<number> {
+    readonly jsTypes: readonly [{
+        readonly typeof: "number";
+    }];
+    readonly kind = "Float";
+    get fromRdfResourceValuesFunction(): Code;
+    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
+    literalValueExpression(literal: Literal | number): Code;
+}
+//# sourceMappingURL=FloatType.d.ts.map

package/dist/generators/ts/FloatType.js

@@ -0,0 +1,30 @@
+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 { LiteralDecoder } from "@rdfx/literal";
+import { Memoize } from "typescript-memoize";
+import { AbstractNumericType } from "./AbstractNumericType.js";
+import { code } from "./ts-poet-wrapper.js";
+export class FloatType extends AbstractNumericType {
+    jsTypes = [{ typeof: "number" }];
+    kind = "Float";
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.floatFromRdfResourceValues}<${this.expression}>`;
+    }
+    get graphqlType() {
+        return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLFloat}`, this.reusables);
+    }
+    literalValueExpression(literal) {
+        return code `${typeof literal === "number" ? literal : LiteralDecoder.decodeFloatLiteral(literal).unsafeCoerce()}`;
+    }
+}
+__decorate([
+    Memoize()
+], FloatType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], FloatType.prototype, "graphqlType", null);
+//# sourceMappingURL=FloatType.js.map

package/dist/generators/ts/GraphqlSchema.d.ts

@@ -0,0 +1,22 @@
+import type { Logger } from "ts-log";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { Reusables } from "./Reusables.js";
+import type { TsGenerator } from "./TsGenerator.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class GraphqlSchema {
+    private readonly configuration;
+    private readonly reusables;
+    private readonly namedObjectTypes;
+    private readonly namedObjectUnionTypes;
+    constructor({ configuration, namedObjectTypes, namedObjectUnionTypes, reusables, }: {
+        configuration: TsGenerator.Configuration;
+        logger: Logger;
+        namedObjectTypes: readonly ObjectType[];
+        namedObjectUnionTypes: readonly ObjectUnionType[];
+        reusables: Reusables;
+    });
+    get declaration(): Code;
+    private get graphqlQueryObjectType();
+}
+//# sourceMappingURL=GraphqlSchema.d.ts.map