@shaclmate/compiler 4.0.48 → 4.0.50

package/dist/generators/ts/BigIntType.js

@@ -1,56 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,143 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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