@shaclmate/compiler 4.0.48 → 4.0.50

package/dist/generators/ts/LazySetType.js

@@ -1,76 +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 { AbstractLazyType } from "./AbstractLazyType.js";
-import { code } from "./ts-poet-wrapper.js";
-export class LazySetType extends AbstractLazyType {
-    graphqlArgs = Maybe.of({
-        limit: {
-            type: code `${this.reusables.imports.GraphQLInt}`,
-        },
-        offset: {
-            type: code `${this.reusables.imports.GraphQLInt}`,
-        },
-    });
-    kind = "LazySet";
-    get conversionFunction() {
-        invariant(this.jsTypes.length === 1);
-        invariant(this.resolveType.jsTypes.length === 1);
-        return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazySet}<${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
-            sourceTypes: [
-                {
-                    expression: this.expression,
-                    jsType: this.jsTypes[0],
-                },
-                {
-                    expression: this.resolveType.expression,
-                    jsType: this.resolveType.jsTypes[0],
-                },
-                {
-                    expression: code `undefined`,
-                    jsType: { typeof: "undefined" },
-                },
-            ],
-        });
-    }
-    get runtimeClass() {
-        return {
-            name: code `${this.reusables.snippets.LazySet}<${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
-            partialPropertyName: "partials",
-            rawName: code `${this.reusables.snippets.LazySet}`,
-        };
-    }
-    fromJsonExpression(parameters) {
-        return code `${this.partialType.fromJsonExpression(parameters)}.map(partials => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: partials, resolver: () => Promise.resolve(${this.reusables.imports.Left}(new Error("unable to resolve partials deserialized from JSON"))) }))`;
-    }
-    get fromRdfResourceValuesFunction() {
-        return code `\
-(
-    (
-      (values, { objectSet, schema, ...otherOptions }) =>
-        ${this.partialType.fromRdfResourceValuesFunction}(values, { ...otherOptions, objectSet, schema: schema.partialType })
-          .map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (partials, options) => objectSet.${this.resolveType.itemType.objectSetMethodNames.objects}({ identifiers: partials.map(partial => partial.${this.configuration.syntheticNamePrefix}identifier()), ...options }) })))
-    ) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>
-)`;
-    }
-    graphqlResolveExpression({ variables, }) {
-        return code `(${variables.value}.resolve({ limit: ${variables.args}.limit, offset: ${variables.args}.offset })).then(either => either.unsafeCoerce())`;
-    }
-}
-__decorate([
-    Memoize()
-], LazySetType.prototype, "conversionFunction", null);
-__decorate([
-    Memoize()
-], LazySetType.prototype, "runtimeClass", null);
-__decorate([
-    Memoize()
-], LazySetType.prototype, "fromRdfResourceValuesFunction", null);
-//# sourceMappingURL=LazySetType.js.map

package/dist/generators/ts/LazyType.d.ts

@@ -1,19 +0,0 @@
-import { Maybe } from "purify-ts";
-import { AbstractLazyType } from "./AbstractLazyType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class LazyType extends AbstractLazyType<AbstractLazyType.ItemTypeConstraint, AbstractLazyType.ItemTypeConstraint> {
-    readonly graphqlArgs: Super["graphqlArgs"];
-    readonly kind = "Lazy";
-    get conversionFunction(): Maybe<AbstractLazyType.ConversionFunction>;
-    protected get runtimeClass(): {
-        name: Code;
-        partialPropertyName: string;
-        rawName: Code;
-    };
-    fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
-    get fromRdfResourceValuesFunction(): Code;
-    graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
-}
-type Super = AbstractLazyType<AbstractLazyType.ItemTypeConstraint, AbstractLazyType.ItemTypeConstraint>;
-export {};
-//# sourceMappingURL=LazyType.d.ts.map

package/dist/generators/ts/LazyType.js

@@ -1,65 +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 { AbstractLazyType } from "./AbstractLazyType.js";
-import { code } from "./ts-poet-wrapper.js";
-export class LazyType extends AbstractLazyType {
-    graphqlArgs = Maybe.empty();
-    kind = "Lazy";
-    get conversionFunction() {
-        invariant(this.jsTypes.length === 1);
-        invariant(this.resolveType.jsTypes.length === 1);
-        return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazy}<${this.partialType.expression}, ${this.resolveType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType, resolveType: this.resolveType })})`,
-            sourceTypes: [
-                {
-                    expression: this.expression,
-                    jsType: this.jsTypes[0],
-                },
-                {
-                    expression: this.resolveType.expression,
-                    jsType: this.resolveType.jsTypes[0],
-                },
-            ],
-        });
-    }
-    get runtimeClass() {
-        return {
-            name: code `${this.reusables.snippets.Lazy}<${this.partialType.expression}, ${this.resolveType.expression}>`,
-            partialPropertyName: "partial",
-            rawName: code `${this.reusables.snippets.Lazy}`,
-        };
-    }
-    fromJsonExpression(parameters) {
-        return code `${this.partialType.fromJsonExpression(parameters)}.map(partial => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: partial, resolver: (partial) => Promise.resolve(${this.reusables.imports.Left}(new Error(\`unable to resolve \${partial} deserialized from JSON\`))) }))`;
-    }
-    get fromRdfResourceValuesFunction() {
-        return code `\
-(
-    (
-      (values, { objectSet, schema, ...otherOptions }) =>
-        ${this.partialType.fromRdfResourceValuesFunction}(values, { ...otherOptions, objectSet, schema: schema.partialType })
-          .map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (partial, options) => objectSet.${this.resolveType.objectSetMethodNames.object}(partial.${this.configuration.syntheticNamePrefix}identifier(), options) })))
-    ) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>
-)`;
-    }
-    graphqlResolveExpression({ variables, }) {
-        return code `${variables.value}.resolve().then(either => either.unsafeCoerce())`;
-    }
-}
-__decorate([
-    Memoize()
-], LazyType.prototype, "conversionFunction", null);
-__decorate([
-    Memoize()
-], LazyType.prototype, "runtimeClass", null);
-__decorate([
-    Memoize()
-], LazyType.prototype, "fromRdfResourceValuesFunction", null);
-//# sourceMappingURL=LazyType.js.map

package/dist/generators/ts/ListType.d.ts

@@ -1,49 +0,0 @@
-import type { NamedNode } from "@rdfjs/types";
-import { Maybe } from "purify-ts";
-import { AbstractCollectionType } from "./AbstractCollectionType.js";
-import type { BigDecimalType } from "./BigDecimalType.js";
-import type { BigIntType } from "./BigIntType.js";
-import type { BlankNodeType } from "./BlankNodeType.js";
-import type { BooleanType } from "./BooleanType.js";
-import type { DateTimeType } from "./DateTimeType.js";
-import type { DateType } from "./DateType.js";
-import type { FloatType } from "./FloatType.js";
-import type { IdentifierType } from "./IdentifierType.js";
-import type { IntType } from "./IntType.js";
-import type { IriType } from "./IriType.js";
-import type { LiteralType } from "./LiteralType.js";
-import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
-import type { StringType } from "./StringType.js";
-import type { TermType } from "./TermType.js";
-import type { Type } from "./Type.js";
-import { type Code } from "./ts-poet-wrapper.js";
-import type { UnionType } from "./UnionType.js";
-export declare class ListType<ItemTypeT extends ListType.ItemType> extends AbstractCollectionType<ItemTypeT> {
-    private readonly identifierNodeKind;
-    private readonly toRdfTypes;
-    readonly jsTypes: readonly [{
-        readonly instanceof: "Array";
-        readonly typeof: "object";
-    }];
-    readonly kind = "List";
-    constructor({ identifierNodeKind, toRdfTypes, ...superParameters }: {
-        identifierNodeKind: ListType<ItemTypeT>["identifierNodeKind"];
-        toRdfTypes: readonly NamedNode[];
-    } & ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0]);
-    get conversionFunction(): Maybe<AbstractCollectionType.ConversionFunction>;
-    get fromRdfResourceValuesFunction(): Code;
-    get toRdfResourceValueTypes(): AbstractCollectionType<ItemTypeT>["toRdfResourceValueTypes"];
-    get valueSparqlConstructTriplesFunction(): Code;
-    get valueSparqlWherePatternsFunction(): Code;
-    fromJsonExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
-    jsonSchema(parameters: Parameters<AbstractCollectionType<ItemTypeT>["jsonSchema"]>[0]): Code;
-    jsonType(): AbstractCollectionType.JsonType;
-    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
-    toStringExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toStringExpression"]>[0]): Code;
-}
-export declare namespace ListType {
-    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | ListType<ListType.ItemType> | LiteralType | ObjectUnionType | ObjectType | StringType | TermType | UnionType<Type>;
-    function isItemType(type: Type): type is ItemType;
-}
-//# sourceMappingURL=ListType.d.ts.map

package/dist/generators/ts/ListType.js

@@ -1,161 +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 { rdf } from "@tpluscode/rdf-ns-builders";
-import { Maybe } from "purify-ts";
-import { Memoize } from "typescript-memoize";
-import { AbstractCollectionType } from "./AbstractCollectionType.js";
-import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
-export class ListType extends AbstractCollectionType {
-    identifierNodeKind;
-    toRdfTypes;
-    jsTypes = [
-        { instanceof: "Array", typeof: "object" },
-    ];
-    kind = "List";
-    constructor({ identifierNodeKind, toRdfTypes, ...superParameters }) {
-        super(superParameters);
-        this.identifierNodeKind = identifierNodeKind;
-        this.toRdfTypes = toRdfTypes;
-    }
-    get conversionFunction() {
-        const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
-        return Maybe.of({
-            code: code `${this.reusables.snippets.convertToList}(${itemConversionFunction.code}, ${literalOf(!this._mutable)})`,
-            sourceTypes: [
-                {
-                    expression: code `readonly (${joinCode(itemConversionFunction.sourceTypes.map((itemSourceType) => code `${itemSourceType.expression}`), { on: " | " })})[]`,
-                    jsType: { instanceof: "Array", typeof: "object" },
-                },
-            ],
-        });
-    }
-    get fromRdfResourceValuesFunction() {
-        return code `${this._mutable ? this.reusables.snippets.mutableListFromRdfResourceValues : this.reusables.snippets.listFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction})`;
-    }
-    get toRdfResourceValueTypes() {
-        return new Set(["BlankNode", "NamedNode"]); // List or rdf:nil
-    }
-    get valueSparqlConstructTriplesFunction() {
-        return code `${this.reusables.snippets.listSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
-    }
-    get valueSparqlWherePatternsFunction() {
-        return code `${this.reusables.snippets.listSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
-    }
-    fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.sequence<Error, ${this.itemType.expression}>(${variables.value}.map(item => (${this.itemType.fromJsonExpression({
-            variables: { value: code `item` },
-        })})))`;
-    }
-    jsonSchema(parameters) {
-        let schema = code `${this.itemType.jsonSchema(parameters)}.array()`;
-        if (!this._mutable) {
-            schema = code `${schema}.readonly()`;
-        }
-        return schema;
-    }
-    jsonType() {
-        return new AbstractCollectionType.JsonType(code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().expression})[]`);
-    }
-    toRdfResourceValuesExpression({ variables, }) {
-        let mintListIdentifierFunction;
-        let mintSubListIdentifierFunction;
-        let resourceTypeExpression;
-        switch (this.identifierNodeKind) {
-            case "BlankNode": {
-                mintListIdentifierFunction =
-                    mintSubListIdentifierFunction = code `(() => ${this.reusables.imports.dataFactory}.blankNode())`;
-                resourceTypeExpression = code `${this.reusables.imports.Resource}<${this.reusables.imports.BlankNode}>`;
-                break;
-            }
-            case "IRI": {
-                resourceTypeExpression = code `${this.reusables.imports.Resource}<${this.reusables.imports.NamedNode}>`;
-                throw new RangeError("list IRI minting is unsupported");
-            }
-        }
-        return code `[${variables.value}.length > 0 ? ${variables.value}.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
-    if (itemIndex === 0) {
-      currentSubListResource = listResource;
-    } else {
-      const newSubListResource = ${variables.resourceSet}.resource(${mintSubListIdentifierFunction}());
-      currentSubListResource!.add(${this.rdfjsTermExpression(rdf.rest)}, newSubListResource.identifier, ${variables.graph});
-      currentSubListResource = newSubListResource;
-    }
-    
-    ${joinCode(this.toRdfTypes.map((rdfType) => code `currentSubListResource.add(${this.rdfjsTermExpression(rdf.type)}, ${this.reusables.imports.dataFactory}.namedNode("${rdfType.value}"), ${variables.graph})`))}
-    
-    currentSubListResource.add(${this.rdfjsTermExpression(rdf.first)}, ${this.itemType.toRdfResourceValuesExpression({ variables: { graph: variables.graph, propertyPath: this.rdfjsTermExpression(rdf.first), resource: code `currentSubListResource`, resourceSet: variables.resourceSet, value: code `item` } })}, ${variables.graph});
-
-    if (itemIndex + 1 === list.length) {
-      currentSubListResource.add(${this.rdfjsTermExpression(rdf.rest)}, ${this.rdfjsTermExpression(rdf.nil)}, ${variables.graph});
-    }
-    
-    return { currentSubListResource, listResource };
-  },
-  {
-    currentSubListResource: null,
-    listResource: ${variables.resourceSet}.resource(${mintListIdentifierFunction}()),
-  } as {
-    currentSubListResource: ${resourceTypeExpression} | null;
-    listResource: ${resourceTypeExpression};
-  },
-).listResource.identifier : ${this.rdfjsTermExpression(rdf.nil)}]`;
-    }
-    toStringExpression({ variables, }) {
-        return code `\`[\${${variables.value}.map(item => (${this.itemType.toStringExpression({ variables: { value: code `item` } })}))}]\``;
-    }
-}
-__decorate([
-    Memoize()
-], ListType.prototype, "conversionFunction", null);
-__decorate([
-    Memoize()
-], ListType.prototype, "fromRdfResourceValuesFunction", null);
-__decorate([
-    Memoize()
-], ListType.prototype, "toRdfResourceValueTypes", null);
-__decorate([
-    Memoize()
-], ListType.prototype, "valueSparqlConstructTriplesFunction", null);
-__decorate([
-    Memoize()
-], ListType.prototype, "valueSparqlWherePatternsFunction", null);
-__decorate([
-    Memoize()
-], ListType.prototype, "jsonType", null);
-(function (ListType) {
-    function isItemType(type) {
-        switch (type.kind) {
-            case "BigDecimal":
-            case "BigInt":
-            case "BlankNode":
-            case "Boolean":
-            case "DateTime":
-            case "Date":
-            case "Float":
-            case "Identifier":
-            case "Iri":
-            case "Int":
-            case "List":
-            case "Literal":
-            case "ObjectUnion":
-            case "Object":
-            case "String":
-            case "Term":
-            case "Union":
-                return true;
-            case "DefaultValue":
-            case "LazyOption":
-            case "LazySet":
-            case "Lazy":
-            case "Option":
-            case "Set":
-                return false;
-        }
-    }
-    ListType.isItemType = isItemType;
-})(ListType || (ListType = {}));
-//# sourceMappingURL=ListType.js.map

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

@@ -1,27 +0,0 @@
-import type { Literal } from "@rdfjs/types";
-import { Maybe } from "purify-ts";
-import { AbstractLiteralType } from "./AbstractLiteralType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class LiteralType extends AbstractLiteralType {
-    protected readonly inlineExpression: Code;
-    readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
-    readonly filterFunction: Code;
-    readonly filterType: Code;
-    readonly fromRdfResourceValuesFunction: Code;
-    readonly jsTypes: readonly [{
-        readonly instanceof: "Object";
-        readonly typeof: "object";
-    }];
-    readonly kind = "Literal";
-    readonly schemaType: Code;
-    readonly valueSparqlWherePatternsFunction: Code;
-    get graphqlType(): AbstractLiteralType.GraphqlType;
-    protected get schemaInitializers(): readonly Code[];
-    fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
-    graphqlResolveExpression(_parameters: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
-    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractLiteralType["jsonSchema"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractLiteralType["jsonType"]>[0]): AbstractLiteralType.JsonType;
-    literalValueExpression(literal: Literal): Code;
-    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
-}
-//# sourceMappingURL=LiteralType.d.ts.map

package/dist/generators/ts/LiteralType.js

@@ -1,71 +0,0 @@
-import { xsd } from "@tpluscode/rdf-ns-builders";
-import { Maybe } from "purify-ts";
-import { AbstractLiteralType } from "./AbstractLiteralType.js";
-import { arrayOf, code } from "./ts-poet-wrapper.js";
-export class LiteralType extends AbstractLiteralType {
-    inlineExpression = code `${this.reusables.imports.Literal}`;
-    conversionFunction = Maybe.of({
-        code: code `${this.reusables.snippets.convertToLiteral}`,
-        sourceTypes: [
-            ...["bigint", "boolean", "number", "string"].map((typeof_) => ({
-                expression: code `${typeof_}`,
-                jsType: { typeof: typeof_ },
-            })),
-            {
-                expression: code `Date`,
-                jsType: { instanceof: "Date", typeof: "object" },
-            },
-            {
-                expression: code `${this.reusables.imports.Literal}`,
-                jsType: { instanceof: "Object", typeof: "object" },
-            },
-        ],
-    });
-    filterFunction = code `${this.reusables.snippets.filterLiteral}`;
-    filterType = code `${this.reusables.snippets.LiteralFilter}`;
-    fromRdfResourceValuesFunction = code `${this.reusables.snippets.literalFromRdfResourceValues}`;
-    jsTypes = [
-        { instanceof: "Object", typeof: "object" },
-    ];
-    kind = "Literal";
-    schemaType = code `${this.reusables.snippets.LiteralSchema}`;
-    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.literalSparqlWherePatterns}`;
-    get graphqlType() {
-        throw new Error("not implemented");
-    }
-    get schemaInitializers() {
-        let initializers = super.schemaInitializers;
-        if (this.in_.length > 0) {
-            initializers = initializers.concat(code `in: ${arrayOf(...this.in_.map((in_) => this.rdfjsTermExpression(in_)))}`);
-        }
-        if (this.languageIn.length > 0) {
-            initializers = initializers.concat(code `languageIn: ${arrayOf(...this.languageIn)}`);
-        }
-        return initializers;
-    }
-    fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${this.reusables.imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined)))`;
-    }
-    graphqlResolveExpression(_parameters) {
-        throw new Error("not implemented");
-    }
-    jsonSchema({ includeDiscriminantProperty, }) {
-        const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${this.reusables.imports.z}.literal("Literal")`
-            : "";
-        return code `${this.reusables.imports.z}.object({ "@language": ${this.reusables.imports.z}.string().optional()${discriminantProperty}, "@type": ${this.reusables.imports.z}.string().optional(), "@value": ${this.reusables.imports.z}.string() })`;
-    }
-    jsonType(parameters) {
-        const discriminantProperty = parameters?.includeDiscriminantProperty
-            ? `, readonly termType: "Literal"`
-            : "";
-        return new AbstractLiteralType.JsonType(code `{ readonly "@language"?: string${discriminantProperty}, readonly "@type"?: string, readonly "@value": string }`);
-    }
-    literalValueExpression(literal) {
-        return this.rdfjsTermExpression(literal);
-    }
-    toJsonExpression({ includeDiscriminantProperty, variables, }) {
-        return code `{ "@language": ${variables.value}.language.length > 0 ? ${variables.value}.language : undefined${includeDiscriminantProperty ? `, "termType": "Literal" as const` : ""}, "@type": ${variables.value}.datatype.value !== "${xsd.string.value}" ? ${variables.value}.datatype.value : undefined, "@value": ${variables.value}.value }`;
-    }
-}
-//# sourceMappingURL=LiteralType.js.map

package/dist/generators/ts/ObjectSetType.d.ts

@@ -1,6 +0,0 @@
-import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class ObjectSetType extends AbstractObjectSetType {
-    get declaration(): Code;
-}
-//# sourceMappingURL=ObjectSetType.d.ts.map

package/dist/generators/ts/ObjectSetType.js

@@ -1,36 +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 { Memoize } from "typescript-memoize";
-import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
-export class ObjectSetType extends AbstractObjectSetType {
-    get declaration() {
-        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-        return code `\
-export interface ${syntheticNamePrefix}ObjectSet {
-  ${joinCode(this.namedObjectTypes
-            .flatMap((namedObjectType) => Object.values(this.methodSignatures(namedObjectType)))
-            .concat(this.namedObjectUnionTypes.flatMap((namedObjectUnionType) => Object.values(this.methodSignatures(namedObjectUnionType))))
-            .map((methodSignature) => code `${methodSignature.name}(${methodSignature.parameters}): ${methodSignature.returnType};`), { on: "\n\n" })}
-}
-
-export namespace ${syntheticNamePrefix}ObjectSet {
-  export interface Query<ObjectFilterT, ObjectIdentifierT extends ${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode}> {
-    readonly filter?: ObjectFilterT;
-    readonly graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}>;
-    readonly identifiers?: readonly ObjectIdentifierT[];
-    readonly limit?: number;
-    readonly offset?: number;
-    readonly preferredLanguages?: readonly string[];
-  }
-}`;
-    }
-}
-__decorate([
-    Memoize()
-], ObjectSetType.prototype, "declaration", null);
-//# sourceMappingURL=ObjectSetType.js.map

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

@@ -1,104 +0,0 @@
-import type { NamedNode } from "@rdfjs/types";
-import { Maybe } from "purify-ts";
-import { DiscriminantProperty as _DiscriminantProperty } from "./_ObjectType/DiscriminantProperty.js";
-import { IdentifierProperty as _IdentifierProperty } from "./_ObjectType/IdentifierProperty.js";
-import type { Property as _Property } from "./_ObjectType/Property.js";
-import { ShaclProperty as _ShaclProperty } from "./_ObjectType/ShaclProperty.js";
-import { AbstractType } from "./AbstractType.js";
-import type { BlankNodeType } from "./BlankNodeType.js";
-import type { IdentifierType } from "./IdentifierType.js";
-import type { IriType } from "./IriType.js";
-import type { Type } from "./Type.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class ObjectType extends AbstractType {
-    protected readonly toRdfTypes: readonly NamedNode[];
-    readonly discriminantProperty: Maybe<ObjectType.DiscriminantProperty>;
-    readonly extern: boolean;
-    readonly fromRdfType: Maybe<NamedNode>;
-    readonly graphqlArgs: AbstractType["graphqlArgs"];
-    readonly identifierType: BlankNodeType | IdentifierType | IriType;
-    readonly jsTypes: readonly [{
-        readonly instanceof: "Object";
-        readonly typeof: "object";
-    }];
-    readonly kind = "Object";
-    readonly recursive: boolean;
-    readonly synthetic: boolean;
-    readonly validationFunction: Maybe<Code>;
-    constructor({ discriminantProperty, extern, fromRdfType, identifierType, lazyProperties, recursive, synthetic, toRdfTypes, ...superParameters }: {
-        discriminantProperty: Maybe<ObjectType.DiscriminantProperty>;
-        comment: Maybe<string>;
-        extern: boolean;
-        fromRdfType: Maybe<NamedNode>;
-        identifierType: BlankNodeType | IdentifierType | IriType;
-        label: Maybe<string>;
-        lazyProperties: (objectType: ObjectType) => readonly ObjectType.Property[];
-        recursive: boolean;
-        synthetic: boolean;
-        toRdfTypes: readonly NamedNode[];
-    } & ConstructorParameters<typeof AbstractType>[0]);
-    get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
-    get declaration(): Maybe<Code>;
-    get equalsFunction(): Code;
-    get expression(): Code;
-    get filterFunction(): Code;
-    get filterType(): Code;
-    get fromRdfResourceValuesFunction(): Code;
-    get fromRdfTypeVariable(): Maybe<Code>;
-    get graphqlType(): AbstractType.GraphqlType;
-    get hashFunction(): Code;
-    get identifierTypeAlias(): Code;
-    get mutable(): boolean;
-    get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
-    get properties(): readonly ObjectType.Property[];
-    get referencesNamedType(): boolean;
-    get schema(): Code;
-    get schemaType(): Code;
-    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
-    get toRdfjsResourceType(): Code;
-    get valueSparqlConstructTriplesFunction(): Code;
-    get valueSparqlWherePatternsFunction(): Code;
-    protected get constructorParameters(): {
-        hasQuestionToken: boolean;
-        signature: Code;
-        type: {
-            expression: Code;
-        };
-        variable: string;
-    };
-    protected get createFunction(): Code;
-    protected get thisVariable(): Code;
-    protected get toJsonFunction(): Code;
-    protected get toStringFunction(): Code;
-    private get inlineExpression();
-    fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
-    graphqlResolveExpression({ variables, }: {
-        variables: {
-            value: Code;
-        };
-    }): Code;
-    jsonSchema({ context, }: Parameters<AbstractType["jsonSchema"]>[0]): Code;
-    jsonType(): AbstractType.JsonType;
-    jsonUiSchemaElement({ variables, }: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
-    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
-    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
-    protected toStringRecordExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
-    private readonly lazyProperties;
-}
-export declare namespace ObjectType {
-    const IdentifierProperty: typeof _IdentifierProperty;
-    type IdentifierProperty = _IdentifierProperty;
-    type ObjectSetMethodNames = {
-        readonly object: string;
-        readonly objectCount: string;
-        readonly objectIdentifiers: string;
-        readonly objects: string;
-    };
-    type Property = _Property;
-    const ShaclProperty: typeof _ShaclProperty;
-    type ShaclProperty<TypeT extends Type> = _ShaclProperty<TypeT>;
-    const DiscriminantProperty: typeof _DiscriminantProperty;
-    type DiscriminantProperty = _DiscriminantProperty;
-}
-//# sourceMappingURL=ObjectType.d.ts.map