@shaclmate/compiler 4.0.38 → 4.0.39

package/dist/generators/ts/IdentifierType.js

@@ -34,7 +34,7 @@ export class IdentifierType extends AbstractIdentifierType {
     filterFunction = code `${this.reusables.snippets.filterIdentifier}`;
     filterType = code `${this.reusables.snippets.IdentifierFilter}`;
     parseFunction = code `${this.reusables.snippets.parseIdentifier};`;
-    kind = "IdentifierType";
+    kind = "Identifier";
     name = code `(${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode})`;
     nodeKinds = nodeKinds;
     schemaType = code `${this.reusables.snippets.IdentifierSchema}`;

package/dist/generators/ts/IntType.d.ts

@@ -2,7 +2,7 @@ import type { Literal } from "@rdfjs/types";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class IntType extends AbstractNumericType<number> {
-    readonly kind = "IntType";
+    readonly kind = "Int";
     readonly typeofs: "number"[];
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     literalExpression(literal: Literal | number): Code;

package/dist/generators/ts/IntType.js

@@ -9,7 +9,7 @@ import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class IntType extends AbstractNumericType {
-    kind = "IntType";
+    kind = "Int";
     typeofs = ["number"];
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLInt}`, this.reusables);

package/dist/generators/ts/IriType.d.ts

@@ -5,13 +5,15 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class IriType extends AbstractIdentifierType<NamedNode> {
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly kind = "IriType";
+    readonly kind = "Iri";
     readonly nodeKinds: ReadonlySet<"IRI">;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     get conversionFunction(): Maybe<AbstractIdentifierType.ConversionFunction>;
     get name(): Code;
+    private get valueTypeName();
     get parseFunction(): Code;
+    protected get schemaInitializers(): readonly Code[];
     fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<NamedNode>["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractIdentifierType<NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;

package/dist/generators/ts/IriType.js

@@ -7,23 +7,20 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { arrayOf, code, joinCode, literalOf, } from "./ts-poet-wrapper.js";
+import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
 export class IriType extends AbstractIdentifierType {
     filterFunction = code `${this.reusables.snippets.filterIri}`;
     filterType = code `${this.reusables.snippets.IriFilter}`;
-    kind = "IriType";
+    kind = "Iri";
     nodeKinds = nodeKinds;
-    schemaType = code `${this.reusables.snippets.IriSchema}`;
+    schemaType = code `${this.reusables.snippets.IriSchema}<${this.valueTypeName}>`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.iriSparqlWherePatterns}`;
     get conversionFunction() {
-        const IriT = this.in_.length > 0
-            ? code `${joinCode(this.in_.map((iri) => code `${literalOf(iri.value)}`), { on: "| " })}`
-            : code `string`;
         return Maybe.of({
-            code: code `${this.reusables.snippets.convertToIri}<${IriT}>`,
+            code: code `${this.reusables.snippets.convertToIri}<${this.valueTypeName}>`,
             sourceTypes: [
                 {
-                    name: IriT,
+                    name: this.valueTypeName,
                     typeof: "string",
                 },
                 {
@@ -35,18 +32,28 @@ export class IriType extends AbstractIdentifierType {
     }
     get name() {
         if (this.in_.length > 0) {
-            // Treat sh:in as a union of the IRIs
-            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            return code `${this.reusables.imports.NamedNode}<${joinCode(this.in_.map((iri) => code `${literalOf(iri.value)}`), { on: "| " })}>`;
+            return code `${this.reusables.imports.NamedNode}<${this.valueTypeName}>`;
         }
         return code `${this.reusables.imports.NamedNode}`;
     }
+    get valueTypeName() {
+        return this.in_.length > 0
+            ? `(${this.in_.map((in_) => `"${in_.value}"`).join(" | ")})`
+            : "string";
+    }
     get parseFunction() {
         if (this.in_.length > 0) {
             return code `(identifier: string) => ${this.reusables.snippets.parseIri}(identifier).chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${this.reusables.imports.Right}(identifier as ${this.name});`))} default: return ${this.reusables.imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`;
         }
         return code `${this.reusables.snippets.parseIri}`;
     }
+    get schemaInitializers() {
+        let initializers = super.schemaInitializers;
+        if (this.in_.length > 0) {
+            initializers = initializers.concat(code `in: ${arrayOf(...this.in_.map((in_) => this.rdfjsTermExpression(in_)))}`);
+        }
+        return initializers;
+    }
     fromJsonExpression({ variables, }) {
         return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"]))`;
     }
@@ -69,12 +76,7 @@ export class IriType extends AbstractIdentifierType {
         const discriminantProperty = parameters?.includeDiscriminantProperty
             ? `, readonly termType: "NamedNode"`
             : "";
-        if (this.in_.length > 0) {
-            // Treat sh:in as a union of the IRIs
-            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            return new AbstractIdentifierType.JsonType(code `{ readonly "@id": ${this.in_.map((iri) => `"${iri.value}"`).join(" | ")}${discriminantProperty} }`);
-        }
-        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": ${this.valueTypeName}${discriminantProperty} }`);
     }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {
         const discriminantProperty = includeDiscriminantProperty
@@ -97,6 +99,9 @@ __decorate([
 __decorate([
     Memoize()
 ], IriType.prototype, "name", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "valueTypeName", null);
 __decorate([
     Memoize()
 ], IriType.prototype, "parseFunction", null);

package/dist/generators/ts/LazyObjectOptionType.d.ts

@@ -18,7 +18,7 @@ declare const Super: (abstract new ({ partialType, resolveType, ...superParamete
 };
 export declare class LazyObjectOptionType extends Super {
     readonly graphqlArgs: Super["graphqlArgs"];
-    readonly kind = "LazyObjectOptionType";
+    readonly kind = "LazyObjectOption";
     get conversionFunction(): Maybe<AbstractLazyObjectType.ConversionFunction>;
     protected get runtimeClass(): {
         name: Code;

package/dist/generators/ts/LazyObjectOptionType.js

@@ -11,7 +11,7 @@ import { code } from "./ts-poet-wrapper.js";
 const Super = (AbstractLazyObjectType);
 export class LazyObjectOptionType extends Super {
     graphqlArgs = Maybe.empty();
-    kind = "LazyObjectOptionType";
+    kind = "LazyObjectOption";
     get conversionFunction() {
         return Maybe.of({
             code: code `${this.reusables.snippets.convertToLazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,

package/dist/generators/ts/LazyObjectSetType.d.ts

@@ -4,7 +4,7 @@ import type { SetType } from "./SetType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class LazyObjectSetType extends AbstractLazyObjectType<SetType<AbstractLazyObjectType.ObjectTypeConstraint>, SetType<AbstractLazyObjectType.ObjectTypeConstraint>> {
     readonly graphqlArgs: Super["graphqlArgs"];
-    readonly kind = "LazyObjectSetType";
+    readonly kind = "LazyObjectSet";
     get conversionFunction(): Maybe<AbstractLazyObjectType.ConversionFunction>;
     protected get runtimeClass(): {
         name: Code;

package/dist/generators/ts/LazyObjectSetType.js

@@ -17,7 +17,7 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
             type: code `${this.reusables.imports.GraphQLInt}`,
         },
     });
-    kind = "LazyObjectSetType";
+    kind = "LazyObjectSet";
     get conversionFunction() {
         return Maybe.of({
             code: code `${this.reusables.snippets.convertToLazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,

package/dist/generators/ts/LazyObjectType.d.ts

@@ -3,7 +3,7 @@ import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class LazyObjectType extends AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint> {
     readonly graphqlArgs: Super["graphqlArgs"];
-    readonly kind = "LazyObjectType";
+    readonly kind = "LazyObject";
     get conversionFunction(): Maybe<AbstractLazyObjectType.ConversionFunction>;
     protected get runtimeClass(): {
         name: Code;

package/dist/generators/ts/LazyObjectType.js

@@ -10,7 +10,7 @@ import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class LazyObjectType extends AbstractLazyObjectType {
     graphqlArgs = Maybe.empty();
-    kind = "LazyObjectType";
+    kind = "LazyObject";
     get conversionFunction() {
         return Maybe.of({
             code: code `${this.reusables.snippets.convertToLazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.name}, ${this.resolveType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType, resolveType: this.resolveType })})`,

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

@@ -22,7 +22,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class ListType<ItemTypeT extends ListType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     private readonly identifierNodeKind;
     private readonly toRdfTypes;
-    readonly kind = "ListType";
+    readonly kind = "List";
     constructor({ identifierNodeKind, toRdfTypes, ...superParameters }: {
         identifierNodeKind: ListType<ItemTypeT>["identifierNodeKind"];
         toRdfTypes: readonly NamedNode[];

package/dist/generators/ts/ListType.js

@@ -11,7 +11,7 @@ import { code, joinCode } from "./ts-poet-wrapper.js";
 export class ListType extends AbstractCollectionType {
     identifierNodeKind;
     toRdfTypes;
-    kind = "ListType";
+    kind = "List";
     constructor({ identifierNodeKind, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.identifierNodeKind = identifierNodeKind;
@@ -102,31 +102,31 @@ __decorate([
 (function (ListType) {
     function isItemType(type) {
         switch (type.kind) {
-            case "AnonymousUnionType":
-            case "BigDecimalType":
-            case "BigIntType":
-            case "BlankNodeType":
-            case "BooleanType":
-            case "DateTimeType":
-            case "DateType":
-            case "FloatType":
-            case "IdentifierType":
-            case "IriType":
-            case "IntType":
-            case "LiteralType":
-            case "NamedObjectUnionType":
-            case "NamedUnionType":
+            case "AnonymousUnion":
+            case "BigDecimal":
+            case "BigInt":
+            case "BlankNode":
+            case "Boolean":
+            case "DateTime":
+            case "Date":
+            case "Float":
+            case "Identifier":
+            case "Iri":
+            case "Int":
+            case "Literal":
+            case "NamedObjectUnion":
+            case "NamedUnion":
             case "NamedObjectType":
-            case "StringType":
-            case "TermType":
+            case "String":
+            case "Term":
                 return true;
-            case "DefaultValueType":
-            case "LazyObjectOptionType":
-            case "LazyObjectSetType":
-            case "LazyObjectType":
-            case "ListType":
-            case "OptionType":
-            case "SetType":
+            case "DefaultValue":
+            case "LazyObjectOption":
+            case "LazyObjectSet":
+            case "LazyObject":
+            case "List":
+            case "Option":
+            case "Set":
                 return false;
         }
     }

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

@@ -7,10 +7,11 @@ export declare class LiteralType extends AbstractLiteralType {
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly kind = "LiteralType";
+    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;

package/dist/generators/ts/LiteralType.js

@@ -1,7 +1,7 @@
 import { xsd } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
-import { code } from "./ts-poet-wrapper.js";
+import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class LiteralType extends AbstractLiteralType {
     name = code `${this.reusables.imports.Literal}`;
     conversionFunction = Maybe.of({
@@ -23,12 +23,19 @@ export class LiteralType extends AbstractLiteralType {
     });
     filterFunction = code `${this.reusables.snippets.filterLiteral}`;
     filterType = code `${this.reusables.snippets.LiteralFilter}`;
-    kind = "LiteralType";
+    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_)))}`);
+        }
+        return initializers;
+    }
     fromJsonExpression({ variables, }) {
         return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${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)))`;
     }

package/dist/generators/ts/NamedObjectType.d.ts

@@ -20,6 +20,7 @@ export declare class NamedObjectType extends AbstractType {
     readonly kind = "NamedObjectType";
     readonly name: string;
     readonly recursive: boolean;
+    readonly referencesObjectType = true;
     readonly synthetic: boolean;
     readonly typeofs: "object"[];
     readonly validationFunction: Maybe<Code>;

package/dist/generators/ts/NamedObjectType.js

@@ -51,6 +51,7 @@ export class NamedObjectType extends AbstractType {
     kind = "NamedObjectType";
     name;
     recursive;
+    referencesObjectType = true;
     synthetic;
     typeofs = ["object"];
     validationFunction = Maybe.empty();
@@ -196,7 +197,7 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         if (this.parentObjectTypes.length > 0) {
             return this.parentObjectTypes[0].toRdfjsResourceType;
         }
-        return code `${this.reusables.imports.Resource}${this.identifierType.kind === "IriType" ? code `<${this.reusables.imports.NamedNode}>` : ""}`;
+        return code `${this.reusables.imports.Resource}${this.identifierType.kind === "Iri" ? code `<${this.reusables.imports.NamedNode}>` : ""}`;
     }
     get valueSparqlConstructTriplesFunction() {
         return code `${this.name}.valueSparqlConstructTriples`;

package/dist/generators/ts/NamedObjectUnionType.d.ts

@@ -8,7 +8,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class NamedObjectUnionType extends AbstractNamedUnionType<NamedObjectType> {
     #private;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
-    readonly kind = "NamedObjectUnionType";
+    readonly kind = "NamedObjectUnion";
     readonly synthetic: boolean;
     constructor({ identifierType, synthetic, ...superParameters }: {
         identifierType: BlankNodeType | IdentifierType | IriType;

package/dist/generators/ts/NamedObjectUnionType.js

@@ -18,7 +18,7 @@ import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class NamedObjectUnionType extends AbstractNamedUnionType {
     #identifierType;
     graphqlArgs = Maybe.empty();
-    kind = "NamedObjectUnionType";
+    kind = "NamedObjectUnion";
     synthetic;
     constructor({ identifierType, synthetic, ...superParameters }) {
         super({ ...superParameters, identifierType: Maybe.of(identifierType) });
@@ -167,7 +167,7 @@ export namespace Identifier {
         const commonPropertiesByName = {};
         this.members.forEach((member, memberI) => {
             for (const memberTypeProperty of member.type.properties.concat(member.type.ancestorObjectTypes.flatMap((ancestorObjectType) => ancestorObjectType.properties))) {
-                if (memberTypeProperty.kind !== "ShaclProperty") {
+                if (memberTypeProperty.kind !== "Shacl") {
                     continue;
                 }
                 let commonProperty = commonPropertiesByName[memberTypeProperty.name];
@@ -191,14 +191,12 @@ export namespace Identifier {
             if (!memberTypesWithProperty.every((value) => value)) {
                 continue;
             }
-            propertiesObject.push(code `${property.name}: ${property.schema}`);
+            property.schema.ifJust(propertySchema => {
+                propertiesObject.push(code `${property.name}: ${propertySchema}`);
+            });
         }
         return singleEntryRecord(`schema`, code `\
-export const schema =
-${{
-            ...super.schemaObject,
-            properties: code `{ ${joinCode(propertiesObject, { on: ", " })} }`,
-        }} as const;`);
+export const schema = { ${joinCode(super.schemaInitializers.concat(code `properties: { ${joinCode(propertiesObject, { on: ", " })} }`), { on: ", " })} } as const;`);
     }
     get toRdfResourceFunctionDeclaration() {
         if (!this.configuration.features.has("Object.toRdf")) {

package/dist/generators/ts/NamedUnionType.d.ts

@@ -4,7 +4,7 @@ import type { Type } from "./Type.js";
 import type { Code } from "./ts-poet-wrapper.js";
 export declare class NamedUnionType extends AbstractNamedUnionType<Type> {
     readonly graphqlArgs: AbstractType["graphqlArgs"];
-    readonly kind = "NamedUnionType";
+    readonly kind = "NamedUnion";
     graphqlResolveExpression(): Code;
     get graphqlType(): AbstractType.GraphqlType;
 }

package/dist/generators/ts/NamedUnionType.js

@@ -2,7 +2,7 @@ import { Maybe } from "purify-ts";
 import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
 export class NamedUnionType extends AbstractNamedUnionType {
     graphqlArgs = Maybe.empty();
-    kind = "NamedUnionType";
+    kind = "NamedUnion";
     graphqlResolveExpression() {
         throw new Error("GraphQL doesn't support scalar unions");
     }

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

@@ -4,7 +4,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends AbstractContainerType<ItemTypeT> {
     readonly discriminantProperty: Maybe<AbstractContainerType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
-    readonly kind = "OptionType";
+    readonly kind = "Option";
     readonly typeofs: "object"[];
     get conversionFunction(): Maybe<AbstractContainerType.ConversionFunction>;
     get equalsFunction(): Code;
@@ -18,10 +18,6 @@ export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends A
     get validationFunction(): Maybe<Code>;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
-    protected get schemaObject(): {
-        kind: Code;
-        item: Code;
-    };
     fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;

package/dist/generators/ts/OptionType.js

@@ -9,11 +9,11 @@ import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import { codeEquals } from "./codeEquals.js";
-import { code, literalOf } from "./ts-poet-wrapper.js";
+import { code } from "./ts-poet-wrapper.js";
 export class OptionType extends AbstractContainerType {
     discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
-    kind = "OptionType";
+    kind = "Option";
     typeofs = ["object"];
     get conversionFunction() {
         const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
@@ -64,12 +64,6 @@ export class OptionType extends AbstractContainerType {
     get valueSparqlWherePatternsFunction() {
         return code `${this.reusables.snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            kind: code `${literalOf("Maybe")} as const`,
-        };
-    }
     fromJsonExpression({ variables, }) {
         const expression = code `${this.reusables.imports.Maybe}.fromNullable(${variables.value})`;
         const itemFromJsonExpression = this.itemType.fromJsonExpression({

package/dist/generators/ts/RdfjsDatasetObjectSetType.js

@@ -99,7 +99,7 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
   return this.#objectsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
 }`);
                     }
-                    case "NamedObjectUnionType":
+                    case "NamedObjectUnion":
                         return delegatingMethods.concat(code `\
 ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.name}[]> {
   return this.#objectUnionsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([

package/dist/generators/ts/SetType.d.ts

@@ -2,7 +2,7 @@ import { AbstractCollectionType } from "./AbstractCollectionType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class SetType<ItemTypeT extends SetType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     readonly graphqlArgs: AbstractCollectionType<ItemTypeT>["graphqlArgs"];
-    readonly kind = "SetType";
+    readonly kind = "Set";
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;

package/dist/generators/ts/SetType.js

@@ -10,7 +10,7 @@ import { AbstractCollectionType } from "./AbstractCollectionType.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class SetType extends AbstractCollectionType {
     graphqlArgs = Maybe.empty();
-    kind = "SetType";
+    kind = "Set";
     get valueSparqlConstructTriplesFunction() {
         return code `${this.reusables.snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }

package/dist/generators/ts/Snippets.d.ts

@@ -87,6 +87,7 @@ export declare class Snippets {
     get decodeBigDecimalLiteral(): Snippet;
     get deduplicateSparqlPatterns(): Snippet;
     get defaultValueSparqlWherePatterns(): Snippet;
+    get ensureRdfResourceType(): Snippet;
     get filterArray(): Snippet;
     get filterBigDecimal(): Snippet;
     get filterBlankNode(): Snippet;

package/dist/generators/ts/Snippets.js

@@ -45,6 +45,7 @@ import { snippets_decodeBigDecimalLiteral } from "./_snippets/snippets_decodeBig
 import { snippets_deduplicateSparqlPatterns } from "./_snippets/snippets_deduplicateSparqlPatterns.js";
 import { snippets_defaultValueSparqlWherePatterns } from "./_snippets/snippets_defaultValueSparqlWherePatterns.js";
 import { snippets_EqualsResult } from "./_snippets/snippets_EqualsResult.js";
+import { snippets_ensureRdfResourceType } from "./_snippets/snippets_ensureRdfResourceType.js";
 import { snippets_FocusSparqlConstructTriplesFunction } from "./_snippets/snippets_FocusSparqlConstructTriplesFunction.js";
 import { snippets_FocusSparqlWherePatternsFunction } from "./_snippets/snippets_FocusSparqlWherePatternsFunction.js";
 import { snippets_FromRdfResourceFunction } from "./_snippets/snippets_FromRdfResourceFunction.js";
@@ -379,6 +380,9 @@ export class Snippets {
     get defaultValueSparqlWherePatterns() {
         return this.snippet(snippets_defaultValueSparqlWherePatterns);
     }
+    get ensureRdfResourceType() {
+        return this.snippet(snippets_ensureRdfResourceType);
+    }
     get filterArray() {
         return this.snippet(snippets_filterArray);
     }
@@ -827,6 +831,9 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "defaultValueSparqlWherePatterns", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "ensureRdfResourceType", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "filterArray", null);

package/dist/generators/ts/StringType.d.ts

@@ -6,7 +6,7 @@ export declare class StringType extends AbstractPrimitiveType<string> {
     readonly filterType: Code;
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly hashFunction: Code;
-    readonly kind = "StringType";
+    readonly kind = "String";
     readonly schemaType: Code;
     readonly typeofs: "string"[];
     readonly valueSparqlWherePatternsFunction: Code;

package/dist/generators/ts/StringType.js

@@ -13,8 +13,8 @@ export class StringType extends AbstractPrimitiveType {
     filterType = code `${this.reusables.snippets.StringFilter}`;
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashString}`;
-    kind = "StringType";
-    schemaType = code `${this.reusables.snippets.StringSchema}`;
+    kind = "String";
+    schemaType = code `${this.reusables.snippets.StringSchema}<${this.name}>`;
     typeofs = ["string"];
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.stringSparqlWherePatterns}`;
     get name() {

package/dist/generators/ts/TermType.d.ts

@@ -7,7 +7,7 @@ export declare class TermType<ConstantTermT extends Literal | NamedNode = Litera
     readonly conversionFunction: Maybe<AbstractTermType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly kind = "TermType";
+    readonly kind = "Term";
     readonly nodeKinds: ReadonlySet<NodeKind>;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;

package/dist/generators/ts/TermType.js

@@ -15,7 +15,7 @@ export class TermType extends AbstractTermType {
     conversionFunction = Maybe.empty();
     filterFunction = code `${this.reusables.snippets.filterTerm}`;
     filterType = code `${this.reusables.snippets.TermFilter}`;
-    kind = "TermType";
+    kind = "Term";
     nodeKinds;
     schemaType = code `${this.reusables.snippets.TermSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.termSparqlWherePatterns}`;