@shaclmate/compiler 2.0.13 → 2.0.15

package/generators/ts/Type.js

@@ -1,83 +1,117 @@
 import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { rdfjsTermExpression } from "./_ObjectType/rdfjsTermExpression.js";
+import { objectInitializer } from "./objectInitializer.js";
+/**
+ * Abstract base class for generating TypeScript expressions and statemenst in the TypeScript generator.
+ *
+ * Subclasses are used for both property types (c.f., property* methods) and node/object types.
+ */
 export class Type {
-    constructor({ configuration, }) {
-        this.configuration = configuration;
+    constructor({ dataFactoryVariable, }) {
+        this.dataFactoryVariable = dataFactoryVariable;
     }
     /**
-     * Expressions that convert a source type or types to this type. It should include the type itself.
+     * A property that discriminates sub-types of this type e.g., termType on RDF/JS terms.
      */
-    get conversions() {
-        return [
-            {
-                conversionExpression: (value) => value,
-                sourceTypeName: this.name,
-            },
-        ];
+    get discriminatorProperty() {
+        return Maybe.empty();
     }
     /**
-     * A property that discriminates sub-types of this type e.g., termType on RDF/JS terms.
+     * Element object for a JSON Forms UI schema.
      */
-    get discriminatorProperty() {
+    jsonUiSchemaElement(_parameters) {
         return Maybe.empty();
     }
     /**
-     * Imports used by other methods on this type.
+     * Reusable function, type, and other declarations that are not particular to this type but that type-specific code
+     * relies on. For example, the equals function/method of ObjectType has a custom return type that's the same across all
+     * ObjectType's. Instead of re-declaring the return type anonymously on every equals function, declare a named type
+     * as a snippet and reference it.
+     *
+     * The generator deduplicates snippet declarations across all types before adding them to the source.
      */
-    get importStatements() {
+    snippetDeclarations(_features) {
         return [];
     }
     /**
-     * An optional sparqlBuilder.GraphPattern expression that's chained to the object of another pattern, such as a list item.
+     * An array of SPARQL.js CONSTRUCT template triples for a value of this type, as strings (so they can incorporate runtime calls).
+     *
+     * This method is called in two contexts:
+     * (1) By an ObjectType.Property. The property expects a basic graph pattern (subject, property path, property object). The property calls this method to get additional triples in which the propertyObject is the subject. For example, if the type is a nested object, it would include (propertyObject, nestedPredicate, nestedObject) triples.
+     * (2) By another Type. For example, ListType calls this method to with the item variable as a subject in order to chain additional patterns on items.
      *
-     * If the type is e.g., an RDF/JS term it won't have additional graph patterns beyond the basic (s, p, o), and this
-     * method will return nothing.
+     * Term types with no additional properties should return an empty array.
      */
-    chainSparqlGraphPatternExpression(_) {
-        return Maybe.empty();
+    sparqlConstructTemplateTriples({ context, variables, }) {
+        switch (context) {
+            case "property": {
+                const objectPrefix = `${this.dataFactoryVariable}.variable!(`;
+                const objectSuffix = ")";
+                invariant(variables.object.startsWith(objectPrefix));
+                invariant(variables.object.endsWith(objectSuffix));
+                return [
+                    objectInitializer({
+                        object: variables.object,
+                        predicate: variables.predicate,
+                        subject: variables.subject,
+                    }),
+                ].concat(this.sparqlConstructTemplateTriples({
+                    context: "type",
+                    variables: {
+                        subject: variables.object,
+                        variablePrefix: variables.object.substring(objectPrefix.length, variables.object.length - objectSuffix.length),
+                    },
+                }));
+            }
+            case "type":
+                return [];
+        }
     }
     /**
-     * An sparqlBuilder.GraphPattern expression for a property, typically building a basic graph pattern.
+     * An array of SPARQL.js where patterns for a value of this type, as strings (so they can incorporate runtime calls).
+     *
+     * See note in sparqlConstructTemplateTriples re: how this method is used.
      */
-    propertySparqlGraphPatternExpression({ variables, }) {
-        let expression = `sparqlBuilder.GraphPattern.basic(${variables.subject}, ${variables.predicate}, ${variables.object})`;
-        this.chainSparqlGraphPatternExpression({
-            variables: { subject: "object" },
-        }).ifJust((chainSparqlGraphPatternExpression) => {
-            expression = `sparqlBuilder.GraphPattern.group(${expression}.chainObject(object => ${chainSparqlGraphPatternExpression.toSparqlGraphPatternsExpression()}))`;
-        });
-        return new Type.SparqlGraphPatternExpression(expression);
-    }
-}
-(function (Type) {
-    class SparqlGraphPatternExpression {
-        constructor(value) {
-            this.value = value;
-        }
-        toSparqlGraphPatternExpression() {
-            return this;
-        }
-        toSparqlGraphPatternsExpression() {
-            return new SparqlGraphPatternExpression(`[${this.value}]`);
-        }
-        toString() {
-            return this.value;
+    sparqlWherePatterns({ context, variables, }) {
+        switch (context) {
+            case "property": {
+                const objectPrefix = `${this.dataFactoryVariable}.variable!(`;
+                const objectSuffix = ")";
+                invariant(variables.object.startsWith(objectPrefix));
+                invariant(variables.object.endsWith(objectSuffix));
+                return [
+                    objectInitializer({
+                        triples: `[${objectInitializer({
+                            object: variables.object,
+                            predicate: variables.predicate,
+                            subject: variables.subject,
+                        })}]`,
+                        type: '"bgp"',
+                    }),
+                ].concat(this.sparqlWherePatterns({
+                    context: "type",
+                    variables: {
+                        subject: variables.object,
+                        variablePrefix: variables.object.substring(objectPrefix.length, variables.object.length - objectSuffix.length),
+                    },
+                }));
+            }
+            case "type":
+                return [];
         }
     }
-    Type.SparqlGraphPatternExpression = SparqlGraphPatternExpression;
-    class SparqlGraphPatternsExpression {
-        constructor(value) {
-            this.value = value;
-        }
-        toSparqlGraphPatternExpression() {
-            return new SparqlGraphPatternExpression(`sparqlBuilder.GraphPattern.group(${this.value})`);
-        }
-        toSparqlGraphPatternsExpression() {
-            return this;
-        }
-        toString() {
-            return this.value;
-        }
+    /**
+     * Imports necessary to use this type.
+     */
+    useImports(_features) {
+        return [];
     }
-    Type.SparqlGraphPatternsExpression = SparqlGraphPatternsExpression;
-})(Type || (Type = {}));
+    rdfjsTermExpression(rdfjsTerm) {
+        return rdfjsTermExpression({
+            dataFactoryVariable: this.dataFactoryVariable,
+            rdfjsTerm,
+        });
+    }
+}
 //# sourceMappingURL=Type.js.map

package/generators/ts/TypeFactory.d.ts

@@ -1,12 +1,11 @@
-import type * as ast from "../../ast";
-import type { Configuration } from "./Configuration";
+import type * as ast from "../../ast/index.js";
 import type { Type } from "./Type.js";
 export declare class TypeFactory {
     private cachedObjectTypePropertiesByIdentifier;
     private cachedObjectTypesByIdentifier;
-    private readonly configuration;
-    constructor({ configuration }: {
-        configuration: Configuration;
+    private readonly dataFactoryVariable;
+    constructor({ dataFactoryVariable }: {
+        dataFactoryVariable: string;
     });
     createTypeFromAstType(astType: ast.Type): Type;
     private createObjectTypeFromAstType;

package/generators/ts/TypeFactory.js

@@ -1,101 +1,204 @@
 import TermMap from "@rdfjs/term-map";
-import { NodeKind } from "@shaclmate/shacl-ast";
-import { xsd } from "@tpluscode/rdf-ns-builders";
+import TermSet from "@rdfjs/term-set";
+import { rdf, xsd } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
-import { BooleanType } from "./BooleanType";
-import { IdentifierType } from "./IdentifierType";
-import { IntersectionType } from "./IntersectionType";
+import { fromRdf } from "rdf-literal";
+import { logger } from "../../logger.js";
+import { BooleanType } from "./BooleanType.js";
+import { DateTimeType } from "./DateTimeType.js";
+import { IdentifierType } from "./IdentifierType.js";
 import { ListType } from "./ListType.js";
 import { LiteralType } from "./LiteralType.js";
 import { NumberType } from "./NumberType.js";
 import { ObjectType } from "./ObjectType.js";
-import { OptionType } from "./OptionType";
-import { SetType } from "./SetType";
+import { ObjectUnionType } from "./ObjectUnionType.js";
+import { OptionType } from "./OptionType.js";
+import { SetType } from "./SetType.js";
 import { StringType } from "./StringType.js";
-import { UnionType } from "./UnionType";
+import { TermType } from "./TermType.js";
+import { UnionType } from "./UnionType.js";
 import { tsName } from "./tsName.js";
 export class TypeFactory {
-    constructor({ configuration }) {
+    constructor({ dataFactoryVariable }) {
         this.cachedObjectTypePropertiesByIdentifier = new TermMap();
         this.cachedObjectTypesByIdentifier = new TermMap();
-        this.configuration = configuration;
+        this.dataFactoryVariable = dataFactoryVariable;
     }
     createTypeFromAstType(astType) {
         switch (astType.kind) {
             case "IdentifierType":
                 return new IdentifierType({
-                    configuration: this.configuration,
+                    dataFactoryVariable: this.dataFactoryVariable,
                     defaultValue: astType.defaultValue,
-                    hasValue: astType.hasValue,
+                    hasValues: astType.hasValues,
+                    in_: astType.in_,
                     nodeKinds: astType.nodeKinds,
                 });
             case "IntersectionType":
-                return new IntersectionType({
-                    configuration: this.configuration,
-                    memberTypes: astType.memberTypes.map((astType) => this.createTypeFromAstType(astType)),
+                throw new Error("not implemented");
+            case "ListType": {
+                return new ListType({
+                    dataFactoryVariable: this.dataFactoryVariable,
+                    identifierNodeKind: astType.identifierNodeKind,
+                    itemType: this.createTypeFromAstType(astType.itemType),
+                    mutable: astType.mutable.orDefault(false),
+                    mintingStrategy: astType.mintingStrategy,
+                    toRdfTypes: astType.toRdfTypes,
                 });
+            }
             case "LiteralType": {
-                const datatype = astType.datatype
-                    .altLazy(() => astType.defaultValue.map((defaultValue) => defaultValue.datatype))
-                    .altLazy(() => astType.hasValue.map((hasValue) => hasValue.datatype))
-                    .extractNullable();
-                if (datatype !== null) {
+                // Look at sh:datatype as well as sh:defaultValue/sh:hasValue/sh:in term datatypes
+                // If there's one common datatype than we can refine the type
+                // Otherwise default to rdfjs.Literal
+                const datatypes = new TermSet();
+                astType.datatype.ifJust((datatype) => datatypes.add(datatype));
+                astType.defaultValue.ifJust((defaultValue) => datatypes.add(defaultValue.datatype));
+                for (const hasValue of astType.hasValues) {
+                    datatypes.add(hasValue.datatype);
+                }
+                for (const value of astType.in_) {
+                    datatypes.add(value.datatype);
+                }
+                if (datatypes.size === 1) {
+                    const datatype = [...datatypes][0];
                     if (datatype.equals(xsd.boolean)) {
                         return new BooleanType({
-                            configuration: this.configuration,
+                            dataFactoryVariable: this.dataFactoryVariable,
                             defaultValue: astType.defaultValue,
-                            hasValue: astType.hasValue,
+                            hasValues: astType.hasValues,
+                            languageIn: [],
+                            in_: astType.in_,
+                            primitiveDefaultValue: astType.defaultValue
+                                .map((value) => fromRdf(value, true))
+                                .filter((value) => typeof value === "boolean"),
+                            primitiveIn: astType.in_
+                                .map((value) => fromRdf(value, true))
+                                .filter((value) => typeof value === "boolean"),
                         });
                     }
-                    if (datatype.equals(xsd.integer)) {
-                        return new NumberType({
-                            configuration: this.configuration,
+                    if (datatype.equals(xsd.dateTime)) {
+                        return new DateTimeType({
+                            dataFactoryVariable: this.dataFactoryVariable,
                             defaultValue: astType.defaultValue,
-                            hasValue: astType.hasValue,
+                            hasValues: astType.hasValues,
+                            in_: astType.in_,
+                            languageIn: [],
+                            primitiveDefaultValue: astType.defaultValue
+                                .map((value) => fromRdf(value, true))
+                                .filter((value) => typeof value === "object" && value instanceof Date),
+                            primitiveIn: astType.in_
+                                .map((value) => fromRdf(value, true))
+                                .filter((value) => typeof value === "object" && value instanceof Date),
                         });
                     }
+                    for (const numberDatatype of [
+                        // Integers
+                        xsd.byte,
+                        xsd.int,
+                        xsd.integer,
+                        xsd.long,
+                        xsd.negativeInteger,
+                        xsd.nonNegativeInteger,
+                        xsd.nonPositiveInteger,
+                        xsd.positiveInteger,
+                        xsd.short,
+                        xsd.unsignedByte,
+                        xsd.unsignedInt,
+                        xsd.unsignedLong,
+                        xsd.unsignedShort,
+                        // Floating point
+                        xsd.decimal,
+                        xsd.double,
+                        xsd.float,
+                    ]) {
+                        if (datatype.equals(numberDatatype)) {
+                            return new NumberType({
+                                dataFactoryVariable: this.dataFactoryVariable,
+                                defaultValue: astType.defaultValue,
+                                hasValues: astType.hasValues,
+                                in_: astType.in_,
+                                languageIn: [],
+                                primitiveDefaultValue: astType.defaultValue
+                                    .map((value) => fromRdf(value, true))
+                                    .filter((value) => typeof value === "number"),
+                                primitiveIn: astType.in_
+                                    .map((value) => fromRdf(value, true))
+                                    .filter((value) => typeof value === "number"),
+                            });
+                        }
+                    }
                     if (datatype.equals(xsd.anyURI) || datatype.equals(xsd.string)) {
                         return new StringType({
-                            configuration: this.configuration,
+                            dataFactoryVariable: this.dataFactoryVariable,
                             defaultValue: astType.defaultValue,
-                            hasValue: astType.hasValue,
+                            hasValues: astType.hasValues,
+                            languageIn: [],
+                            in_: astType.in_,
+                            primitiveDefaultValue: astType.defaultValue.map((value) => value.value),
+                            primitiveIn: astType.in_.map((value) => value.value),
                         });
                     }
+                    if (datatype.equals(rdf.langString)) {
+                        // Drop down
+                    }
+                    else {
+                        logger.warn("unrecognized literal datatype: %s", datatype.value);
+                    }
+                }
+                else if (datatypes.size > 0) {
+                    logger.warn("literal type has multiple datatypes: %s", JSON.stringify([...datatypes].map((datatype) => datatype.value)));
+                }
+                else {
+                    logger.debug("literal type has no datatypes");
                 }
                 return new LiteralType({
-                    configuration: this.configuration,
+                    dataFactoryVariable: this.dataFactoryVariable,
                     defaultValue: astType.defaultValue,
-                    hasValue: astType.hasValue,
+                    hasValues: astType.hasValues,
+                    in_: astType.in_,
+                    languageIn: astType.languageIn,
                 });
             }
-            case "ObjectType": {
-                if (astType.listItemType.isJust()) {
-                    return new ListType({
-                        configuration: this.configuration,
-                        identifierNodeKind: astType.nodeKinds.has(NodeKind.BLANK_NODE)
-                            ? NodeKind.BLANK_NODE
-                            : NodeKind.IRI,
-                        itemType: this.createTypeFromAstType(astType.listItemType.unsafeCoerce()),
-                        mintingStrategy: astType.mintingStrategy,
-                        rdfType: astType.rdfType,
-                    });
-                }
+            case "ObjectIntersectionType":
+                throw new Error("not implemented");
+            case "ObjectType":
                 return this.createObjectTypeFromAstType(astType);
-            }
+            case "ObjectUnionType":
+                return new ObjectUnionType({
+                    comment: astType.comment,
+                    dataFactoryVariable: this.dataFactoryVariable,
+                    export_: astType.export,
+                    features: astType.tsFeatures,
+                    label: astType.label,
+                    memberTypes: astType.memberTypes
+                        .map((astType) => this.createTypeFromAstType(astType))
+                        .filter((memberType) => memberType instanceof ObjectType),
+                    name: tsName(astType.name),
+                });
             case "OptionType":
                 return new OptionType({
-                    configuration: this.configuration,
+                    dataFactoryVariable: this.dataFactoryVariable,
                     itemType: this.createTypeFromAstType(astType.itemType),
                 });
+            case "PlaceholderType":
+                throw new Error(astType.kind);
             case "SetType":
                 return new SetType({
-                    configuration: this.configuration,
+                    dataFactoryVariable: this.dataFactoryVariable,
                     itemType: this.createTypeFromAstType(astType.itemType),
                     minCount: astType.minCount,
                 });
+            case "TermType":
+                return new TermType({
+                    dataFactoryVariable: this.dataFactoryVariable,
+                    defaultValue: astType.defaultValue,
+                    hasValues: astType.hasValues,
+                    in_: astType.in_,
+                    nodeKinds: astType.nodeKinds,
+                });
             case "UnionType":
                 return new UnionType({
-                    configuration: this.configuration,
+                    dataFactoryVariable: this.dataFactoryVariable,
                     memberTypes: astType.memberTypes.map((astType) => this.createTypeFromAstType(astType)),
                 });
         }
@@ -108,29 +211,60 @@ export class TypeFactory {
             }
         }
         const identifierType = new IdentifierType({
-            configuration: this.configuration,
+            dataFactoryVariable: this.dataFactoryVariable,
             defaultValue: Maybe.empty(),
-            hasValue: Maybe.empty(),
+            hasValues: [],
+            in_: [],
             nodeKinds: astType.nodeKinds,
         });
         const objectType = new ObjectType({
             abstract: astType.abstract,
-            configuration: this.configuration,
+            comment: astType.comment,
+            dataFactoryVariable: this.dataFactoryVariable,
+            declarationType: astType.tsObjectDeclarationType,
             export_: astType.export,
-            identifierType,
+            extern: astType.extern,
+            features: astType.tsFeatures,
+            fromRdfType: astType.fromRdfType,
+            imports: astType.tsImports,
+            label: astType.label,
             lazyAncestorObjectTypes: () => astType.ancestorObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
             lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
             lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
             lazyProperties: () => {
-                const properties = astType.properties.map((astProperty) => this.createObjectTypePropertyFromAstProperty(astProperty));
-                if (astType.parentObjectTypes.length === 0) {
-                    properties.push(new ObjectType.IdentifierProperty({
-                        configuration: this.configuration,
-                        mintingStrategy: astType.mintingStrategy,
-                        name: this.configuration.objectTypeIdentifierPropertyName,
-                        type: identifierType,
-                    }));
-                } // Else parent will have the identifier property
+                const properties = astType.properties.map((astProperty) => this.createObjectTypePropertyFromAstProperty(astType, astProperty));
+                let identifierPropertyClassDeclarationVisibility;
+                if (astType.abstract) {
+                    // If the type is abstract, don't declare a property.
+                    identifierPropertyClassDeclarationVisibility = Maybe.empty();
+                }
+                else if (astType.ancestorObjectTypes.some((ancestorObjectType) => !ancestorObjectType.abstract)) {
+                    // If the type has a non-abstract ancestor, that ancestor will declare the identifier property
+                    identifierPropertyClassDeclarationVisibility = Maybe.empty();
+                }
+                else if (astType.descendantObjectTypes.some((descendantObjectType) => !descendantObjectType.abstract)) {
+                    // If the type has a non-abstract descendant, declare the identifier property for it
+                    identifierPropertyClassDeclarationVisibility = Maybe.of("protected");
+                }
+                else {
+                    identifierPropertyClassDeclarationVisibility = Maybe.of("private");
+                }
+                const identifierProperty = new ObjectType.IdentifierProperty({
+                    abstract: astType.abstract,
+                    classDeclarationVisibility: identifierPropertyClassDeclarationVisibility,
+                    dataFactoryVariable: this.dataFactoryVariable,
+                    mintingStrategy: astType.mintingStrategy,
+                    name: astType.tsIdentifierPropertyName,
+                    lazyObjectTypeMutable: () => properties.some((property) => property.mutable || property.type.mutable),
+                    objectType: {
+                        declarationType: astType.tsObjectDeclarationType,
+                        features: astType.tsFeatures,
+                    },
+                    override: astType.parentObjectTypes.length > 0,
+                    type: identifierType,
+                    visibility: "public",
+                });
+                properties.push(identifierProperty);
                 // Type discriminator property
                 const typeDiscriminatorValues = new Set();
                 if (!astType.abstract) {
@@ -141,55 +275,54 @@ export class TypeFactory {
                         typeDiscriminatorValues.add(descendantObjectType.discriminatorValue);
                     }
                 }
-                properties.push(new ObjectType.TypeDiscriminatorProperty({
-                    abstract: astType.abstract,
-                    configuration: this.configuration,
-                    name: this.configuration.objectTypeDiscriminatorPropertyName,
-                    override: objectType.parentObjectTypes.length > 0 &&
-                        !objectType.parentObjectTypes[0].abstract,
-                    type: {
-                        name: [...typeDiscriminatorValues]
-                            .sort()
-                            .map((name) => `"${name}"`)
-                            .join("|"),
-                    },
-                    value: objectType.discriminatorValue,
-                }));
+                if (typeDiscriminatorValues.size > 0) {
+                    properties.push(new ObjectType.TypeDiscriminatorProperty({
+                        abstract: astType.abstract,
+                        dataFactoryVariable: this.dataFactoryVariable,
+                        name: astType.tsTypeDiscriminatorPropertyName,
+                        objectType: {
+                            declarationType: astType.tsObjectDeclarationType,
+                            features: astType.tsFeatures,
+                        },
+                        override: objectType.parentObjectTypes.length > 0,
+                        type: new ObjectType.TypeDiscriminatorProperty.Type({
+                            mutable: false,
+                            values: [...typeDiscriminatorValues].sort(),
+                        }),
+                        visibility: "public",
+                        value: objectType.discriminatorValue,
+                    }));
+                }
                 return properties.sort((left, right) => left.name.localeCompare(right.name));
             },
             mintingStrategy: astType.mintingStrategy,
             name: tsName(astType.name),
-            rdfType: astType.rdfType,
+            toRdfTypes: astType.toRdfTypes,
         });
         this.cachedObjectTypesByIdentifier.set(astType.name.identifier, objectType);
         return objectType;
     }
-    createObjectTypePropertyFromAstProperty(astObjectTypeProperty) {
+    createObjectTypePropertyFromAstProperty(astObjectType, astObjectTypeProperty) {
         {
             const cachedProperty = this.cachedObjectTypePropertiesByIdentifier.get(astObjectTypeProperty.name.identifier);
             if (cachedProperty) {
                 return cachedProperty;
             }
         }
-        let type;
-        if (astObjectTypeProperty.type.kind === "ObjectType" &&
-            !astObjectTypeProperty.inline) {
-            // Non-inlined object type = its identifier
-            type = new IdentifierType({
-                configuration: this.configuration,
-                defaultValue: Maybe.empty(),
-                hasValue: Maybe.empty(),
-                nodeKinds: astObjectTypeProperty.type.nodeKinds,
-            });
-        }
-        else {
-            type = this.createTypeFromAstType(astObjectTypeProperty.type);
-        }
         const property = new ObjectType.ShaclProperty({
-            configuration: this.configuration,
+            comment: astObjectTypeProperty.comment,
+            dataFactoryVariable: this.dataFactoryVariable,
+            description: astObjectTypeProperty.description,
+            label: astObjectTypeProperty.label,
+            mutable: astObjectTypeProperty.mutable.orDefault(false),
+            objectType: {
+                declarationType: astObjectType.tsObjectDeclarationType,
+                features: astObjectType.tsFeatures,
+            },
             name: tsName(astObjectTypeProperty.name),
             path: astObjectTypeProperty.path.iri,
-            type,
+            type: this.createTypeFromAstType(astObjectTypeProperty.type),
+            visibility: astObjectTypeProperty.visibility,
         });
         this.cachedObjectTypePropertiesByIdentifier.set(astObjectTypeProperty.name.identifier, property);
         return property;

package/generators/ts/UnionType.d.ts

@@ -1,18 +1,32 @@
 import { Maybe } from "purify-ts";
+import type { TsFeature } from "../../enums/index.js";
+import type { Import } from "./Import.js";
 import { Type } from "./Type.js";
 export declare class UnionType extends Type {
     readonly kind = "UnionType";
     readonly memberTypes: readonly Type[];
-    constructor({ memberTypes, ...superParameters }: ConstructorParameters<typeof Type>[0] & {
+    constructor({ memberTypes, name, ...superParameters }: ConstructorParameters<typeof Type>[0] & {
         memberTypes: readonly Type[];
+        name?: string;
     });
-    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    private _name?;
     get name(): string;
-    private get typesSharedDiscriminatorProperty();
-    equalsFunction(): string;
+    get conversions(): readonly Type.Conversion[];
+    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    get equalsFunction(): string;
+    get jsonName(): string;
+    get mutable(): boolean;
+    private get _discriminatorProperty();
+    private get memberTypeTraits();
+    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression(parameters: Parameters<Type["fromRdfExpression"]>[0]): string;
-    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    propertySparqlGraphPatternExpression(parameters: Parameters<Type["propertySparqlGraphPatternExpression"]>[0]): Type.SparqlGraphPatternExpression | Type.SparqlGraphPatternsExpression;
+    hashStatements({ depth, variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
+    sparqlConstructTemplateTriples(parameters: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
+    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
+    toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
+    useImports(features: Set<TsFeature>): readonly Import[];
+    private ternaryExpression;
 }
 //# sourceMappingURL=UnionType.d.ts.map