@shaclmate/compiler 4.0.50 → 4.0.51

package/dist/generators/ts/LazySetType.js

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,105 @@
+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 toRdfTypesVariable(): Maybe<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