@shaclmate/compiler 4.0.8 → 4.0.10

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

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

package/dist/generators/ts/NamedUnionType.js

@@ -0,0 +1,13 @@
+import { Maybe } from "purify-ts";
+import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
+export class NamedUnionType extends AbstractNamedUnionType {
+    graphqlArgs = Maybe.empty();
+    kind = "NamedUnionType";
+    graphqlResolveExpression() {
+        throw new Error("GraphQL doesn't support scalar unions");
+    }
+    get graphqlType() {
+        throw new Error("GraphQL doesn't support scalar unions");
+    }
+}
+//# sourceMappingURL=NamedUnionType.js.map

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

@@ -14,21 +14,21 @@ export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends A
     get mutable(): boolean;
     get name(): Code;
     get schemaType(): Code;
-    get sparqlConstructTriplesFunction(): Code;
-    get sparqlWherePatternsFunction(): Code;
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
     protected get schemaObject(): {
         kind: Code;
         item: Code;
     };
     fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
-    fromRdfExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["fromRdfExpression"]>[0]): Code;
+    fromRdfResourceValuesExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
     hashStatements({ depth, variables, }: Parameters<AbstractContainerType<ItemTypeT>["hashStatements"]>[0]): readonly Code[];
     jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractContainerType.JsonType;
     jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    jsonZodSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonZodSchema"]>[0]): Code;
+    jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toJsonExpression"]>[0]): Code;
-    toRdfExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toRdfExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
 }
 export declare namespace OptionType {
     type ItemType = AbstractContainerType.ItemType;

package/dist/generators/ts/OptionType.js

@@ -70,11 +70,11 @@ export class OptionType extends AbstractContainerType {
     get schemaType() {
         return code `${snippets.MaybeSchema}<${this.itemType.schemaType}>`;
     }
-    get sparqlConstructTriplesFunction() {
-        return code `${snippets.maybeSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlConstructTriplesFunction})`;
+    get valueSparqlConstructTriplesFunction() {
+        return code `${snippets.maybeSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
-    get sparqlWherePatternsFunction() {
-        return code `${snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlWherePatternsFunction})`;
+    get valueSparqlWherePatternsFunction() {
+        return code `${snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
     get schemaObject() {
         return {
@@ -92,9 +92,9 @@ export class OptionType extends AbstractContainerType {
             ? expression
             : code `${expression}.map(item => (${itemFromJsonExpression}))`;
     }
-    fromRdfExpression(parameters) {
+    fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.itemType.fromRdfExpression(parameters)}.map(values => values.length > 0 ? values.map(value => ${imports.Maybe}.of(value)) : ${imports.Resource}.Values.fromValue<${imports.Maybe}<${this.itemType.name}>>({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: ${imports.Maybe}.empty() }))`;
+        return code `${this.itemType.fromRdfResourceValuesExpression(parameters)}.map(values => values.length > 0 ? values.map(value => ${imports.Maybe}.of(value)) : ${imports.Resource}.Values.fromValue<${imports.Maybe}<${this.itemType.name}>>({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: ${imports.Maybe}.empty() }))`;
     }
     graphqlResolveExpression(parameters) {
         return code `${this.itemType.graphqlResolveExpression(parameters)}.extractNullable()`;
@@ -122,14 +122,14 @@ export class OptionType extends AbstractContainerType {
     jsonUiSchemaElement(parameters) {
         return this.itemType.jsonUiSchemaElement(parameters);
     }
-    jsonZodSchema(parameters) {
-        return code `${this.itemType.jsonZodSchema(parameters)}.optional()`;
+    jsonSchema(parameters) {
+        return code `${this.itemType.jsonSchema(parameters)}.optional()`;
     }
     toJsonExpression({ variables, }) {
         return code `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: code `item` } })})).extract()`;
     }
-    toRdfExpression({ variables, }) {
-        const itemTypeToRdfExpression = this.itemType.toRdfExpression({
+    toRdfResourceValuesExpression({ variables, }) {
+        const itemTypeToRdfExpression = this.itemType.toRdfResourceValuesExpression({
             variables: { ...variables, value: code `value` },
         });
         let toRdfExpression = code `${variables.value}.toList()`;
@@ -162,10 +162,10 @@ __decorate([
 ], OptionType.prototype, "schemaType", null);
 __decorate([
     Memoize()
-], OptionType.prototype, "sparqlConstructTriplesFunction", null);
+], OptionType.prototype, "valueSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], OptionType.prototype, "sparqlWherePatternsFunction", null);
+], OptionType.prototype, "valueSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "jsonType", null);

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

@@ -3,11 +3,11 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class SetType<ItemTypeT extends SetType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     readonly graphqlArgs: AbstractCollectionType<ItemTypeT>["graphqlArgs"];
     readonly kind = "SetType";
-    get sparqlConstructTriplesFunction(): Code;
-    get sparqlWherePatternsFunction(): Code;
-    fromRdfExpression(parameters: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfExpression"]>[0]): Code;
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
+    fromRdfResourceValuesExpression(parameters: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     jsonType(): AbstractCollectionType.JsonType;
-    toRdfExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
 }
 export declare namespace SetType {
     type ItemType = AbstractCollectionType.ItemType;

package/dist/generators/ts/SetType.js

@@ -13,15 +13,17 @@ import { code, joinCode } from "./ts-poet-wrapper.js";
 export class SetType extends AbstractCollectionType {
     graphqlArgs = Maybe.empty();
     kind = "SetType";
-    get sparqlConstructTriplesFunction() {
-        return code `${snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlConstructTriplesFunction})`;
+    get valueSparqlConstructTriplesFunction() {
+        return code `${snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
-    get sparqlWherePatternsFunction() {
-        return code `${snippets.setSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlWherePatternsFunction})`;
+    get valueSparqlWherePatternsFunction() {
+        return code `${snippets.setSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
-    fromRdfExpression(parameters) {
+    fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        const chain = [this.itemType.fromRdfExpression(parameters)];
+        const chain = [
+            this.itemType.fromRdfResourceValuesExpression(parameters),
+        ];
         if (this.minCount === 0 || this._mutable) {
             chain.push(code `map(values => values.toArray()${this._mutable ? ".concat()" : ""})`);
         }
@@ -32,24 +34,24 @@ export class SetType extends AbstractCollectionType {
         return joinCode(chain, { on: "." });
     }
     jsonType() {
-        const name = code `readonly (${this.itemType.jsonType().name})[]`;
+        const name = code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().name})[]`;
         if (this.minCount === 0) {
             return new AbstractCollectionType.JsonType(name, { optional: true });
         }
         return new AbstractCollectionType.JsonType(name);
     }
-    toRdfExpression({ variables, }) {
-        return code `${variables.value}.flatMap((item) => ${this.itemType.toRdfExpression({
+    toRdfResourceValuesExpression({ variables, }) {
+        return code `${variables.value}.flatMap((item) => ${this.itemType.toRdfResourceValuesExpression({
             variables: { ...variables, value: code `item` },
         })})`;
     }
 }
 __decorate([
     Memoize()
-], SetType.prototype, "sparqlConstructTriplesFunction", null);
+], SetType.prototype, "valueSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], SetType.prototype, "sparqlWherePatternsFunction", null);
+], SetType.prototype, "valueSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
 ], SetType.prototype, "jsonType", null);

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

@@ -7,7 +7,7 @@ export declare class StringType extends AbstractPrimitiveType<string> {
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "StringType";
     readonly schemaType: Code;
-    readonly sparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
     readonly typeofs: NonEmptyList<"string">;
     get name(): string;
     protected get schemaObject(): {
@@ -16,8 +16,8 @@ export declare class StringType extends AbstractPrimitiveType<string> {
         kind: Code;
     };
     hashStatements({ variables, }: Parameters<AbstractPrimitiveType<string>["hashStatements"]>[0]): readonly Code[];
-    jsonZodSchema(_parameters: Parameters<AbstractPrimitiveType<string>["jsonZodSchema"]>[0]): Code;
-    toRdfExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfExpression"]>[0]): Code;
+    jsonSchema(_parameters: Parameters<AbstractPrimitiveType<string>["jsonSchema"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<string>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<string>["fromRdfExpressionChain"]>;
 }
 //# sourceMappingURL=StringType.d.ts.map

package/dist/generators/ts/StringType.js

@@ -18,7 +18,7 @@ export class StringType extends AbstractPrimitiveType {
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${imports.GraphQLString}`);
     kind = "StringType";
     schemaType = code `${snippets.StringSchema}`;
-    sparqlWherePatternsFunction = code `${snippets.stringSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = code `${snippets.stringSparqlWherePatterns}`;
     typeofs = NonEmptyList(["string"]);
     get name() {
         if (this.primitiveIn.length > 0) {
@@ -37,7 +37,7 @@ export class StringType extends AbstractPrimitiveType {
     hashStatements({ variables, }) {
         return [code `${variables.hasher}.update(${variables.value});`];
     }
-    jsonZodSchema(_parameters) {
+    jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {
             case 0:
                 return code `${imports.z}.string()`;
@@ -47,7 +47,7 @@ export class StringType extends AbstractPrimitiveType {
                 return code `${imports.z}.enum(${arrayOf(...this.primitiveIn)})`;
         }
     }
-    toRdfExpression({ variables, }) {
+    toRdfResourceValuesExpression({ variables, }) {
         return code `[${snippets.literalFactory}.string(${variables.value}${!this.datatype.equals(xsd.string) ? `, ${rdfjsTermExpression(this.datatype)}` : ""})]`;
     }
     fromRdfExpressionChain({ variables, }) {

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

@@ -8,7 +8,7 @@ export declare class TermType<ConstantTermT extends Literal | NamedNode = Litera
     readonly kind = "TermType";
     readonly nodeKinds: ReadonlySet<NodeKind>;
     readonly schemaType: Code;
-    readonly sparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
     constructor({ nodeKinds, ...superParameters }: ConstructorParameters<typeof AbstractTermType<ConstantTermT, RuntimeTermT>>[0] & {
         nodeKinds: ReadonlySet<NodeKind>;
     });
@@ -21,7 +21,7 @@ export declare class TermType<ConstantTermT extends Literal | NamedNode = Litera
     fromJsonExpression({ variables, }: Parameters<AbstractTermType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression(_parameters: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
     jsonType(): AbstractTermType.JsonType;
-    jsonZodSchema(_parameters: Parameters<AbstractTermType["jsonZodSchema"]>[0]): Code;
+    jsonSchema(_parameters: Parameters<AbstractTermType["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractTermType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=TermType.d.ts.map

package/dist/generators/ts/TermType.js

@@ -19,7 +19,7 @@ export class TermType extends AbstractTermType {
     kind = "TermType";
     nodeKinds;
     schemaType = code `${snippets.TermSchema}`;
-    sparqlWherePatternsFunction = code `${snippets.termSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = code `${snippets.termSparqlWherePatterns}`;
     constructor({ nodeKinds, ...superParameters }) {
         super(superParameters);
         this.nodeKinds = nodeKinds;
@@ -63,7 +63,7 @@ export class TermType extends AbstractTermType {
                     valueToNodeKind = code `${imports.dataFactory}.namedNode(${variables.value}["@id"])`;
                     break;
                 case "Literal":
-                    valueToNodeKind = code `${imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${imports.dataFactory}.namedNode(${variables.value}["@type"]) : undefined))`;
+                    valueToNodeKind = code `${imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined))`;
                     break;
                 default:
                     throw new RangeError(nodeKind);
@@ -82,7 +82,7 @@ export class TermType extends AbstractTermType {
             .map((nodeKind) => `"${NodeKind.toTermType(nodeKind)}"`)
             .join(" | ")} } | { readonly "@language"?: string, readonly "@type"?: string, readonly "@value": string, readonly termType: "Literal" }`);
     }
-    jsonZodSchema(_parameters) {
+    jsonSchema(_parameters) {
         return code `${imports.z}.discriminatedUnion("termType", [${joinCode([...this.nodeKinds].map((nodeKind) => {
             switch (nodeKind) {
                 case "BlankNode":

package/dist/generators/ts/TsGenerator.js

@@ -1,38 +1,46 @@
 import * as ast from "../../ast/index.js";
 import { graphqlSchemaVariableStatement } from "./graphqlSchemaVariableStatement.js";
 import { objectSetDeclarations } from "./objectSetDeclarations.js";
-// import { graphqlSchemaVariableStatement } from "./graphqlSchemaVariableStatement.js";
-// import { objectSetDeclarations } from "./objectSetDeclarations.js";
 import { snippets } from "./snippets.js";
 import { synthesizeUberObjectUnionType } from "./synthesizeUberObjectUnionType.js";
-// import { synthesizeUberObjectUnionType } from "./synthesizeUberObjectUnionType.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class TsGenerator {
     typeFactory = new TypeFactory();
     generate(ast_) {
-        const declarations = [];
-        const objectTypesToposorted = ast.ObjectType.toposort(ast_.objectTypes).map((astObjectType) => this.typeFactory.createObjectType(astObjectType));
-        const objectUnionTypesToposorted = ast_.objectUnionTypes.map((astObjectUnionType) => this.typeFactory.createObjectUnionType(astObjectUnionType));
-        for (const objectType of objectTypesToposorted) {
-            declarations.push(objectType.declaration);
+        let declarations = [];
+        for (const astNamedUnionType of ast_.namedUnionTypes) {
+            if (astNamedUnionType.isObjectUnionType()) {
+                continue;
+            }
+            declarations = declarations.concat(this.typeFactory.createType(astNamedUnionType).declaration.toList());
         }
-        for (const objectUnionType of objectUnionTypesToposorted) {
-            declarations.push(objectUnionType.declaration);
+        const namedObjectTypesToposorted = ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => this.typeFactory.createNamedObjectType(astObjectType));
+        const namedObjectUnionTypesToposorted = ast_.namedUnionTypes
+            .filter((_) => _.isObjectUnionType())
+            .map((astObjectUnionType) => this.typeFactory.createNamedObjectUnionType(astObjectUnionType));
+        for (const namedObjectType of namedObjectTypesToposorted) {
+            declarations = declarations.concat(namedObjectType.declaration.toList());
+        }
+        for (const namedObjectUnionType of namedObjectUnionTypesToposorted) {
+            declarations = declarations.concat(namedObjectUnionType.declaration.toList());
+        }
+        const namedObjectTypesNameSorted = namedObjectTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
+        const namedObjectUnionTypesNameSorted = namedObjectUnionTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
+        if (namedObjectTypesToposorted.length > 0) {
+            const uberObjectUnionType = synthesizeUberObjectUnionType({
+                namedObjectTypes: namedObjectTypesToposorted.toReversed(), // Reverse topological order so children ane before parents
+            });
+            declarations = declarations.concat(uberObjectUnionType.declaration.toList());
+            namedObjectUnionTypesNameSorted.push(uberObjectUnionType);
         }
-        const objectTypesNameSorted = objectTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
-        const objectUnionTypesNameSorted = objectUnionTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
-        const uberObjectUnionType = synthesizeUberObjectUnionType({
-            objectTypes: objectTypesToposorted.toReversed(), // Reverse topological order so children ane before parents
-        });
-        declarations.push(uberObjectUnionType.declaration);
         declarations.push(...objectSetDeclarations({
-            objectTypes: objectTypesNameSorted,
-            objectUnionTypes: objectUnionTypesNameSorted.concat(uberObjectUnionType),
+            namedObjectTypes: namedObjectTypesNameSorted,
+            namedObjectUnionTypes: namedObjectUnionTypesNameSorted,
         }));
         declarations.push(...graphqlSchemaVariableStatement({
-            objectTypes: objectTypesNameSorted,
-            objectUnionTypes: objectUnionTypesNameSorted.concat(uberObjectUnionType),
+            namedObjectTypes: namedObjectTypesNameSorted,
+            namedObjectUnionTypes: namedObjectUnionTypesNameSorted,
         }).toList());
         declarations.splice(0, 0, joinCode(Object.values(snippets)
             .sort((left, right) => left.usageSiteName.localeCompare(right.usageSiteName))

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

@@ -1,3 +1,4 @@
+import type { AnonymousUnionType } from "./AnonymousUnionType.js";
 import type { BigDecimalType } from "./BigDecimalType.js";
 import type { BigIntType } from "./BigIntType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
@@ -14,12 +15,12 @@ import type { LazyObjectSetType } from "./LazyObjectSetType.js";
 import type { LazyObjectType } from "./LazyObjectType.js";
 import type { ListType } from "./ListType.js";
 import type { LiteralType } from "./LiteralType.js";
-import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { NamedObjectType } from "./NamedObjectType.js";
+import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { NamedUnionType } from "./NamedUnionType.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 | LazyObjectOptionType | LazyObjectSetType | LazyObjectType | ListType<ListType.ItemType> | LiteralType | ObjectType | ObjectUnionType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType | UnionType;
+export type Type = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | FloatType | IdentifierType | IntType | IriType | LazyObjectOptionType | LazyObjectSetType | LazyObjectType | ListType<ListType.ItemType> | LiteralType | NamedObjectUnionType | NamedUnionType | NamedObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType;
 //# sourceMappingURL=Type.d.ts.map

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

@@ -1,17 +1,20 @@
 import type { Literal, NamedNode } from "@rdfjs/types";
-import type * as ast from "../../ast/index.js";
-import { ObjectType } from "./ObjectType.js";
-import { ObjectUnionType } from "./ObjectUnionType.js";
+import * as ast from "../../ast/index.js";
+import { AnonymousUnionType } from "./AnonymousUnionType.js";
+import { NamedObjectType } from "./NamedObjectType.js";
+import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import { NamedUnionType } from "./NamedUnionType.js";
 import type { Type } from "./Type.js";
 export declare class TypeFactory {
+    private cachedNamedObjectUnionTypesByShapeIdentifier;
     private cachedObjectTypePropertiesByShapeIdentifier;
     private cachedObjectTypesByShapeIdentifier;
-    private cachedObjectUnionTypesByShapeIdentifier;
-    createObjectType(astType: ast.ObjectType): ObjectType;
-    createObjectUnionType(astType: ast.ObjectUnionType): ObjectUnionType;
+    createNamedObjectUnionType(astType: ast.ObjectUnionType): NamedObjectUnionType;
+    createNamedObjectType(astType: ast.ObjectType): NamedObjectType;
     createType(astType: ast.Type, parameters?: {
         defaultValue?: Literal | NamedNode;
     }): Type;
+    createUnionType(astType: ast.UnionType): AnonymousUnionType | NamedUnionType | NamedObjectUnionType;
     private createBlankNodeType;
     private createDefaultValueType;
     private createIdentifierType;
@@ -25,6 +28,5 @@ export declare class TypeFactory {
     private createOptionType;
     private createSetType;
     private createTermType;
-    private createUnionType;
 }
 //# sourceMappingURL=TypeFactory.d.ts.map