@shaclmate/compiler 4.0.57 → 4.0.59

package/dist/generators/ts/AbstractPrimitiveType.d.ts

@@ -19,9 +19,9 @@ export declare namespace AbstractPrimitiveType {
     type ConversionFunction = AbstractLiteralType.ConversionFunction;
     type DiscriminantProperty = AbstractLiteralType.DiscriminantProperty;
     type JsType = AbstractLiteralType.JsType;
-    const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
+    const GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     type GraphqlType = AbstractLiteralType.GraphqlType;
-    const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
+    const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractLiteralType.JsonType;
 }
 //# sourceMappingURL=AbstractPrimitiveType.d.ts.map

package/dist/generators/ts/AbstractTermType.d.ts

@@ -41,10 +41,10 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
 export declare namespace AbstractTermType {
     type ConversionFunction = AbstractType.ConversionFunction;
     type DiscriminantProperty = AbstractType.DiscriminantProperty;
-    const GraphqlType: typeof AbstractType.GraphqlType;
+    const GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     type GraphqlType = AbstractType.GraphqlType;
     type JsType = AbstractType.JsType;
-    const JsonType: typeof AbstractType.JsonType;
+    const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractType.JsonType;
 }
 //# sourceMappingURL=AbstractTermType.d.ts.map

package/dist/generators/ts/AbstractType.d.ts

@@ -1,6 +1,11 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
 import type { Logger } from "ts-log";
+import type { AbstractType_ConversionFunction } from "./_AbstractType/AbstractType_ConversionFunction.js";
+import type { AbstractType_DiscriminantProperty } from "./_AbstractType/AbstractType_DiscriminantProperty.js";
+import { AbstractType_GraphqlType } from "./_AbstractType/AbstractType_GraphqlType.js";
+import { AbstractType_JsonType } from "./_AbstractType/AbstractType_JsonType.js";
+import { AbstractType_JsType } from "./_AbstractType/AbstractType_JsType.js";
 import type { Reusables } from "./Reusables.js";
 import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 import type { TsGenerator } from "./TsGenerator.js";
@@ -202,7 +207,7 @@ export declare abstract class AbstractType {
      *
      * This method is called in two contexts:
      * "property": from a ShaclProperty, while generating the z.object properties of an ObjectType
-     * "type": from another Type e.g., an OptionType or UnionType
+     * "type": from another Type e.g., an OptionType or DiscriminatedUnionType
      *
      * z.lazy() should only be returned for "property".
      */
@@ -265,81 +270,16 @@ export declare abstract class AbstractType {
     protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;
 }
 export declare namespace AbstractType {
-    interface ConversionFunction {
-        readonly code: Code;
-        readonly sourceTypes: {
-            readonly expression: Code;
-            readonly jsType: JsType;
-        }[];
-    }
-    interface DiscriminantProperty {
-        readonly jsonName: string;
-        readonly name: string;
-        readonly values: readonly DiscriminantProperty.Value[];
-    }
+    type ConversionFunction = AbstractType_ConversionFunction;
+    type DiscriminantProperty = AbstractType_DiscriminantProperty;
     namespace DiscriminantProperty {
-        type Value = number | string;
-    }
-    class GraphqlType {
-        /**
-         * Is the type nullable in GraphQL?
-         */
-        readonly nullable: boolean;
-        /**
-         * The expression of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
-         */
-        readonly nullableExpression: Code;
-        private readonly reusables;
-        constructor(nullableExpression: Code, reusables: Reusables, options?: {
-            nullable: boolean;
-        });
-        get expression(): Code;
-    }
-    type JsType = {
-        typeof: "bigint";
-    } | {
-        typeof: "boolean";
-    } | {
-        typeof: "function";
-    } | {
-        typeof: "number";
-    } | {
-        instanceof: "Array";
-        typeof: "object";
-    } | {
-        className: Code;
-        instanceof: "class";
-        typeof: "object";
-    } | {
-        instanceof: "Date";
-        typeof: "object";
-    } | {
-        instanceof: "Maybe";
-        typeof: "object";
-    } | {
-        instanceof: "Object";
-        typeof: "object";
-    } | {
-        typeof: "string";
-    } | {
-        typeof: "undefined";
-    };
-    namespace JsType {
-        function equals(left: JsType, right: JsType): boolean;
-    }
-    class JsonType {
-        /**
-         * Is the type optional in JSON? Equivalent to ? in TypeScript or | undefined.
-         */
-        readonly optional: boolean;
-        /**
-         * The expression of the type when it's required i.e. -- so it should never include "| undefined".
-         */
-        readonly requiredExpression: Code;
-        constructor(requiredExpression: Code, parameters?: {
-            optional: boolean;
-        });
-        get expression(): Code;
+        type Value = AbstractType_DiscriminantProperty.Value;
     }
+    const GraphqlType: typeof AbstractType_GraphqlType;
+    type GraphqlType = AbstractType_GraphqlType;
+    type JsType = AbstractType_JsType;
+    const JsType: typeof AbstractType_JsType;
+    const JsonType: typeof AbstractType_JsonType;
+    type JsonType = AbstractType_JsonType;
 }
 //# sourceMappingURL=AbstractType.d.ts.map

package/dist/generators/ts/AbstractType.js

@@ -5,6 +5,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Memoize } from "typescript-memoize";
+import { AbstractType_GraphqlType } from "./_AbstractType/AbstractType_GraphqlType.js";
+import { AbstractType_JsonType } from "./_AbstractType/AbstractType_JsonType.js";
+import { AbstractType_JsType } from "./_AbstractType/AbstractType_JsType.js";
 import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 /**
@@ -68,68 +71,8 @@ __decorate([
     Memoize()
 ], AbstractType.prototype, "schemaExpression", null);
 (function (AbstractType) {
-    class GraphqlType {
-        /**
-         * Is the type nullable in GraphQL?
-         */
-        nullable;
-        /**
-         * The expression of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
-         */
-        nullableExpression;
-        reusables;
-        constructor(nullableExpression, reusables, options) {
-            this.nullable = !!options?.nullable;
-            this.nullableExpression = nullableExpression;
-            this.reusables = reusables;
-        }
-        get expression() {
-            return this.nullable
-                ? this.nullableExpression
-                : code `new ${this.reusables.imports.GraphQLNonNull}(${this.nullableExpression})`;
-        }
-    }
-    __decorate([
-        Memoize()
-    ], GraphqlType.prototype, "expression", null);
-    AbstractType.GraphqlType = GraphqlType;
-    let JsType;
-    (function (JsType) {
-        function equals(left, right) {
-            if (left.typeof !== right.typeof) {
-                return false;
-            }
-            if (left.typeof === "object" &&
-                right.typeof === "object" &&
-                left.instanceof !== right.instanceof) {
-                return false;
-            }
-            return true;
-        }
-        JsType.equals = equals;
-    })(JsType = AbstractType.JsType || (AbstractType.JsType = {}));
-    class JsonType {
-        /**
-         * Is the type optional in JSON? Equivalent to ? in TypeScript or | undefined.
-         */
-        optional;
-        /**
-         * The expression of the type when it's required i.e. -- so it should never include "| undefined".
-         */
-        requiredExpression;
-        constructor(requiredExpression, parameters) {
-            this.optional = !!parameters?.optional;
-            this.requiredExpression = requiredExpression;
-        }
-        get expression() {
-            return this.optional
-                ? code `(${this.requiredExpression}) | undefined`
-                : this.requiredExpression;
-        }
-    }
-    __decorate([
-        Memoize()
-    ], JsonType.prototype, "expression", null);
-    AbstractType.JsonType = JsonType;
+    AbstractType.GraphqlType = AbstractType_GraphqlType;
+    AbstractType.JsType = AbstractType_JsType;
+    AbstractType.JsonType = AbstractType_JsonType;
 })(AbstractType || (AbstractType = {}));
 //# sourceMappingURL=AbstractType.js.map

package/dist/generators/ts/AbstractTypedLiteralType.d.ts

@@ -23,10 +23,10 @@ export declare abstract class AbstractTypedLiteralType<ValueT> extends AbstractL
 export declare namespace AbstractTypedLiteralType {
     type ConversionFunction = AbstractTermType.ConversionFunction;
     type DiscriminantProperty = AbstractTermType.DiscriminantProperty;
-    const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
+    const GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     type GraphqlType = AbstractTermType.GraphqlType;
     type JsType = AbstractTermType.JsType;
-    const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
+    const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractTermType.JsonType;
 }
 //# sourceMappingURL=AbstractTypedLiteralType.d.ts.map

package/dist/generators/ts/BigDecimalType.d.ts

@@ -18,7 +18,7 @@ export declare class BigDecimalType extends AbstractTypedLiteralType<Decimal> {
     readonly kind = "BigDecimal";
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
-    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
+    get graphqlType(): import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     jsonSchema(): Code;

package/dist/generators/ts/BigIntType.d.ts

@@ -7,7 +7,7 @@ export declare class BigIntType extends AbstractNumericType<bigint> {
     }[];
     readonly kind = "BigInt";
     get fromRdfResourceValuesFunction(): Code;
-    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
+    get graphqlType(): import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     fromJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromJsonExpression"]>[0]): Code;
     jsonSchema(_parameters: Parameters<AbstractNumericType<bigint>["jsonSchema"]>[0]): Code;
     jsonType(): AbstractNumericType.JsonType;

package/dist/generators/ts/BooleanType.d.ts

@@ -4,7 +4,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class BooleanType extends AbstractPrimitiveType<boolean> {
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
+    readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     readonly hashFunction: Code;
     readonly jsTypes: readonly [{
         readonly typeof: "boolean";

package/dist/generators/ts/DateTimeType.d.ts

@@ -2,7 +2,7 @@ import type { Literal } from "@rdfjs/types";
 import { AbstractDateType } from "./AbstractDateType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateTimeType extends AbstractDateType {
-    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
+    readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     readonly hashFunction: Code;
     readonly kind = "DateTime";
     get fromRdfResourceValuesFunction(): Code;

package/dist/generators/ts/DateType.d.ts

@@ -2,7 +2,7 @@ import type { Literal } from "@rdfjs/types";
 import { AbstractDateType } from "./AbstractDateType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateType extends AbstractDateType {
-    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
+    readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     readonly hashFunction: Code;
     readonly kind = "Date";
     get fromRdfResourceValuesFunction(): Code;

package/dist/generators/ts/DefaultValueType.d.ts

@@ -9,7 +9,7 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     readonly defaultValue: Literal | NamedNode;
     readonly discriminantProperty: Maybe<AbstractType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
-    readonly jsTypes: readonly AbstractType.JsType[] | readonly [{
+    readonly jsTypes: readonly import("./_AbstractType/AbstractType_JsType.js").AbstractType_JsType[] | readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";
     }] | readonly [{
@@ -35,6 +35,9 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     }] | readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";
+    }] | readonly [{
+        readonly instanceof: "Array";
+        readonly typeof: "object";
     }] | readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";
@@ -43,9 +46,6 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
         readonly typeof: "object";
     }] | readonly [{
         readonly typeof: "string";
-    }] | readonly [{
-        readonly instanceof: "Array";
-        readonly typeof: "object";
     }] | readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";

package/dist/generators/ts/DefaultValueType.js

@@ -80,8 +80,8 @@ export class DefaultValueType extends AbstractContainerType {
                 return this.rdfjsTermExpression(this.defaultValue);
             case "List":
             case "Object":
-            case "ObjectUnion":
-            case "Union":
+            case "ObjectDiscriminatedUnion":
+            case "DiscriminatedUnion":
                 throw new RangeError(`not implemented ${this.itemType.kind}`);
         }
         invariant(this.defaultValue.termType === "Literal");

package/dist/generators/ts/{UnionType.d.ts → DiscriminatedUnionType.d.ts}

@@ -6,17 +6,17 @@ import type { IriType } from "./IriType.js";
 import type { Type } from "./Type.js";
 import type { Typeof } from "./Typeof.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare class UnionType<MemberTypeT extends Type> extends AbstractType {
+export declare class DiscriminatedUnionType<MemberTypeT extends Type> extends AbstractType {
     private readonly discriminant;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
-    readonly kind: "ObjectUnion" | "Union";
+    readonly kind: "ObjectDiscriminatedUnion" | "DiscriminatedUnion";
     readonly recursive: boolean;
     readonly synthetic: boolean;
     readonly validationFunction: Maybe<Code>;
     constructor({ identifierType, members, recursive, synthetic, ...superParameters }: {
         identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
-        members: readonly (Pick<AbstractUnionType.Member<MemberTypeT>, "type"> & {
+        members: readonly (Pick<DiscriminatedUnionType.Member<MemberTypeT>, "type"> & {
             readonly discriminantValue: Maybe<number | string>;
         })[];
         recursive: boolean;
@@ -35,7 +35,7 @@ export declare class UnionType<MemberTypeT extends Type> extends AbstractType {
     get jsTypes(): AbstractType["jsTypes"];
     get jsonSchemaFunctionDeclaration(): Code;
     get jsonTypeAliasDeclaration(): Code;
-    get members(): readonly AbstractUnionType.Member<MemberTypeT>[];
+    get members(): readonly DiscriminatedUnionType.Member<MemberTypeT>[];
     get mutable(): boolean;
     get referencesNamedType(): boolean;
     get schema(): Code;
@@ -109,7 +109,7 @@ export declare namespace Discriminant {
         readonly type: Type;
     }[]): Discriminant;
 }
-export declare namespace AbstractUnionType {
+export declare namespace DiscriminatedUnionType {
     interface Member<TypeT extends Type> {
         readonly discriminantValues: readonly AbstractType.DiscriminantProperty.Value[];
         readonly jsonType: Code;
@@ -123,4 +123,4 @@ export declare namespace AbstractUnionType {
     }
 }
 export {};
-//# sourceMappingURL=UnionType.d.ts.map
+//# sourceMappingURL=DiscriminatedUnionType.d.ts.map

package/dist/generators/ts/{UnionType.js → DiscriminatedUnionType.js}

@@ -9,11 +9,11 @@ import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
 import { code, def, joinCode, literalOf, } from "./ts-poet-wrapper.js";
-export class UnionType extends AbstractType {
+export class DiscriminatedUnionType extends AbstractType {
     discriminant;
     graphqlArgs = Maybe.empty();
     identifierType;
-    kind = "Union";
+    kind = "DiscriminatedUnion";
     recursive;
     synthetic;
     validationFunction = Maybe.empty();
@@ -54,7 +54,7 @@ export class UnionType extends AbstractType {
                 if (discriminant.kind === "Intrinsic" && !json) {
                     switch (member.type.kind) {
                         case "Object":
-                        case "ObjectUnion":
+                        case "ObjectDiscriminatedUnion":
                             return code `${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(${instance})`;
                     }
                 }
@@ -633,85 +633,85 @@ unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...oth
 }
 __decorate([
     Memoize()
-], UnionType.prototype, "conversionFunction", null);
+], DiscriminatedUnionType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "declaration", null);
+], DiscriminatedUnionType.prototype, "declaration", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "discriminantProperty", null);
+], DiscriminatedUnionType.prototype, "discriminantProperty", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "equalsFunction", null);
+], DiscriminatedUnionType.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "expression", null);
+], DiscriminatedUnionType.prototype, "expression", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "filterFunction", null);
+], DiscriminatedUnionType.prototype, "filterFunction", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "filterType", null);
+], DiscriminatedUnionType.prototype, "filterType", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "fromRdfResourceValuesFunction", null);
+], DiscriminatedUnionType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "graphqlType", null);
+], DiscriminatedUnionType.prototype, "graphqlType", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "hashFunction", null);
+], DiscriminatedUnionType.prototype, "hashFunction", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "jsTypes", null);
+], DiscriminatedUnionType.prototype, "jsTypes", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "members", null);
+], DiscriminatedUnionType.prototype, "members", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "mutable", null);
+], DiscriminatedUnionType.prototype, "mutable", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "schema", null);
+], DiscriminatedUnionType.prototype, "schema", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "schemaType", null);
+], DiscriminatedUnionType.prototype, "schemaType", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "toRdfResourceValueTypes", null);
+], DiscriminatedUnionType.prototype, "toRdfResourceValueTypes", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "valueSparqlConstructTriplesFunction", null);
+], DiscriminatedUnionType.prototype, "valueSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "valueSparqlWherePatternsFunction", null);
+], DiscriminatedUnionType.prototype, "valueSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "schemaTypeExpression", null);
+], DiscriminatedUnionType.prototype, "schemaTypeExpression", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "equalsFunctionExpression", null);
+], DiscriminatedUnionType.prototype, "equalsFunctionExpression", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "filterFunctionExpression", null);
+], DiscriminatedUnionType.prototype, "filterFunctionExpression", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "filterTypeLiteral", null);
+], DiscriminatedUnionType.prototype, "filterTypeLiteral", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "inlineExpression", null);
+], DiscriminatedUnionType.prototype, "inlineExpression", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "jsonTypeLiteral", null);
+], DiscriminatedUnionType.prototype, "jsonTypeLiteral", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "valueSparqlConstructTriplesFunctionExpression", null);
+], DiscriminatedUnionType.prototype, "valueSparqlConstructTriplesFunctionExpression", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "valueSparqlWherePatternsFunctionExpression", null);
+], DiscriminatedUnionType.prototype, "valueSparqlWherePatternsFunctionExpression", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "jsonType", null);
+], DiscriminatedUnionType.prototype, "jsonType", null);
 function termTypes(type) {
     switch (type.kind) {
         case "BlankNode":
@@ -847,4 +847,4 @@ export var Discriminant;
     }
     Discriminant.infer = infer;
 })(Discriminant || (Discriminant = {}));
-//# sourceMappingURL=UnionType.js.map
+//# sourceMappingURL=DiscriminatedUnionType.js.map

package/dist/generators/ts/FloatType.d.ts

@@ -7,7 +7,7 @@ export declare class FloatType extends AbstractNumericType<number> {
     }];
     readonly kind = "Float";
     get fromRdfResourceValuesFunction(): Code;
-    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
+    get graphqlType(): import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     literalValueExpression(literal: Literal | number): Code;
 }
 //# sourceMappingURL=FloatType.d.ts.map

package/dist/generators/ts/GraphqlSchema.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from "ts-log";
+import type { ObjectDiscriminatedUnionType } from "./ObjectDiscriminatedUnionType.js";
 import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
 import type { Reusables } from "./Reusables.js";
 import type { TsGenerator } from "./TsGenerator.js";
 import { type Code } from "./ts-poet-wrapper.js";
@@ -8,12 +8,12 @@ export declare class GraphqlSchema {
     private readonly configuration;
     private readonly reusables;
     private readonly namedObjectTypes;
-    private readonly namedObjectUnionTypes;
-    constructor({ configuration, namedObjectTypes, namedObjectUnionTypes, reusables, }: {
+    private readonly namedObjectDiscriminatedUnionTypes;
+    constructor({ configuration, namedObjectTypes, namedObjectDiscriminatedUnionTypes, reusables, }: {
         configuration: TsGenerator.Configuration;
         logger: Logger;
         namedObjectTypes: readonly ObjectType[];
-        namedObjectUnionTypes: readonly ObjectUnionType[];
+        namedObjectDiscriminatedUnionTypes: readonly ObjectDiscriminatedUnionType[];
         reusables: Reusables;
     });
     get declaration(): Code;

package/dist/generators/ts/GraphqlSchema.js

@@ -3,11 +3,12 @@ export class GraphqlSchema {
     configuration;
     reusables;
     namedObjectTypes;
-    namedObjectUnionTypes;
-    constructor({ configuration, namedObjectTypes, namedObjectUnionTypes, reusables, }) {
+    namedObjectDiscriminatedUnionTypes;
+    constructor({ configuration, namedObjectTypes, namedObjectDiscriminatedUnionTypes, reusables, }) {
         this.configuration = configuration;
         this.namedObjectTypes = namedObjectTypes;
-        this.namedObjectUnionTypes = namedObjectUnionTypes;
+        this.namedObjectDiscriminatedUnionTypes =
+            namedObjectDiscriminatedUnionTypes;
         this.reusables = reusables;
     }
     get declaration() {
@@ -19,7 +20,7 @@ export const graphqlSchema = new ${this.reusables.imports.GraphQLSchema}({ query
         const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
         return code `new ${this.reusables.imports.GraphQLObjectType}<null, { objectSet: ${syntheticNamePrefix}ObjectSet }>({ name: "Query", fields: ${[
             ...this.namedObjectTypes,
-            ...this.namedObjectUnionTypes,
+            ...this.namedObjectDiscriminatedUnionTypes,
         ].reduce((fields, namedObjectType) => {
             fields[namedObjectType.objectSetMethodNames.object] = {
                 args: {

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

@@ -7,7 +7,7 @@ export declare class IntType extends AbstractNumericType<number> {
     }];
     readonly kind = "Int";
     get fromRdfResourceValuesFunction(): Code;
-    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
+    get graphqlType(): import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     literalValueExpression(literal: Literal | number): Code;
 }
 //# sourceMappingURL=IntType.d.ts.map

package/dist/generators/ts/LazyOptionType.d.ts

@@ -15,9 +15,9 @@ declare const Super: (abstract new ({ partialType, resolveType, ...superParamete
     reusables: import("./Reusables.js").Reusables;
     shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode;
 }) => AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>>) & {
-    readonly GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
-    readonly JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
-    JsType: typeof import("./AbstractType.js").AbstractType.JsType;
+    readonly GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
+    readonly JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
+    readonly JsType: typeof import("./_AbstractType/AbstractType_JsType.js").AbstractType_JsType;
 };
 export declare class LazyOptionType extends Super {
     readonly graphqlArgs: Super["graphqlArgs"];

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

@@ -7,19 +7,19 @@ 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 { DiscriminatedUnionType } from "./DiscriminatedUnionType.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 { LangStringType } from "./LangStringType.js";
 import type { LiteralType } from "./LiteralType.js";
+import type { ObjectDiscriminatedUnionType } from "./ObjectDiscriminatedUnionType.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;
@@ -44,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 | LangStringType | 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 | ObjectDiscriminatedUnionType | ObjectType | StringType | TermType | DiscriminatedUnionType<Type>;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=ListType.d.ts.map

package/dist/generators/ts/ListType.js

@@ -142,11 +142,11 @@ __decorate([
             case "LangString":
             case "List":
             case "Literal":
-            case "ObjectUnion":
+            case "ObjectDiscriminatedUnion":
             case "Object":
             case "String":
             case "Term":
-            case "Union":
+            case "DiscriminatedUnion":
                 return true;
             case "DefaultValue":
             case "LazyOption":