@shaclmate/compiler 4.0.57 → 4.0.59

package/dist/generators/ts/{ObjectUnionType.d.ts → ObjectDiscriminatedUnionType.d.ts}

@@ -1,8 +1,8 @@
+import { DiscriminatedUnionType } from "./DiscriminatedUnionType.js";
 import type { ObjectType } from "./ObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-import { UnionType } from "./UnionType.js";
-export declare class ObjectUnionType extends UnionType<ObjectType> {
-    readonly kind = "ObjectUnion";
+export declare class ObjectDiscriminatedUnionType extends DiscriminatedUnionType<ObjectType> {
+    readonly kind = "ObjectDiscriminatedUnion";
     get identifierTypeAlias(): Code;
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
     get schema(): Code;
@@ -17,4 +17,4 @@ export declare class ObjectUnionType extends UnionType<ObjectType> {
     private get schemaVariableStatement();
     private get toRdfResourceFunctionDeclaration();
 }
-//# sourceMappingURL=ObjectUnionType.d.ts.map
+//# sourceMappingURL=ObjectDiscriminatedUnionType.d.ts.map

package/dist/generators/ts/{ObjectUnionType.js → ObjectDiscriminatedUnionType.js}

@@ -10,11 +10,11 @@ import { Memoize } from "typescript-memoize";
 import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
 import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
 import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
+import { DiscriminatedUnionType } from "./DiscriminatedUnionType.js";
 import { singleEntryRecord } from "./singleEntryRecord.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
-import { UnionType } from "./UnionType.js";
-export class ObjectUnionType extends UnionType {
-    kind = "ObjectUnion";
+export class ObjectDiscriminatedUnionType extends DiscriminatedUnionType {
+    kind = "ObjectDiscriminatedUnion";
     get identifierTypeAlias() {
         return this.name.map((name) => code `${name}.Identifier`).unsafeCoerce();
     }
@@ -210,14 +210,14 @@ ${joinCode(this.members
 }
 __decorate([
     Memoize()
-], ObjectUnionType.prototype, "identifierTypeAlias", null);
+], ObjectDiscriminatedUnionType.prototype, "identifierTypeAlias", null);
 __decorate([
     Memoize()
-], ObjectUnionType.prototype, "objectSetMethodNames", null);
+], ObjectDiscriminatedUnionType.prototype, "objectSetMethodNames", null);
 __decorate([
     Memoize()
-], ObjectUnionType.prototype, "schema", null);
+], ObjectDiscriminatedUnionType.prototype, "schema", null);
 __decorate([
     Memoize()
-], ObjectUnionType.prototype, "schemaType", null);
-//# sourceMappingURL=ObjectUnionType.js.map
+], ObjectDiscriminatedUnionType.prototype, "schemaType", null);
+//# sourceMappingURL=ObjectDiscriminatedUnionType.js.map

package/dist/generators/ts/ObjectSetType.js

@@ -14,7 +14,7 @@ export class ObjectSetType extends AbstractObjectSetType {
 export interface ${syntheticNamePrefix}ObjectSet {
   ${joinCode(this.namedObjectTypes
             .flatMap((namedObjectType) => Object.values(this.methodSignatures(namedObjectType)))
-            .concat(this.namedObjectUnionTypes.flatMap((namedObjectUnionType) => Object.values(this.methodSignatures(namedObjectUnionType))))
+            .concat(this.namedObjectDiscriminatedUnionTypes.flatMap((namedObjectDiscriminatedUnionType) => Object.values(this.methodSignatures(namedObjectDiscriminatedUnionType))))
             .map((methodSignature) => code `${methodSignature.name}(${methodSignature.parameters}): ${methodSignature.returnType};`), { on: "\n\n" })}
 }
 

package/dist/generators/ts/ObjectType.d.ts

@@ -1,9 +1,9 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import { DiscriminantProperty as _DiscriminantProperty } from "./_ObjectType/DiscriminantProperty.js";
-import { IdentifierProperty as _IdentifierProperty } from "./_ObjectType/IdentifierProperty.js";
-import type { Property as _Property } from "./_ObjectType/Property.js";
-import { ShaclProperty as _ShaclProperty } from "./_ObjectType/ShaclProperty.js";
+import { ObjectType_DiscriminantProperty } from "./_ObjectType/ObjectType_DiscriminantProperty.js";
+import { ObjectType_IdentifierProperty } from "./_ObjectType/ObjectType_IdentifierProperty.js";
+import type { ObjectType_Property } from "./_ObjectType/ObjectType_Property.js";
+import { ObjectType_ShaclProperty } from "./_ObjectType/ObjectType_ShaclProperty.js";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
@@ -88,18 +88,18 @@ export declare class ObjectType extends AbstractType {
     private readonly lazyProperties;
 }
 export declare namespace ObjectType {
-    const IdentifierProperty: typeof _IdentifierProperty;
-    type IdentifierProperty = _IdentifierProperty;
+    const IdentifierProperty: typeof ObjectType_IdentifierProperty;
+    type IdentifierProperty = ObjectType_IdentifierProperty;
     type ObjectSetMethodNames = {
         readonly object: string;
         readonly objectCount: string;
         readonly objectIdentifiers: string;
         readonly objects: string;
     };
-    type Property = _Property;
-    const ShaclProperty: typeof _ShaclProperty;
-    type ShaclProperty<TypeT extends Type> = _ShaclProperty<TypeT>;
-    const DiscriminantProperty: typeof _DiscriminantProperty;
-    type DiscriminantProperty = _DiscriminantProperty;
+    type Property = ObjectType_Property;
+    const ShaclProperty: typeof ObjectType_ShaclProperty;
+    type ShaclProperty<TypeT extends Type> = ObjectType_ShaclProperty<TypeT>;
+    const DiscriminantProperty: typeof ObjectType_DiscriminantProperty;
+    type DiscriminantProperty = ObjectType_DiscriminantProperty;
 }
 //# sourceMappingURL=ObjectType.d.ts.map

package/dist/generators/ts/ObjectType.js

@@ -9,9 +9,8 @@ import { camelCase } from "change-case";
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { DiscriminantProperty as _DiscriminantProperty } from "./_ObjectType/DiscriminantProperty.js";
-import { IdentifierProperty as _IdentifierProperty } from "./_ObjectType/IdentifierProperty.js";
 import { ObjectType_createFunctionExpression } from "./_ObjectType/ObjectType_createFunctionExpression.js";
+import { ObjectType_DiscriminantProperty } from "./_ObjectType/ObjectType_DiscriminantProperty.js";
 import { ObjectType_equalsFunctionExpression } from "./_ObjectType/ObjectType_equalsFunctionExpression.js";
 import { ObjectType_filterFunctionExpression } from "./_ObjectType/ObjectType_filterFunctionExpression.js";
 import { ObjectType_filterTypeExpression } from "./_ObjectType/ObjectType_filterTypeExpression.js";
@@ -21,6 +20,7 @@ import { ObjectType_fromJsonFunctionExpression } from "./_ObjectType/ObjectType_
 import { ObjectType_fromRdfResourceFunctionExpression } from "./_ObjectType/ObjectType_fromRdfResourceFunctionExpression.js";
 import { ObjectType_graphqlTypeExpression } from "./_ObjectType/ObjectType_graphqlTypeExpression.js";
 import { ObjectType_hashFunctionExpression } from "./_ObjectType/ObjectType_hashFunctionExpression.js";
+import { ObjectType_IdentifierProperty } from "./_ObjectType/ObjectType_IdentifierProperty.js";
 import { ObjectType_identifierTypeDeclarations } from "./_ObjectType/ObjectType_identifierTypeDeclarations.js";
 import { ObjectType_isTypeFunctionDeclaration } from "./_ObjectType/ObjectType_isTypeFunctionDeclaration.js";
 import { ObjectType_jsonParseFunctionDeclaration } from "./_ObjectType/ObjectType_jsonParseFunctionDeclaration.js";
@@ -28,6 +28,7 @@ import { ObjectType_jsonSchemaExpression } from "./_ObjectType/ObjectType_jsonSc
 import { ObjectType_jsonTypeExpression } from "./_ObjectType/ObjectType_jsonTypeExpression.js";
 import { ObjectType_jsonUiSchemaFunctionExpression } from "./_ObjectType/ObjectType_jsonUiSchemaFunctionExpression.js";
 import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
+import { ObjectType_ShaclProperty } from "./_ObjectType/ObjectType_ShaclProperty.js";
 import { ObjectType_schemaExpression } from "./_ObjectType/ObjectType_schemaExpression.js";
 import { ObjectType_schemaTypeExpression } from "./_ObjectType/ObjectType_schemaTypeExpression.js";
 import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
@@ -38,7 +39,6 @@ import { ObjectType_toStringFunctionExpression } from "./_ObjectType/ObjectType_
 import { ObjectType_toStringRecordFunctionExpression } from "./_ObjectType/ObjectType_toStringRecordFunctionExpression.js";
 import { ObjectType_valueSparqlConstructTriplesFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlConstructTriplesFunctionExpression.js";
 import { ObjectType_valueSparqlWherePatternsFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlWherePatternsFunctionExpression.js";
-import { ShaclProperty as _ShaclProperty } from "./_ObjectType/ShaclProperty.js";
 import { AbstractType } from "./AbstractType.js";
 import { arrayOf, code, def, joinCode } from "./ts-poet-wrapper.js";
 import { tsComment } from "./tsComment.js";
@@ -496,8 +496,8 @@ __decorate([
     Memoize()
 ], ObjectType.prototype, "jsonType", null);
 (function (ObjectType) {
-    ObjectType.IdentifierProperty = _IdentifierProperty;
-    ObjectType.ShaclProperty = _ShaclProperty;
-    ObjectType.DiscriminantProperty = _DiscriminantProperty;
+    ObjectType.IdentifierProperty = ObjectType_IdentifierProperty;
+    ObjectType.ShaclProperty = ObjectType_ShaclProperty;
+    ObjectType.DiscriminantProperty = ObjectType_DiscriminantProperty;
 })(ObjectType || (ObjectType = {}));
 //# sourceMappingURL=ObjectType.js.map

package/dist/generators/ts/RdfjsDatasetObjectSetType.js

@@ -46,7 +46,10 @@ export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticN
   }
 
   ${joinCode([
-            ...[...this.namedObjectTypes, ...this.namedObjectUnionTypes].flatMap((namedObjectType) => {
+            ...[
+                ...this.namedObjectTypes,
+                ...this.namedObjectDiscriminatedUnionTypes,
+            ].flatMap((namedObjectType) => {
                 const methodSignatures = this.methodSignatures(namedObjectType);
                 const delegatingMethods = [
                     // object
@@ -96,10 +99,10 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
   return this.#objectsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
 }`);
                     }
-                    case "ObjectUnion":
+                    case "ObjectDiscriminatedUnion":
                         return delegatingMethods.concat(code `\
 ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.expression}[]> {
-  return this.#objectUnionsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
+  return this.#objectDiscriminatedUnionsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
     ${joinCode(namedObjectType.members.map((member) => runtimeObjectType(namedObjectType.filterFunction, member.type)), { on: ", " })}
   ], query);
 }`);
@@ -200,10 +203,10 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
   }`,
                 ]
                 : []),
-            ...(this.namedObjectUnionTypes.length > 0
+            ...(this.namedObjectDiscriminatedUnionTypes.length > 0
                 ? [
                     code `\
-#objectUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectTypes: readonly ${namedObjectTypeType}[], ${parameters.query}): ${this.reusables.imports.Either}<Error, readonly ObjectT[]> {
+#objectDiscriminatedUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectTypes: readonly ${namedObjectTypeType}[], ${parameters.query}): ${this.reusables.imports.Either}<Error, readonly ObjectT[]> {
   const graph = query?.graph ?? this.#graph;
 
   const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;

package/dist/generators/ts/SparqlObjectSetType.js

@@ -38,7 +38,10 @@ export class ${syntheticNamePrefix}SparqlObjectSet implements ${syntheticNamePre
     this.#sparqlClient = sparqlClient;
   }
 
-${joinCode([...this.namedObjectTypes, ...this.namedObjectUnionTypes].flatMap((namedObjectType) => {
+${joinCode([
+            ...this.namedObjectTypes,
+            ...this.namedObjectDiscriminatedUnionTypes,
+        ].flatMap((namedObjectType) => {
             const methodSignatures = this.methodSignatures(namedObjectType, {
                 queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
             });

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

@@ -5,7 +5,7 @@ export declare class StringType extends AbstractPrimitiveType<string> {
     private readonly languageIn;
     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: "string";

package/dist/generators/ts/TsGenerator.d.ts

@@ -14,7 +14,7 @@ export declare class TsGenerator implements Generator {
     /**
      * Synthesize the $Object union.
      */
-    private synthesizeUberObjectUnionType;
+    private synthesizeUberObjectDiscriminatedUnionType;
 }
 export declare namespace TsGenerator {
     interface Configuration {

package/dist/generators/ts/TsGenerator.js

@@ -5,8 +5,8 @@ import { BlankNodeType } from "./BlankNodeType.js";
 import { GraphqlSchema } from "./GraphqlSchema.js";
 import { IdentifierType } from "./IdentifierType.js";
 import { IriType } from "./IriType.js";
+import { ObjectDiscriminatedUnionType } from "./ObjectDiscriminatedUnionType.js";
 import { ObjectSetType } from "./ObjectSetType.js";
-import { ObjectUnionType } from "./ObjectUnionType.js";
 import { RdfjsDatasetObjectSetType } from "./RdfjsDatasetObjectSetType.js";
 import { Reusables } from "./Reusables.js";
 import { SparqlObjectSetType } from "./SparqlObjectSetType.js";
@@ -36,7 +36,7 @@ export class TsGenerator {
         let declarations = [];
         const tsNamedTypes = [];
         const tsNamedObjectTypes = [];
-        const tsNamedObjectUnionTypes = [];
+        const tsNamedObjectDiscriminatedUnionTypes = [];
         for (const astNamedType of ast_.namedTypes) {
             const tsNamedType = typeFactory.createType(astNamedType);
             tsNamedTypes.push(tsNamedType);
@@ -49,18 +49,18 @@ export class TsGenerator {
                 case "Object":
                     tsNamedObjectTypes.push(tsNamedType);
                     break;
-                case "ObjectUnion":
-                    tsNamedObjectUnionTypes.push(tsNamedType);
+                case "ObjectDiscriminatedUnion":
+                    tsNamedObjectDiscriminatedUnionTypes.push(tsNamedType);
                     break;
             }
         }
         tsNamedTypes.sort(compareTsNamedType);
         tsNamedObjectTypes.sort(compareTsNamedType);
-        tsNamedObjectUnionTypes.sort(compareTsNamedType);
+        tsNamedObjectDiscriminatedUnionTypes.sort(compareTsNamedType);
         for (const tsNamedType of tsNamedTypes) {
             switch (tsNamedType.kind) {
-                case "ObjectUnion":
-                case "Union":
+                case "ObjectDiscriminatedUnion":
+                case "DiscriminatedUnion":
                     continue; // Declare compound types last.
             }
             tsNamedType.declaration.ifJust((declaration) => {
@@ -70,8 +70,8 @@ export class TsGenerator {
         // Declare compound types last.
         for (const tsNamedType of tsNamedTypes) {
             switch (tsNamedType.kind) {
-                case "ObjectUnion":
-                case "Union":
+                case "ObjectDiscriminatedUnion":
+                case "DiscriminatedUnion":
                     break;
                 default:
                     continue;
@@ -87,30 +87,30 @@ export class TsGenerator {
                 declarations.push(code `type ${configuration.syntheticNamePrefix}Object = ${tsNamedObjectTypes[0].expression};`);
                 break;
             default: {
-                const uberObjectUnionType = this.synthesizeUberObjectUnionType({
+                const uberObjectDiscriminatedUnionType = this.synthesizeUberObjectDiscriminatedUnionType({
                     configuration,
                     namedObjectTypes: tsNamedObjectTypes,
                     reusables,
                 });
-                declarations = declarations.concat(uberObjectUnionType.declaration.toList());
-                tsNamedObjectUnionTypes.push(uberObjectUnionType);
+                declarations = declarations.concat(uberObjectDiscriminatedUnionType.declaration.toList());
+                tsNamedObjectDiscriminatedUnionTypes.push(uberObjectDiscriminatedUnionType);
             }
         }
         declarations.push(...this.objectSetTypeDeclarations({
             configuration,
             namedObjectTypes: tsNamedObjectTypes,
-            namedObjectUnionTypes: tsNamedObjectUnionTypes,
+            namedObjectDiscriminatedUnionTypes: tsNamedObjectDiscriminatedUnionTypes,
             reusables,
         }));
         if (configuration.features.has("GraphQL")) {
             const graphqlNamedObjectTypes = tsNamedObjectTypes.filter((tsNamedObjectType) => !tsNamedObjectType.synthetic);
-            const graphqlNamedObjectUnionTypes = tsNamedObjectUnionTypes.filter((tsNamedObjectUnionType) => !tsNamedObjectUnionType.synthetic);
+            const graphqlNamedObjectDiscriminatedUnionTypes = tsNamedObjectDiscriminatedUnionTypes.filter((tsNamedObjectDiscriminatedUnionType) => !tsNamedObjectDiscriminatedUnionType.synthetic);
             if (graphqlNamedObjectTypes.length > 0) {
                 declarations.push(new GraphqlSchema({
                     configuration,
                     logger: this.logger,
                     namedObjectTypes: graphqlNamedObjectTypes,
-                    namedObjectUnionTypes: graphqlNamedObjectUnionTypes,
+                    namedObjectDiscriminatedUnionTypes: graphqlNamedObjectDiscriminatedUnionTypes,
                     reusables,
                 }).declaration);
             }
@@ -118,12 +118,12 @@ export class TsGenerator {
         declarations.splice(0, 0, joinCode(reusables.snippets.ifUsed, { on: "\n\n" }));
         return joinCode(declarations).toString({});
     }
-    objectSetTypeDeclarations({ configuration, namedObjectTypes, namedObjectUnionTypes, reusables, }) {
+    objectSetTypeDeclarations({ configuration, namedObjectTypes, namedObjectDiscriminatedUnionTypes, reusables, }) {
         const constructorParameters = {
             configuration,
             logger: this.logger,
             namedObjectTypes: namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern && !namedObjectType.synthetic),
-            namedObjectUnionTypes,
+            namedObjectDiscriminatedUnionTypes,
             reusables,
         };
         const declarations = [];
@@ -141,7 +141,7 @@ export class TsGenerator {
     /**
      * Synthesize the $Object union.
      */
-    synthesizeUberObjectUnionType({ configuration, namedObjectTypes, reusables, }) {
+    synthesizeUberObjectDiscriminatedUnionType({ configuration, namedObjectTypes, reusables, }) {
         const filteredNamedObjectTypes = namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern && !namedObjectType.synthetic);
         invariant(filteredNamedObjectTypes.length > 0);
         const nodeKinds = filteredNamedObjectTypes.reduce((nodeKinds, namedObjectType) => {
@@ -190,7 +190,7 @@ export class TsGenerator {
                     break;
             }
         }
-        return new ObjectUnionType({
+        return new ObjectDiscriminatedUnionType({
             name: Maybe.of(`${configuration.syntheticNamePrefix}Object`),
             comment: Maybe.empty(),
             configuration,

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

@@ -5,6 +5,7 @@ import type { BooleanType } from "./BooleanType.js";
 import type { DateTimeType } from "./DateTimeType.js";
 import type { DateType } from "./DateType.js";
 import type { DefaultValueType } from "./DefaultValueType.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";
@@ -15,12 +16,11 @@ import type { LazySetType } from "./LazySetType.js";
 import type { LazyType } from "./LazyType.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 { OptionType } from "./OptionType.js";
 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 | LangStringType | 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 | ObjectDiscriminatedUnionType | ObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType | DiscriminatedUnionType<Type>;
 //# sourceMappingURL=Type.d.ts.map

package/dist/generators/ts/TypeFactory.d.ts

@@ -1,17 +1,17 @@
 import type { Literal, NamedNode } from "@rdfjs/types";
 import type { Logger } from "ts-log";
 import * as ast from "../../ast/index.js";
+import { DiscriminatedUnionType } from "./DiscriminatedUnionType.js";
+import { ObjectDiscriminatedUnionType } from "./ObjectDiscriminatedUnionType.js";
 import { ObjectType } from "./ObjectType.js";
-import { ObjectUnionType } from "./ObjectUnionType.js";
 import type { Reusables } from "./Reusables.js";
 import type { TsGenerator } from "./TsGenerator.js";
 import type { Type } from "./Type.js";
-import { UnionType } from "./UnionType.js";
 export declare class TypeFactory {
     private readonly configuration;
     private readonly logger;
     private readonly reusables;
-    private cachedObjectUnionTypesByShapeIdentifier;
+    private cachedObjectDiscriminatedUnionTypesByShapeIdentifier;
     private cachedObjectTypePropertiesByShapeIdentifier;
     private cachedObjectTypesByShapeIdentifier;
     constructor({ configuration, logger, reusables, }: {
@@ -20,11 +20,11 @@ export declare class TypeFactory {
         reusables: Reusables;
     });
     createObjectType(astType: ast.StructType): ObjectType;
-    createObjectUnionType(astType: ast.StructUnionType): ObjectUnionType;
+    createObjectDiscriminatedUnionType(astType: ast.StructDiscriminatedUnionType): ObjectDiscriminatedUnionType;
     createType(astType: ast.Type, parameters?: {
         defaultValue?: Literal | NamedNode;
     }): Type;
-    createUnionType(astType: ast.UnionType): ObjectUnionType | UnionType<Type>;
+    createDiscriminatedUnionType(astType: ast.DiscriminatedUnionType): ObjectDiscriminatedUnionType | DiscriminatedUnionType<Type>;
     private createBlankNodeType;
     private createDefaultValueType;
     private createIdentifierType;

package/dist/generators/ts/TypeFactory.js

@@ -14,6 +14,7 @@ import { BooleanType } from "./BooleanType.js";
 import { DateTimeType } from "./DateTimeType.js";
 import { DateType } from "./DateType.js";
 import { DefaultValueType } from "./DefaultValueType.js";
+import { DiscriminatedUnionType } from "./DiscriminatedUnionType.js";
 import { FloatType } from "./FloatType.js";
 import { IdentifierType } from "./IdentifierType.js";
 import { IntType } from "./IntType.js";
@@ -24,18 +25,17 @@ import { LazySetType } from "./LazySetType.js";
 import { LazyType } from "./LazyType.js";
 import { ListType } from "./ListType.js";
 import { LiteralType } from "./LiteralType.js";
+import { ObjectDiscriminatedUnionType } from "./ObjectDiscriminatedUnionType.js";
 import { ObjectType } from "./ObjectType.js";
-import { ObjectUnionType } from "./ObjectUnionType.js";
 import { OptionType } from "./OptionType.js";
 import { SetType } from "./SetType.js";
 import { StringType } from "./StringType.js";
 import { TermType } from "./TermType.js";
-import { UnionType } from "./UnionType.js";
 export class TypeFactory {
     configuration;
     logger;
     reusables;
-    cachedObjectUnionTypesByShapeIdentifier = new TermMap();
+    cachedObjectDiscriminatedUnionTypesByShapeIdentifier = new TermMap();
     cachedObjectTypePropertiesByShapeIdentifier = new TermMap();
     cachedObjectTypesByShapeIdentifier = new TermMap();
     constructor({ configuration, logger, reusables, }) {
@@ -106,14 +106,14 @@ export class TypeFactory {
         this.cachedObjectTypesByShapeIdentifier.set(astType.shapeIdentifier, objectType);
         return objectType;
     }
-    createObjectUnionType(astType) {
+    createObjectDiscriminatedUnionType(astType) {
         {
-            const cachedObjectUnionType = this.cachedObjectUnionTypesByShapeIdentifier.get(astType.shapeIdentifier);
-            if (cachedObjectUnionType) {
-                return cachedObjectUnionType;
+            const cachedObjectDiscriminatedUnionType = this.cachedObjectDiscriminatedUnionTypesByShapeIdentifier.get(astType.shapeIdentifier);
+            if (cachedObjectDiscriminatedUnionType) {
+                return cachedObjectDiscriminatedUnionType;
             }
         }
-        const objectUnionType = new ObjectUnionType({
+        const objectDiscriminatedUnionType = new ObjectDiscriminatedUnionType({
             comment: astType.comment,
             configuration: this.configuration,
             identifierType: Maybe.of(this.createIdentifierType(ast.StructCompoundType.identifierType(astType))),
@@ -129,8 +129,8 @@ export class TypeFactory {
             shapeIdentifier: astType.shapeIdentifier,
             synthetic: astType.synthetic,
         });
-        this.cachedObjectUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, objectUnionType);
-        return objectUnionType;
+        this.cachedObjectDiscriminatedUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, objectDiscriminatedUnionType);
+        return objectDiscriminatedUnionType;
     }
     createType(astType, parameters) {
         switch (astType.kind) {
@@ -162,15 +162,15 @@ export class TypeFactory {
                 return this.createObjectType(astType);
             case "Term":
                 return this.createTermType(astType);
-            case "Union":
-                return this.createUnionType(astType);
+            case "DiscriminatedUnion":
+                return this.createDiscriminatedUnionType(astType);
         }
     }
-    createUnionType(astType) {
-        if (astType.isStructUnionType()) {
-            return this.createObjectUnionType(astType);
+    createDiscriminatedUnionType(astType) {
+        if (astType.isStructDiscriminatedUnionType()) {
+            return this.createObjectDiscriminatedUnionType(astType);
         }
-        return new UnionType({
+        return new DiscriminatedUnionType({
             comment: astType.comment,
             configuration: this.configuration,
             identifierType: Maybe.empty(),

package/dist/generators/ts/ZodGenerator.js

@@ -34,13 +34,13 @@ export namespace ${tsNamedObjectType.name.unsafeCoerce()} {
 }`);
                     break;
                 }
-                case "Union": {
-                    const tsNamedUnionType = typeFactory.createUnionType(astNamedType);
+                case "DiscriminatedUnion": {
+                    const tsNamedDiscriminatedUnionType = typeFactory.createDiscriminatedUnionType(astNamedType);
                     declarations.push(code `\
-export namespace ${tsNamedUnionType.name.unsafeCoerce()} {
-  ${tsNamedUnionType.jsonTypeAliasDeclaration}
+export namespace ${tsNamedDiscriminatedUnionType.name.unsafeCoerce()} {
+  ${tsNamedDiscriminatedUnionType.jsonTypeAliasDeclaration}
   export namespace Json {
-    ${tsNamedUnionType.jsonSchemaFunctionDeclaration}
+    ${tsNamedDiscriminatedUnionType.jsonSchemaFunctionDeclaration}
   }
 }`);
                     break;

package/dist/generators/ts/_AbstractType/AbstractType_ConversionFunction.d.ts

@@ -0,0 +1,10 @@
+import type { Code } from "../ts-poet-wrapper.js";
+import type { AbstractType_JsType } from "./AbstractType_JsType.js";
+export interface AbstractType_ConversionFunction {
+    readonly code: Code;
+    readonly sourceTypes: {
+        readonly expression: Code;
+        readonly jsType: AbstractType_JsType;
+    }[];
+}
+//# sourceMappingURL=AbstractType_ConversionFunction.d.ts.map

package/dist/generators/ts/_AbstractType/AbstractType_ConversionFunction.js

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

package/dist/generators/ts/_AbstractType/AbstractType_DiscriminantProperty.d.ts

@@ -0,0 +1,9 @@
+export interface AbstractType_DiscriminantProperty {
+    readonly jsonName: string;
+    readonly name: string;
+    readonly values: readonly AbstractType_DiscriminantProperty.Value[];
+}
+export declare namespace AbstractType_DiscriminantProperty {
+    type Value = number | string;
+}
+//# sourceMappingURL=AbstractType_DiscriminantProperty.d.ts.map

package/dist/generators/ts/_AbstractType/AbstractType_DiscriminantProperty.js

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

package/dist/generators/ts/_AbstractType/AbstractType_GraphqlType.d.ts

@@ -0,0 +1,18 @@
+import type { Reusables } from "../Reusables.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare class AbstractType_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;
+}
+//# sourceMappingURL=AbstractType_GraphqlType.d.ts.map

package/dist/generators/ts/_AbstractType/AbstractType_GraphqlType.js

@@ -0,0 +1,33 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Memoize } from "typescript-memoize";
+import { code } from "../ts-poet-wrapper.js";
+export class AbstractType_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()
+], AbstractType_GraphqlType.prototype, "expression", null);
+//# sourceMappingURL=AbstractType_GraphqlType.js.map

package/dist/generators/ts/_AbstractType/AbstractType_JsType.d.ts

@@ -0,0 +1,34 @@
+import type { Code } from "../ts-poet-wrapper.js";
+export type AbstractType_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";
+};
+export declare namespace AbstractType_JsType {
+    function equals(left: AbstractType_JsType, right: AbstractType_JsType): boolean;
+}
+//# sourceMappingURL=AbstractType_JsType.d.ts.map