@shaclmate/compiler 4.0.52 → 4.0.53

package/dist/generators/ts/LangStringType.d.ts

@@ -0,0 +1,31 @@
+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 LangStringType extends AbstractLiteralType {
+    private readonly languageIn;
+    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 = "LangString";
+    readonly schemaType: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
+    constructor({ languageIn, ...superParameters }: {
+        languageIn: readonly string[];
+    } & ConstructorParameters<typeof AbstractLiteralType>[0]);
+    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=LangStringType.d.ts.map

package/dist/generators/ts/LangStringType.js

@@ -0,0 +1,67 @@
+import { Maybe } from "purify-ts";
+import { AbstractLiteralType } from "./AbstractLiteralType.js";
+import { arrayOf, code } from "./ts-poet-wrapper.js";
+export class LangStringType extends AbstractLiteralType {
+    languageIn;
+    inlineExpression = code `${this.reusables.imports.Literal}`;
+    conversionFunction = Maybe.of({
+        code: code `${this.reusables.snippets.convertToLangString}`,
+        sourceTypes: [
+            {
+                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.langStringFromRdfResourceValues}`;
+    jsTypes = [
+        { instanceof: "Object", typeof: "object" },
+    ];
+    kind = "LangString";
+    schemaType = code `${this.reusables.snippets.LangStringSchema}`;
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.langStringSparqlWherePatterns}`;
+    constructor({ languageIn, ...superParameters }) {
+        super(superParameters);
+        this.languageIn = languageIn;
+    }
+    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"]))`;
+    }
+    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()${discriminantProperty}, "@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 "@value": string }`);
+    }
+    literalValueExpression(literal) {
+        return this.rdfjsTermExpression(literal);
+    }
+    toJsonExpression({ includeDiscriminantProperty, variables, }) {
+        return code `{ "@language": ${variables.value}.language${includeDiscriminantProperty ? `, "termType": "Literal" as const` : ""}, "@value": ${variables.value}.value }`;
+    }
+}
+//# sourceMappingURL=LangStringType.js.map

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

@@ -11,6 +11,7 @@ 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 { LangStringType } from "./LangStringType.js";
 import type { LiteralType } from "./LiteralType.js";
 import type { ObjectType } from "./ObjectType.js";
 import type { ObjectUnionType } from "./ObjectUnionType.js";
@@ -43,7 +44,7 @@ export declare class ListType<ItemTypeT extends ListType.ItemType> extends Abstr
     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>;
+    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | LangStringType | 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

@@ -139,6 +139,7 @@ __decorate([
             case "Identifier":
             case "Iri":
             case "Int":
+            case "LangString":
             case "List":
             case "Literal":
             case "ObjectUnion":

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

@@ -3,6 +3,7 @@ import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class LiteralType extends AbstractLiteralType {
+    private readonly languageIn;
     protected readonly inlineExpression: Code;
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly filterFunction: Code;
@@ -15,6 +16,9 @@ export declare class LiteralType extends AbstractLiteralType {
     readonly kind = "Literal";
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
+    constructor({ languageIn, ...superParameters }: {
+        languageIn: readonly string[];
+    } & ConstructorParameters<typeof AbstractLiteralType>[0]);
     get graphqlType(): AbstractLiteralType.GraphqlType;
     protected get schemaInitializers(): readonly Code[];
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;

package/dist/generators/ts/LiteralType.js

@@ -3,6 +3,7 @@ import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class LiteralType extends AbstractLiteralType {
+    languageIn;
     inlineExpression = code `${this.reusables.imports.Literal}`;
     conversionFunction = Maybe.of({
         code: code `${this.reusables.snippets.convertToLiteral}`,
@@ -30,6 +31,10 @@ export class LiteralType extends AbstractLiteralType {
     kind = "Literal";
     schemaType = code `${this.reusables.snippets.LiteralSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.literalSparqlWherePatterns}`;
+    constructor({ languageIn, ...superParameters }) {
+        super(superParameters);
+        this.languageIn = languageIn;
+    }
     get graphqlType() {
         throw new Error("not implemented");
     }

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

@@ -35,6 +35,7 @@ export declare class Snippets {
     get IdentifierSet(): Snippet;
     get IriFilter(): Snippet;
     get IriSchema(): Snippet;
+    get LangStringSchema(): Snippet;
     get Lazy(): Snippet;
     get LazyOption(): Snippet;
     get LazySet(): Snippet;
@@ -81,6 +82,7 @@ export declare class Snippets {
     get convertToIdentifierProperty(): Snippet;
     get convertToIri(): Snippet;
     get convertToIriIdentifierProperty(): Snippet;
+    get convertToLangString(): Snippet;
     get convertToLazy(): Snippet;
     get convertToLazyOption(): Snippet;
     get convertToLazySet(): Snippet;
@@ -93,7 +95,6 @@ export declare class Snippets {
     get dateFromRdfResourceValues(): Snippet;
     get dateSparqlWherePatterns(): Snippet;
     get dateTimeFromRdfResourceValues(): Snippet;
-    get decodeBigDecimalLiteral(): Snippet;
     get deduplicateSparqlPatterns(): Snippet;
     get defaultValueFromRdfResourceValues(): Snippet;
     get defaultValueSparqlWherePatterns(): Snippet;
@@ -128,6 +129,8 @@ export declare class Snippets {
     get intFromRdfResourceValues(): Snippet;
     get iriFromRdfResourceValues(): Snippet;
     get iriSparqlWherePatterns(): Snippet;
+    get langStringFromRdfResourceValues(): Snippet;
+    get langStringSparqlWherePatterns(): Snippet;
     get liftSparqlPatterns(): Snippet;
     get listFromRdfResourceValues(): Snippet;
     get listSparqlConstructTriples(): Snippet;

package/dist/generators/ts/Snippets.js

@@ -34,6 +34,7 @@ import { snippets_convertToIdentifier } from "./_snippets/snippets_convertToIden
 import { snippets_convertToIdentifierProperty } from "./_snippets/snippets_convertToIdentifierProperty.js";
 import { snippets_convertToIri } from "./_snippets/snippets_convertToIri.js";
 import { snippets_convertToIriIdentifierProperty } from "./_snippets/snippets_convertToIriIdentifierProperty.js";
+import { snippets_convertToLangString } from "./_snippets/snippets_convertToLangString.js";
 import { snippets_convertToLazy } from "./_snippets/snippets_convertToLazy.js";
 import { snippets_convertToLazyOption } from "./_snippets/snippets_convertToLazyOption.js";
 import { snippets_convertToLazySet } from "./_snippets/snippets_convertToLazySet.js";
@@ -49,7 +50,6 @@ import { snippets_dateEquals } from "./_snippets/snippets_dateEquals.js";
 import { snippets_dateFromRdfResourceValues } from "./_snippets/snippets_dateFromRdfResourceValues.js";
 import { snippets_dateSparqlWherePatterns } from "./_snippets/snippets_dateSparqlWherePatterns.js";
 import { snippets_dateTimeFromRdfResourceValues } from "./_snippets/snippets_dateTimeFromRdfResourceValues.js";
-import { snippets_decodeBigDecimalLiteral } from "./_snippets/snippets_decodeBigDecimalLiteral.js";
 import { snippets_deduplicateSparqlPatterns } from "./_snippets/snippets_deduplicateSparqlPatterns.js";
 import { snippets_defaultValueFromRdfResourceValues } from "./_snippets/snippets_defaultValueFromRdfResourceValues.js";
 import { snippets_defaultValueSparqlWherePatterns } from "./_snippets/snippets_defaultValueSparqlWherePatterns.js";
@@ -96,11 +96,14 @@ import { snippets_identityValidationFunction } from "./_snippets/snippets_identi
 import { snippets_intFromRdfResourceValues } from "./_snippets/snippets_intFromRdfResourceValues.js";
 import { snippets_iriFromRdfResourceValues } from "./_snippets/snippets_iriFromRdfResourceValues.js";
 import { snippets_iriSparqlWherePatterns } from "./_snippets/snippets_iriSparqlWherePatterns.js";
+import { snippets_LangStringSchema } from "./_snippets/snippets_LangStringSchema.js";
 import { snippets_Lazy } from "./_snippets/snippets_Lazy.js";
 import { snippets_LazyOption } from "./_snippets/snippets_LazyOption.js";
 import { snippets_LazySet } from "./_snippets/snippets_LazySet.js";
 import { snippets_LiteralFilter } from "./_snippets/snippets_LiteralFilter.js";
 import { snippets_LiteralSchema } from "./_snippets/snippets_LiteralSchema.js";
+import { snippets_langStringFromRdfResourceValues } from "./_snippets/snippets_langStringFromRdfResourceValues.js";
+import { snippets_langStringSparqlWherePatterns } from "./_snippets/snippets_langStringSparqlWherePatterns.js";
 import { snippets_liftSparqlPatterns } from "./_snippets/snippets_liftSparqlPatterns.js";
 import { snippets_listFromRdfResourceValues } from "./_snippets/snippets_listFromRdfResourceValues.js";
 import { snippets_listSparqlConstructTriples } from "./_snippets/snippets_listSparqlConstructTriples.js";
@@ -247,6 +250,9 @@ export class Snippets {
     get IriSchema() {
         return this.snippet(snippets_IriSchema);
     }
+    get LangStringSchema() {
+        return this.snippet(snippets_LangStringSchema);
+    }
     get Lazy() {
         return this.snippet(snippets_Lazy);
     }
@@ -385,6 +391,9 @@ export class Snippets {
     get convertToIriIdentifierProperty() {
         return this.snippet(snippets_convertToIriIdentifierProperty);
     }
+    get convertToLangString() {
+        return this.snippet(snippets_convertToLangString);
+    }
     get convertToLazy() {
         return this.snippet(snippets_convertToLazy);
     }
@@ -421,9 +430,6 @@ export class Snippets {
     get dateTimeFromRdfResourceValues() {
         return this.snippet(snippets_dateTimeFromRdfResourceValues);
     }
-    get decodeBigDecimalLiteral() {
-        return this.snippet(snippets_decodeBigDecimalLiteral);
-    }
     get deduplicateSparqlPatterns() {
         return this.snippet(snippets_deduplicateSparqlPatterns);
     }
@@ -542,6 +548,12 @@ export class Snippets {
     get iriSparqlWherePatterns() {
         return this.snippet(snippets_iriSparqlWherePatterns);
     }
+    get langStringFromRdfResourceValues() {
+        return this.snippet(snippets_langStringFromRdfResourceValues);
+    }
+    get langStringSparqlWherePatterns() {
+        return this.snippet(snippets_langStringSparqlWherePatterns);
+    }
     get liftSparqlPatterns() {
         return this.snippet(snippets_liftSparqlPatterns);
     }
@@ -767,6 +779,9 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "IriSchema", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "LangStringSchema", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "Lazy", null);
@@ -905,6 +920,9 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToIriIdentifierProperty", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "convertToLangString", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToLazy", null);
@@ -941,9 +959,6 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "dateTimeFromRdfResourceValues", null);
-__decorate([
-    Memoize()
-], Snippets.prototype, "decodeBigDecimalLiteral", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "deduplicateSparqlPatterns", null);
@@ -1043,6 +1058,12 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "iriSparqlWherePatterns", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "langStringFromRdfResourceValues", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "langStringSparqlWherePatterns", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "liftSparqlPatterns", null);

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

@@ -2,6 +2,7 @@ import type { Literal } from "@rdfjs/types";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class StringType extends AbstractPrimitiveType<string> {
+    private readonly languageIn;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
@@ -11,11 +12,13 @@ export declare class StringType extends AbstractPrimitiveType<string> {
     }];
     readonly kind = "String";
     readonly valueSparqlWherePatternsFunction: Code;
+    constructor({ languageIn, ...superParameters }: {
+        languageIn: readonly string[];
+    } & ConstructorParameters<typeof AbstractPrimitiveType<string>>[0]);
     get fromRdfResourceValuesFunction(): Code;
     get schemaType(): Code;
-    protected get inlineExpression(): Code;
     protected get schemaInitializers(): readonly Code[];
-    jsonSchema(_parameters: Parameters<AbstractPrimitiveType<string>["jsonSchema"]>[0]): Code;
+    jsonSchema(parameters: Parameters<AbstractPrimitiveType<string>["jsonSchema"]>[0]): Code;
     literalValueExpression(literal: Literal | string): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
 }

package/dist/generators/ts/StringType.js

@@ -9,6 +9,7 @@ import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { arrayOf, code, literalOf } from "./ts-poet-wrapper.js";
 export class StringType extends AbstractPrimitiveType {
+    languageIn;
     filterFunction = code `${this.reusables.snippets.filterString}`;
     filterType = code `${this.reusables.snippets.StringFilter}`;
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
@@ -20,18 +21,16 @@ export class StringType extends AbstractPrimitiveType {
     ];
     kind = "String";
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.stringSparqlWherePatterns}`;
+    constructor({ languageIn, ...superParameters }) {
+        super(superParameters);
+        this.languageIn = languageIn;
+    }
     get fromRdfResourceValuesFunction() {
         return code `${this.reusables.snippets.stringFromRdfResourceValues}<${this.expression}>`;
     }
     get schemaType() {
         return code `${this.reusables.snippets.StringSchema}<${this.expression}>`;
     }
-    get inlineExpression() {
-        if (this.primitiveIn.length > 0) {
-            return code `${this.primitiveIn.map((value) => `"${value}"`).join(" | ")}`;
-        }
-        return code `string`;
-    }
     get schemaInitializers() {
         let initializers = super.schemaInitializers;
         if (this.languageIn.length > 0) {
@@ -39,15 +38,11 @@ export class StringType extends AbstractPrimitiveType {
         }
         return initializers;
     }
-    jsonSchema(_parameters) {
-        switch (this.primitiveIn.length) {
-            case 0:
-                return code `${this.reusables.imports.z}.string()`;
-            case 1:
-                return code `${this.reusables.imports.z}.literal(${this.primitiveIn[0]})`;
-            default:
-                return code `${this.reusables.imports.z}.enum(${arrayOf(...this.primitiveIn)})`;
+    jsonSchema(parameters) {
+        if (this.decodedIn.length > 1) {
+            return code `${this.reusables.imports.z}.enum(${arrayOf(...this.decodedIn)})`;
         }
+        return super.jsonSchema(parameters);
     }
     literalValueExpression(literal) {
         return code `${literalOf(typeof literal === "string" ? literal : literal.value)}`;
@@ -62,7 +57,4 @@ __decorate([
 __decorate([
     Memoize()
 ], StringType.prototype, "schemaType", null);
-__decorate([
-    Memoize()
-], StringType.prototype, "inlineExpression", null);
 //# sourceMappingURL=StringType.js.map

package/dist/generators/ts/Type.d.ts

@@ -9,6 +9,7 @@ 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 { LangStringType } from "./LangStringType.js";
 import type { LazyOptionType } from "./LazyOptionType.js";
 import type { LazySetType } from "./LazySetType.js";
 import type { LazyType } from "./LazyType.js";
@@ -21,5 +22,5 @@ import type { SetType } from "./SetType.js";
 import type { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
 import type { UnionType } from "./UnionType.js";
-export type Type = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | FloatType | IdentifierType | IntType | IriType | LazyOptionType | LazySetType | LazyType | ListType<ListType.ItemType> | LiteralType | ObjectUnionType | ObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType | UnionType<Type>;
+export type Type = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | FloatType | IdentifierType | IntType | IriType | LangStringType | LazyOptionType | LazySetType | LazyType | ListType<ListType.ItemType> | LiteralType | ObjectUnionType | ObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType | UnionType<Type>;
 //# sourceMappingURL=Type.d.ts.map

package/dist/generators/ts/TypeFactory.js

@@ -18,6 +18,7 @@ import { FloatType } from "./FloatType.js";
 import { IdentifierType } from "./IdentifierType.js";
 import { IntType } from "./IntType.js";
 import { IriType } from "./IriType.js";
+import { LangStringType } from "./LangStringType.js";
 import { LazyOptionType } from "./LazyOptionType.js";
 import { LazySetType } from "./LazySetType.js";
 import { LazyType } from "./LazyType.js";
@@ -321,114 +322,64 @@ export class TypeFactory {
         }
         if (datatypes.size === 1) {
             const datatype = [...datatypes][0];
+            const typeParameters = {
+                comment: astType.comment,
+                configuration: this.configuration,
+                datatype,
+                hasValues: astType.hasValues,
+                in_: astType.in_,
+                label: astType.label,
+                languageIn: astType.languageIn,
+                logger: this.logger,
+                name: astType.name.map((name) => this.tsName(name)),
+                reusables: this.reusables,
+                shapeIdentifier: astType.shapeIdentifier,
+            };
+            if (datatype.equals(rdf.langString)) {
+                return new LangStringType(typeParameters);
+            }
             const datatypeDefinition = literalDatatypeDefinitions[datatype.value];
             if (datatypeDefinition) {
                 switch (datatypeDefinition.kind) {
                     case "bigdecimal":
                         return new BigDecimalType({
-                            comment: astType.comment,
-                            configuration: this.configuration,
-                            hasValues: astType.hasValues,
-                            in_: astType.in_,
-                            label: astType.label,
-                            languageIn: [],
-                            logger: this.logger,
-                            name: astType.name.map((name) => this.tsName(name)),
-                            reusables: this.reusables,
-                            shapeIdentifier: astType.shapeIdentifier,
+                            ...typeParameters,
+                            decodedIn: astType.in_.map((value) => LiteralDecoder.decodeBigDecimalLiteral(value).unsafeCoerce()),
                         });
                     case "bigint":
                         return new BigIntType({
-                            comment: astType.comment,
-                            configuration: this.configuration,
-                            datatype,
-                            hasValues: astType.hasValues,
-                            in_: astType.in_,
-                            label: astType.label,
-                            languageIn: [],
-                            logger: this.logger,
-                            name: astType.name.map((name) => this.tsName(name)),
-                            primitiveIn: astType.in_.map((value) => LiteralDecoder.decodeBigIntLiteral(value).unsafeCoerce()),
-                            reusables: this.reusables,
-                            shapeIdentifier: astType.shapeIdentifier,
+                            ...typeParameters,
+                            decodedIn: astType.in_.map((value) => LiteralDecoder.decodeBigIntLiteral(value).unsafeCoerce()),
                         });
                     case "boolean":
                         return new BooleanType({
-                            comment: astType.comment,
-                            configuration: this.configuration,
-                            datatype,
-                            hasValues: astType.hasValues,
-                            label: astType.label,
-                            languageIn: [],
-                            in_: astType.in_,
-                            logger: this.logger,
-                            name: astType.name.map((name) => this.tsName(name)),
-                            primitiveIn: astType.in_.map((value) => LiteralDecoder.decodeBooleanLiteral(value).unsafeCoerce()),
-                            reusables: this.reusables,
-                            shapeIdentifier: astType.shapeIdentifier,
+                            ...typeParameters,
+                            decodedIn: astType.in_.map((value) => LiteralDecoder.decodeBooleanLiteral(value).unsafeCoerce()),
                         });
                     case "date":
                     case "datetime":
                         return new (datatypeDefinition.kind === "date" ? DateType : DateTimeType)({
-                            comment: astType.comment,
-                            configuration: this.configuration,
-                            datatype,
-                            hasValues: astType.hasValues,
-                            in_: astType.in_,
-                            label: astType.label,
-                            languageIn: [],
-                            logger: this.logger,
-                            name: astType.name.map((name) => this.tsName(name)),
-                            primitiveIn: astType.in_.map((value) => (datatypeDefinition.kind === "date"
+                            ...typeParameters,
+                            decodedIn: astType.in_.map((value) => (datatypeDefinition.kind === "date"
                                 ? LiteralDecoder.decodeDateLiteral
                                 : LiteralDecoder.decodeDateTimeLiteral)(value).unsafeCoerce()),
-                            reusables: this.reusables,
-                            shapeIdentifier: astType.shapeIdentifier,
                         });
                     case "float":
                     case "int":
                         return new (datatypeDefinition.kind === "float" ? FloatType : IntType)({
-                            comment: astType.comment,
-                            configuration: this.configuration,
-                            datatype,
-                            hasValues: astType.hasValues,
-                            in_: astType.in_,
-                            label: astType.label,
-                            languageIn: [],
-                            logger: this.logger,
-                            name: astType.name.map((name) => this.tsName(name)),
-                            primitiveIn: astType.in_.map((value) => (datatypeDefinition.kind === "float"
+                            ...typeParameters,
+                            decodedIn: astType.in_.map((value) => (datatypeDefinition.kind === "float"
                                 ? LiteralDecoder.decodeFloatLiteral
                                 : LiteralDecoder.decodeIntLiteral)(value).unsafeCoerce()),
-                            reusables: this.reusables,
-                            shapeIdentifier: astType.shapeIdentifier,
                         });
                     case "string":
-                        if (!datatype.equals(rdf.langString)) {
-                            return new StringType({
-                                comment: astType.comment,
-                                configuration: this.configuration,
-                                datatype,
-                                hasValues: astType.hasValues,
-                                in_: astType.in_,
-                                label: astType.label,
-                                languageIn: astType.languageIn,
-                                logger: this.logger,
-                                name: astType.name.map((name) => this.tsName(name)),
-                                primitiveIn: astType.in_.map((value) => value.value),
-                                reusables: this.reusables,
-                                shapeIdentifier: astType.shapeIdentifier,
-                            });
-                        }
-                        break;
+                        return new StringType({
+                            ...typeParameters,
+                            decodedIn: astType.in_.map((value) => LiteralDecoder.decodeStringLiteral(value).unsafeCoerce()),
+                        });
                 }
             }
-            if (datatype.equals(rdf.langString)) {
-                // Drop down
-            }
-            else {
-                this.logger.warn("unrecognized literal datatype: %s", datatype.value);
-            }
+            this.logger.warn("unrecognized literal datatype: %s", datatype.value);
         }
         else if (datatypes.size > 0) {
             this.logger.warn("literal type has multiple datatypes: %s", JSON.stringify([...datatypes].map((datatype) => datatype.value)));

package/dist/generators/ts/UnionType.d.ts

@@ -112,7 +112,7 @@ export declare namespace Discriminant {
 export declare namespace AbstractUnionType {
     interface Member<TypeT extends Type> {
         readonly discriminantValues: readonly AbstractType.DiscriminantProperty.Value[];
-        readonly jsonType: Code | string;
+        readonly jsonType: Code;
         readonly jsonTypeCheck: (instance: Code) => Code;
         readonly primaryDiscriminantValue: AbstractType.DiscriminantProperty.Value;
         readonly type: TypeT;

package/dist/generators/ts/_snippets/snippets_LangStringSchema.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_LangStringSchema: SnippetFactory;
+//# sourceMappingURL=snippets_LangStringSchema.d.ts.map

package/dist/generators/ts/_snippets/snippets_LangStringSchema.js

@@ -0,0 +1,4 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_LangStringSchema = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}LangStringSchema`, code `\
+type ${syntheticNamePrefix}LangStringSchema = Omit<${snippets.LiteralSchema}, "kind"> & { readonly kind: "LangString"; };`);
+//# sourceMappingURL=snippets_LangStringSchema.js.map

package/dist/generators/ts/_snippets/snippets_RdfVocabularies.js

@@ -3,6 +3,7 @@ export const snippets_RdfVocabularies = ({ imports, syntheticNamePrefix, }) => c
 namespace ${syntheticNamePrefix}RdfVocabularies {
   export const rdf = {
     first: ${imports.dataFactory}.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#first"),
+    langString: ${imports.dataFactory}.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"),
     nil: ${imports.dataFactory}.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil"),
     rest: ${imports.dataFactory}.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest"),
     subject: ${imports.dataFactory}.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#subject"),

package/dist/generators/ts/_snippets/snippets_bigDecimalFromRdfResourceValues.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_bigDecimalFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigDecimalFromRdfResourceValues`, code `\
 function ${syntheticNamePrefix}bigDecimalFromRdfResourceValues(values: ${imports.Resource}.Values, options: Parameters<${snippets.FromRdfResourceValuesFunction}<${imports.BigDecimal}, ${snippets.NumericSchema}<${imports.BigDecimal}>>>[1]): ${imports.Either}<Error, ${imports.Resource}.Values<${imports.BigDecimal}>> {
-  return ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => value.toLiteral().chain(${snippets.decodeBigDecimalLiteral})));
+  return ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => value.toBigDecimal(options.schema.in)));
 }`);
 //# sourceMappingURL=snippets_bigDecimalFromRdfResourceValues.js.map

package/dist/generators/ts/_snippets/snippets_convertToLangString.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_convertToLangString: SnippetFactory;
+//# sourceMappingURL=snippets_convertToLangString.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToLangString.js

@@ -0,0 +1,15 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToLangString = ({ imports, rdfjsTermExpression, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLangString`, code `\
+function ${syntheticNamePrefix}convertToLangString(value: ${imports.Literal}): ${imports.Either}<Error, ${imports.Literal}> {
+  if (!value.datatype.equals(${rdfjsTermExpression(rdf.langString)})) {
+    return ${imports.Left}(new Error(\`expected Literal to have rdf:langString datatype, not \${value.datatype.value}\`));
+  }
+
+  if (value.language.length === 0) {
+    return ${imports.Left}(new Error("expected Literal to have non-empty language"));
+  }
+
+  return ${imports.Either}.of(value);
+}`);
+//# sourceMappingURL=snippets_convertToLangString.js.map

package/dist/generators/ts/_snippets/snippets_langStringFromRdfResourceValues.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_langStringFromRdfResourceValues: SnippetFactory;
+//# sourceMappingURL=snippets_langStringFromRdfResourceValues.d.ts.map

package/dist/generators/ts/_snippets/snippets_langStringFromRdfResourceValues.js

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_langStringFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}langStringFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}langStringFromRdfResourceValues(values: ${imports.Resource}.Values, options: Parameters<${snippets.FromRdfResourceValuesFunction}<${imports.Literal}, ${snippets.LangStringSchema}>>[1]): ${imports.Either}<Error, ${imports.Resource}.Values<${imports.Literal}>> {
+  return ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => value.toLangString(options.schema.in)));
+}`);
+//# sourceMappingURL=snippets_langStringFromRdfResourceValues.js.map