@shaclmate/compiler 4.0.57 → 4.0.60

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstStructTypeField.js

@@ -161,11 +161,11 @@ export function transformPropertyShapeToAstStructTypeField({ propertyShape, stru
                 switch (astResolveType.kind) {
                     case "Struct":
                         return Either.of(astResolveType);
-                    case "Union":
+                    case "DiscriminatedUnion":
                         if (
                         // This check relies on .members being populated, which may not happen in cycles
                         astResolveType.members.length > 0 &&
-                            !astResolveType.isStructUnionType()) {
+                            !astResolveType.isStructDiscriminatedUnionType()) {
                             return Left(new Error(`${propertyShape} resolve cannot refer to a ${astResolveType.kind} with non-StructType members`));
                         }
                         return Either.of(astResolveType);
@@ -207,8 +207,8 @@ export function transformPropertyShapeToAstStructTypeField({ propertyShape, stru
                 case "Struct":
                     astPartialItemType = astItemType;
                     break;
-                case "Union":
-                    if (!astItemType.isStructUnionType()) {
+                case "DiscriminatedUnion":
+                    if (!astItemType.isStructDiscriminatedUnionType()) {
                         return Left(new Error(`${propertyShape} partial type cannot be a ${astItemType.kind} with non-StructType members`));
                     }
                     astPartialItemType = astItemType;
@@ -227,7 +227,7 @@ export function transformPropertyShapeToAstStructTypeField({ propertyShape, stru
                 case "Identifier":
                 case "Iri":
                 case "Struct":
-                case "Union":
+                case "DiscriminatedUnion":
                     astType = new ast.LazyType({
                         ...astAbstractTypeProperties,
                         partialType: astPartialItemType,

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompoundType.js

@@ -25,7 +25,7 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
             }
             else if (xoneConstraintShapes.length > 0) {
                 memberShapes = xoneConstraintShapes;
-                compoundTypeKind = "Union";
+                compoundTypeKind = "DiscriminatedUnion";
             }
             else {
                 return Either.of(Maybe.empty());
@@ -34,7 +34,7 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
             const memberDiscriminantValues = new Set();
             const compoundType = new (compoundTypeKind === "Intersection"
                 ? ast.IntersectionType
-                : ast.UnionType)({
+                : ast.DiscriminatedUnionType)({
                 comment: shape.comment,
                 label: shape.label,
                 name: shapeAstTypeName(shape),
@@ -61,7 +61,7 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
                         return Left(new Error(`${shape} has duplicate ${compoundTypeKind} member type: ${memberType}`));
                     }
                     let memberDiscriminantValue;
-                    if (compoundTypeKind === "Union") {
+                    if (compoundTypeKind === "DiscriminatedUnion") {
                         if (memberShape.$type === "NodeShape") {
                             memberDiscriminantValue =
                                 memberShape.discriminantValue.extract();

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstStructType.js

@@ -20,7 +20,7 @@ function isStructTypeFieldRequired(field) {
             return false;
         case "Set":
             return field.type.minCount > 0;
-        case "Union":
+        case "DiscriminatedUnion":
             return field.type.members.every((member) => isStructTypeFieldRequired({ type: member.type }));
         case "BlankNode":
         case "Identifier":

package/dist/ast/AbstractCompoundType.d.ts

@@ -1,6 +1,7 @@
 import type { NodeKind } from "@shaclmate/shacl-ast";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
+import type { DiscriminatedUnionType } from "./DiscriminatedUnionType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IntersectionType } from "./IntersectionType.js";
 import type { IriType } from "./IriType.js";
@@ -9,7 +10,6 @@ import type { LiteralType } from "./LiteralType.js";
 import type { StructType } from "./StructType.js";
 import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
-import type { UnionType } from "./UnionType.js";
 /**
  * A compound of types, such as an intersection or union.
  *
@@ -21,7 +21,7 @@ export declare abstract class AbstractCompoundType<MemberT extends AbstractCompo
     /**
      * Type discriminant
      */
-    abstract readonly kind: "Intersection" | "Union";
+    abstract readonly kind: "Intersection" | "DiscriminatedUnion";
     /**
      * Was this type synthesized or did it come from SHACL?
      */
@@ -39,7 +39,7 @@ export declare namespace AbstractCompoundType {
     interface Member<TypeT extends MemberType> {
         readonly type: TypeT;
     }
-    type MemberType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | StructType | TermType | UnionType;
+    type MemberType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | StructType | TermType | DiscriminatedUnionType;
     function isMemberType(type: Type): type is MemberType;
 }
 //# sourceMappingURL=AbstractCompoundType.d.ts.map

package/dist/ast/AbstractCompoundType.js

@@ -65,7 +65,7 @@ __decorate([
             case "Literal":
             case "Struct":
             case "Term":
-            case "Union":
+            case "DiscriminatedUnion":
                 return true;
             case "DefaultValue":
             case "LazyOption":

package/dist/ast/AbstractContainerType.d.ts

@@ -1,6 +1,7 @@
 import type { NodeKind } from "@shaclmate/shacl-ast";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
+import type { DiscriminatedUnionType } from "./DiscriminatedUnionType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IntersectionType } from "./IntersectionType.js";
 import type { IriType } from "./IriType.js";
@@ -9,7 +10,6 @@ import type { LiteralType } from "./LiteralType.js";
 import type { StructType } from "./StructType.js";
 import type { TermType } from "./TermType.js";
 import { Type } from "./Type.js";
-import type { UnionType } from "./UnionType.js";
 /**
  * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
  */
@@ -38,7 +38,7 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
     };
 }
 export declare namespace AbstractContainerType {
-    type ItemType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | StructType | TermType | UnionType;
+    type ItemType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | StructType | TermType | DiscriminatedUnionType;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=AbstractContainerType.d.ts.map

package/dist/ast/AbstractContainerType.js

@@ -47,7 +47,7 @@ export class AbstractContainerType extends AbstractType {
             case "Literal":
             case "Struct":
             case "Term":
-            case "Union":
+            case "DiscriminatedUnion":
                 return true;
             case "DefaultValue":
             case "LazyOption":

package/dist/ast/AbstractLazyType.d.ts

@@ -2,8 +2,8 @@ import type { NodeKind } from "@shaclmate/shacl-ast";
 import { AbstractType } from "./AbstractType.js";
 import type { OptionType } from "./OptionType.js";
 import type { SetType } from "./SetType.js";
+import type { StructDiscriminatedUnionType } from "./StructDiscriminatedUnionType.js";
 import type { StructType } from "./StructType.js";
-import type { StructUnionType } from "./StructUnionType.js";
 /**
  * Abstract base class of LazyOptionType, LazySetType, and LazyType.
  */
@@ -110,7 +110,7 @@ export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazy
     };
 }
 export declare namespace AbstractLazyType {
-    type ItemTypeConstraint = StructType | StructUnionType;
+    type ItemTypeConstraint = StructType | StructDiscriminatedUnionType;
     type PartialTypeConstraint = ItemTypeConstraint | OptionType<ItemTypeConstraint> | SetType<ItemTypeConstraint>;
     type ResolveTypeConstraint = PartialTypeConstraint;
 }

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

@@ -1,12 +1,12 @@
 import type { Maybe } from "purify-ts";
 import { AbstractCompoundType } from "./AbstractCompoundType.js";
-import type { StructUnionType } from "./StructUnionType.js";
+import type { StructDiscriminatedUnionType } from "./StructDiscriminatedUnionType.js";
 /**
  * A disjunction/union of types, corresponding to an sh:xone.
  */
-export declare class UnionType<MemberTypeT extends UnionType.MemberType = UnionType.MemberType> extends AbstractCompoundType<UnionType.Member<MemberTypeT>, MemberTypeT> {
-    readonly kind = "Union";
-    isStructUnionType(): this is StructUnionType;
+export declare class DiscriminatedUnionType<MemberTypeT extends DiscriminatedUnionType.MemberType = DiscriminatedUnionType.MemberType> extends AbstractCompoundType<DiscriminatedUnionType.Member<MemberTypeT>, MemberTypeT> {
+    readonly kind = "DiscriminatedUnion";
+    isStructDiscriminatedUnionType(): this is StructDiscriminatedUnionType;
     toJSON(): {
         members: {
             discriminantValue: string | number | undefined;
@@ -20,11 +20,11 @@ export declare class UnionType<MemberTypeT extends UnionType.MemberType = UnionT
         shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
     };
 }
-export declare namespace UnionType {
-    interface Member<TypeT extends UnionType.MemberType> extends AbstractCompoundType.Member<TypeT> {
+export declare namespace DiscriminatedUnionType {
+    interface Member<TypeT extends DiscriminatedUnionType.MemberType> extends AbstractCompoundType.Member<TypeT> {
         readonly discriminantValue: Maybe<number | string>;
     }
     type MemberType = AbstractCompoundType.MemberType;
     const isMemberType: typeof AbstractCompoundType.isMemberType;
 }
-//# sourceMappingURL=UnionType.d.ts.map
+//# sourceMappingURL=DiscriminatedUnionType.d.ts.map

package/dist/ast/{UnionType.js → DiscriminatedUnionType.js}

@@ -2,12 +2,13 @@ import { AbstractCompoundType } from "./AbstractCompoundType.js";
 /**
  * A disjunction/union of types, corresponding to an sh:xone.
  */
-export class UnionType extends AbstractCompoundType {
-    kind = "Union";
-    isStructUnionType() {
+export class DiscriminatedUnionType extends AbstractCompoundType {
+    kind = "DiscriminatedUnion";
+    isStructDiscriminatedUnionType() {
         return (this.members.length > 0 &&
             this.members.every((member) => member.type.kind === "Struct" ||
-                (member.type.kind === "Union" && member.type.isStructUnionType())));
+                (member.type.kind === "DiscriminatedUnion" &&
+                    member.type.isStructDiscriminatedUnionType())));
     }
     toJSON() {
         return {
@@ -21,7 +22,7 @@ export class UnionType extends AbstractCompoundType {
         };
     }
 }
-(function (UnionType) {
-    UnionType.isMemberType = AbstractCompoundType.isMemberType;
-})(UnionType || (UnionType = {}));
-//# sourceMappingURL=UnionType.js.map
+(function (DiscriminatedUnionType) {
+    DiscriminatedUnionType.isMemberType = AbstractCompoundType.isMemberType;
+})(DiscriminatedUnionType || (DiscriminatedUnionType = {}));
+//# sourceMappingURL=DiscriminatedUnionType.js.map

package/dist/ast/ListType.d.ts

@@ -2,6 +2,7 @@ import type { BlankNode, NamedNode } from "@rdfjs/types";
 import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
+import type { DiscriminatedUnionType } from "./DiscriminatedUnionType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IntersectionType } from "./IntersectionType.js";
 import type { IriType } from "./IriType.js";
@@ -9,7 +10,6 @@ import type { LiteralType } from "./LiteralType.js";
 import type { StructType } from "./StructType.js";
 import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
-import type { UnionType } from "./UnionType.js";
 /**
  * An ordered sequence of items with zero or one values of an item type.
  *
@@ -38,7 +38,7 @@ export declare class ListType<ItemTypeT extends ListType.ItemType = ListType.Ite
     equals(other: ListType<ItemTypeT>): boolean;
 }
 export declare namespace ListType {
-    type ItemType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | StructType | TermType | UnionType;
+    type ItemType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | StructType | TermType | DiscriminatedUnionType;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=ListType.d.ts.map

package/dist/ast/ListType.js

@@ -40,7 +40,7 @@ export class ListType extends AbstractCollectionType {
             case "Literal":
             case "Struct":
             case "Term":
-            case "Union":
+            case "DiscriminatedUnion":
                 return true;
             case "DefaultValue":
             case "LazyOption":

package/dist/ast/StructCompoundType.d.ts

@@ -1,10 +1,10 @@
 import { BlankNodeType } from "./BlankNodeType.js";
 import { IdentifierType } from "./IdentifierType.js";
 import { IriType } from "./IriType.js";
+import type { StructDiscriminatedUnionType } from "./StructDiscriminatedUnionType.js";
 import type { StructIntersectionType } from "./StructIntersectionType.js";
 import type { StructType } from "./StructType.js";
-import type { StructUnionType } from "./StructUnionType.js";
-export type StructCompoundType = StructIntersectionType | StructUnionType;
+export type StructCompoundType = StructIntersectionType | StructDiscriminatedUnionType;
 export declare namespace StructCompoundType {
     function identifierType(objectCompoundType: StructCompoundType): BlankNodeType | IdentifierType | IriType;
     function memberStructTypes(objectCompoundType: StructCompoundType): readonly StructType[];

package/dist/ast/StructCompoundType.js

@@ -58,7 +58,7 @@ export var StructCompoundType;
                     memberStructTypes_.push(member.type);
                     break;
                 case "Intersection":
-                case "Union": {
+                case "DiscriminatedUnion": {
                     invariant(member.type.kind === objectCompoundType.kind);
                     memberStructTypes_.push(...memberStructTypes(member.type));
                     break;

package/dist/ast/StructDiscriminatedUnionType.d.ts

@@ -0,0 +1,4 @@
+import type { DiscriminatedUnionType } from "./DiscriminatedUnionType.js";
+import type { StructType } from "./StructType.js";
+export type StructDiscriminatedUnionType = DiscriminatedUnionType<DiscriminatedUnionType<StructType> | StructType>;
+//# sourceMappingURL=StructDiscriminatedUnionType.d.ts.map

package/dist/ast/StructDiscriminatedUnionType.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=StructDiscriminatedUnionType.js.map

package/dist/ast/StructType.js

@@ -260,7 +260,7 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
                         return false;
                     }
                     case "Intersection":
-                    case "Union": {
+                    case "DiscriminatedUnion": {
                         if (DEBUG) {
                             process.stderr.write(`recurse into ${currentFieldType}`);
                         }

package/dist/ast/Type.d.ts

@@ -1,5 +1,6 @@
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { DefaultValueType } from "./DefaultValueType.js";
+import type { DiscriminatedUnionType } from "./DiscriminatedUnionType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IntersectionType } from "./IntersectionType.js";
 import type { IriType } from "./IriType.js";
@@ -12,8 +13,7 @@ import type { OptionType } from "./OptionType.js";
 import type { SetType } from "./SetType.js";
 import type { StructType } from "./StructType.js";
 import type { TermType } from "./TermType.js";
-import type { UnionType } from "./UnionType.js";
-export type Type = BlankNodeType | DefaultValueType | IdentifierType | IntersectionType | IriType | LazyOptionType | LazySetType | LazyType | ListType | LiteralType | StructType | OptionType | SetType | TermType | UnionType;
+export type Type = BlankNodeType | DefaultValueType | IdentifierType | IntersectionType | IriType | LazyOptionType | LazySetType | LazyType | ListType | LiteralType | StructType | OptionType | SetType | TermType | DiscriminatedUnionType;
 export declare namespace Type {
     function equals(left: Type, right: Type): boolean;
 }

package/dist/ast/Type.js

@@ -31,7 +31,7 @@ export var Type;
                 return left.equals(right);
             case "Term":
                 return left.equals(right);
-            case "Union":
+            case "DiscriminatedUnion":
                 return left.equals(right);
             case "Set":
                 return left.equals(right);

package/dist/ast/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./Ast.js";
 export * from "./BlankNodeType.js";
 export * from "./DefaultValueType.js";
+export * from "./DiscriminatedUnionType.js";
 export * from "./IdentifierType.js";
 export * from "./IntersectionType.js";
 export * from "./IriType.js";
@@ -12,10 +13,9 @@ export * from "./LiteralType.js";
 export * from "./OptionType.js";
 export * from "./SetType.js";
 export * from "./StructCompoundType.js";
+export * from "./StructDiscriminatedUnionType.js";
 export * from "./StructIntersectionType.js";
 export * from "./StructType.js";
-export * from "./StructUnionType.js";
 export * from "./TermType.js";
 export * from "./Type.js";
-export * from "./UnionType.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/ast/index.js

@@ -1,6 +1,7 @@
 export * from "./Ast.js";
 export * from "./BlankNodeType.js";
 export * from "./DefaultValueType.js";
+export * from "./DiscriminatedUnionType.js";
 export * from "./IdentifierType.js";
 export * from "./IntersectionType.js";
 export * from "./IriType.js";
@@ -12,10 +13,9 @@ export * from "./LiteralType.js";
 export * from "./OptionType.js";
 export * from "./SetType.js";
 export * from "./StructCompoundType.js";
+export * from "./StructDiscriminatedUnionType.js";
 export * from "./StructIntersectionType.js";
 export * from "./StructType.js";
-export * from "./StructUnionType.js";
 export * from "./TermType.js";
 export * from "./Type.js";
-export * from "./UnionType.js";
 //# sourceMappingURL=index.js.map

package/dist/generators/transformAstToLabeledPropertyGraph.js

@@ -32,7 +32,7 @@ export function transformAstToLabeledPropertyGraph(ast) {
                 switch (itemType.kind) {
                     case "Intersection":
                     case "Struct":
-                    case "Union":
+                    case "DiscriminatedUnion":
                         if (itemType.name.isJust()) {
                             relationships.push({
                                 id: namedObjectTypeProperty.shapeIdentifier.toString(),
@@ -56,7 +56,7 @@ export function transformAstToLabeledPropertyGraph(ast) {
                 properties: properties,
             });
         }
-        else if (namedType.kind === "Union") {
+        else if (namedType.kind === "DiscriminatedUnion") {
             nodes.push({
                 id: typeId(namedType),
                 label: typeName(namedType),

package/dist/generators/ts/AbstractCollectionType.d.ts

@@ -27,11 +27,11 @@ export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractC
 export declare namespace AbstractCollectionType {
     type ConversionFunction = AbstractContainerType.ConversionFunction;
     type DiscriminantProperty = AbstractContainerType.DiscriminantProperty;
-    const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
+    const GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     type GraphqlType = AbstractContainerType.GraphqlType;
     const isItemType: typeof AbstractContainerType.isItemType;
     type ItemType = AbstractContainerType.ItemType;
-    const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
+    const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractContainerType.JsonType;
 }
 //# sourceMappingURL=AbstractCollectionType.d.ts.map

package/dist/generators/ts/AbstractContainerType.d.ts

@@ -6,6 +6,7 @@ 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";
@@ -13,13 +14,12 @@ import type { IriType } from "./IriType.js";
 import type { LangStringType } from "./LangStringType.js";
 import type { ListType } from "./ListType.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";
 /**
  * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
  */
@@ -44,11 +44,11 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
 export declare namespace AbstractContainerType {
     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 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;
-    const JsonType: typeof AbstractType.JsonType;
+    const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractType.JsonType;
 }
 //# sourceMappingURL=AbstractContainerType.d.ts.map

package/dist/generators/ts/AbstractContainerType.js

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

package/dist/generators/ts/AbstractIdentifierType.d.ts

@@ -11,7 +11,7 @@ export declare abstract class AbstractIdentifierType<IdentifierT extends BlankNo
     abstract readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
     abstract readonly parseFunction: Code;
     readonly stringifyFunction: Code;
-    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
+    get graphqlType(): import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     graphqlResolveExpression({ variables: { value }, }: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
 }
 export declare namespace AbstractIdentifierType {

package/dist/generators/ts/AbstractLazyType.d.ts

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
+import type { ObjectDiscriminatedUnionType } from "./ObjectDiscriminatedUnionType.js";
 import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
 import type { OptionType } from "./OptionType.js";
 import type { SetType } from "./SetType.js";
 import { type Code } from "./ts-poet-wrapper.js";
@@ -45,23 +45,23 @@ export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazy
         partialType: ObjectTypeT;
         resolveType: ObjectTypeT;
     }): Code;
-    protected resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType, partialObjectUnionType, variables, }: {
-        resolvedObjectUnionType: ObjectUnionType;
-        partialObjectUnionType: ObjectUnionType;
+    protected resolvedObjectDiscriminatedUnionTypeToPartialObjectDiscriminatedUnionTypeConversion({ resolvedObjectDiscriminatedUnionType, partialObjectDiscriminatedUnionType, variables, }: {
+        resolvedObjectDiscriminatedUnionType: ObjectDiscriminatedUnionType;
+        partialObjectDiscriminatedUnionType: ObjectDiscriminatedUnionType;
         variables: {
-            resolvedObjectUnion: Code;
+            resolvedObjectDiscriminatedUnion: Code;
         };
     }): Code;
 }
 export declare namespace AbstractLazyType {
-    type ItemTypeConstraint = ObjectType | ObjectUnionType;
+    type ItemTypeConstraint = ObjectType | ObjectDiscriminatedUnionType;
     type PartialTypeConstraint = ItemTypeConstraint | OptionType<ItemTypeConstraint> | SetType<ItemTypeConstraint>;
     type ResolveTypeConstraint = PartialTypeConstraint;
     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;
-    const JsonType: typeof AbstractType.JsonType;
+    const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractType.JsonType;
 }
 //# sourceMappingURL=AbstractLazyType.d.ts.map

package/dist/generators/ts/AbstractLazyType.js

@@ -107,8 +107,8 @@ export class AbstractLazyType extends AbstractType {
         if (partialType.kind === "Object") {
             return code `${partialType.name.unsafeCoerce()}.createUnsafe`;
         }
-        invariant(partialType.kind === "ObjectUnion");
-        invariant(resolveType.kind === "ObjectUnion");
+        invariant(partialType.kind === "ObjectDiscriminatedUnion");
+        invariant(resolveType.kind === "ObjectDiscriminatedUnion");
         invariant(partialType.members.length === resolveType.members.length);
         const caseBlocks = resolveType.members.map(({ discriminantValues }, memberI) => {
             return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialType.members[memberI].type.name.unsafeCoerce()}.createUnsafe(resolved);`;
@@ -116,14 +116,14 @@ export class AbstractLazyType extends AbstractType {
         caseBlocks.push(code `default: resolved satisfies never; throw new Error("unrecognized type");`);
         return code `((resolved: ${resolveType.expression}) => { switch (resolved.${resolveType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} } })`;
     }
-    resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType, partialObjectUnionType, variables, }) {
-        invariant(resolvedObjectUnionType.members.length ===
-            partialObjectUnionType.members.length);
-        const caseBlocks = resolvedObjectUnionType.members.map(({ discriminantValues }, memberI) => {
-            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialObjectUnionType.members[memberI].type.name.unsafeCoerce()}.create(${variables.resolvedObjectUnion});`;
+    resolvedObjectDiscriminatedUnionTypeToPartialObjectDiscriminatedUnionTypeConversion({ resolvedObjectDiscriminatedUnionType, partialObjectDiscriminatedUnionType, variables, }) {
+        invariant(resolvedObjectDiscriminatedUnionType.members.length ===
+            partialObjectDiscriminatedUnionType.members.length);
+        const caseBlocks = resolvedObjectDiscriminatedUnionType.members.map(({ discriminantValues }, memberI) => {
+            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialObjectDiscriminatedUnionType.members[memberI].type.name.unsafeCoerce()}.create(${variables.resolvedObjectDiscriminatedUnion});`;
         });
-        caseBlocks.push(code `default: ${variables.resolvedObjectUnion} satisfies never; throw new Error("unrecognized type");`);
-        return code `switch (${variables.resolvedObjectUnion}.${resolvedObjectUnionType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} }`;
+        caseBlocks.push(code `default: ${variables.resolvedObjectDiscriminatedUnion} satisfies never; throw new Error("unrecognized type");`);
+        return code `switch (${variables.resolvedObjectDiscriminatedUnion}.${resolvedObjectDiscriminatedUnionType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} }`;
     }
 }
 __decorate([

package/dist/generators/ts/AbstractLiteralType.d.ts

@@ -16,10 +16,10 @@ export declare abstract class AbstractLiteralType extends AbstractTermType<Liter
 export declare namespace AbstractLiteralType {
     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=AbstractLiteralType.d.ts.map

package/dist/generators/ts/AbstractNumericType.d.ts

@@ -13,7 +13,7 @@ export declare abstract class AbstractNumericType<ValueT extends bigint | number
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
 }
 export declare namespace AbstractNumericType {
-    const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
+    const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractPrimitiveType.JsonType;
 }
 //# sourceMappingURL=AbstractNumericType.d.ts.map

package/dist/generators/ts/AbstractObjectSetType.d.ts

@@ -1,7 +1,7 @@
 import type { Maybe } from "purify-ts";
 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";
@@ -10,12 +10,12 @@ export declare abstract class AbstractObjectSetType {
     protected readonly logger: Logger;
     protected readonly reusables: Reusables;
     protected readonly namedObjectTypes: readonly ObjectType[];
-    protected readonly namedObjectUnionTypes: readonly ObjectUnionType[];
-    constructor({ configuration, logger, namedObjectTypes, namedObjectUnionTypes, reusables, }: {
+    protected readonly namedObjectDiscriminatedUnionTypes: readonly ObjectDiscriminatedUnionType[];
+    constructor({ configuration, logger, namedObjectTypes, namedObjectDiscriminatedUnionTypes, reusables, }: {
         configuration: TsGenerator.Configuration;
         logger: Logger;
         namedObjectTypes: readonly ObjectType[];
-        namedObjectUnionTypes: readonly ObjectUnionType[];
+        namedObjectDiscriminatedUnionTypes: readonly ObjectDiscriminatedUnionType[];
         reusables: Reusables;
     });
     abstract readonly declaration: Code;

package/dist/generators/ts/AbstractObjectSetType.js

@@ -4,12 +4,13 @@ export class AbstractObjectSetType {
     logger;
     reusables;
     namedObjectTypes;
-    namedObjectUnionTypes;
-    constructor({ configuration, logger, namedObjectTypes, namedObjectUnionTypes, reusables, }) {
+    namedObjectDiscriminatedUnionTypes;
+    constructor({ configuration, logger, namedObjectTypes, namedObjectDiscriminatedUnionTypes, reusables, }) {
         this.configuration = configuration;
         this.logger = logger;
         this.namedObjectTypes = namedObjectTypes;
-        this.namedObjectUnionTypes = namedObjectUnionTypes;
+        this.namedObjectDiscriminatedUnionTypes =
+            namedObjectDiscriminatedUnionTypes;
         this.reusables = reusables;
     }
     methodSignatures(namedObjectType, options) {