@shaclmate/compiler 4.0.50 → 4.0.51

package/dist/generators/ts/TypeFactory.js

@@ -0,0 +1,540 @@
+import TermMap from "@rdfjs/term-map";
+import TermSet from "@rdfjs/term-set";
+import { LiteralDecoder, literalDatatypeDefinitions } from "@rdfx/literal";
+import base62 from "@sindresorhus/base62";
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import reservedTsIdentifiers_ from "reserved-identifiers";
+import { invariant } from "ts-invariant";
+import * as ast from "../../ast/index.js";
+import { BigDecimalType } from "./BigDecimalType.js";
+import { BigIntType } from "./BigIntType.js";
+import { BlankNodeType } from "./BlankNodeType.js";
+import { BooleanType } from "./BooleanType.js";
+import { DateTimeType } from "./DateTimeType.js";
+import { DateType } from "./DateType.js";
+import { DefaultValueType } from "./DefaultValueType.js";
+import { FloatType } from "./FloatType.js";
+import { IdentifierType } from "./IdentifierType.js";
+import { IntType } from "./IntType.js";
+import { IriType } from "./IriType.js";
+import { LazyOptionType } from "./LazyOptionType.js";
+import { LazySetType } from "./LazySetType.js";
+import { LazyType } from "./LazyType.js";
+import { ListType } from "./ListType.js";
+import { LiteralType } from "./LiteralType.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();
+    cachedObjectTypePropertiesByShapeIdentifier = new TermMap();
+    cachedObjectTypesByShapeIdentifier = new TermMap();
+    constructor({ configuration, logger, reusables, }) {
+        this.configuration = configuration;
+        this.logger = logger;
+        this.reusables = reusables;
+    }
+    createObjectType(astType) {
+        {
+            const cachedObjectType = this.cachedObjectTypesByShapeIdentifier.get(astType.shapeIdentifier);
+            if (cachedObjectType) {
+                return cachedObjectType;
+            }
+        }
+        const discriminantProperty = astType.name.map((name) => new ObjectType.DiscriminantProperty({
+            configuration: this.configuration,
+            logger: this.logger,
+            name: `${this.configuration.syntheticNamePrefix}type`,
+            objectType: { name: astType.name },
+            reusables: this.reusables,
+            value: name,
+        }));
+        const identifierType = this.createIdentifierType(astType.identifierType);
+        const objectType = new ObjectType({
+            discriminantProperty,
+            comment: astType.comment,
+            configuration: this.configuration,
+            extern: astType.extern,
+            fromRdfType: astType.fromRdfType,
+            identifierType,
+            label: astType.label,
+            lazyProperties: (objectType) => {
+                const properties = astType.fields
+                    .toSorted((left, right) => {
+                    if (left.order < right.order) {
+                        return -1;
+                    }
+                    if (left.order > right.order) {
+                        return 1;
+                    }
+                    return this.tsName(left.name).localeCompare(this.tsName(right.name));
+                })
+                    .map((astField) => this.createObjectTypeProperty({
+                    astStructField: astField,
+                    objectType,
+                }));
+                discriminantProperty.ifJust((discriminantProperty) => {
+                    properties.splice(0, 0, discriminantProperty);
+                });
+                properties.splice(0, 0, new ObjectType.IdentifierProperty({
+                    configuration: this.configuration,
+                    logger: this.logger,
+                    name: `${this.configuration.syntheticNamePrefix}identifier`,
+                    objectType,
+                    reusables: this.reusables,
+                    type: identifierType,
+                }));
+                return properties;
+            },
+            logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name, { synthetic: astType.synthetic })),
+            recursive: astType.recursive,
+            reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
+            synthetic: astType.synthetic,
+            toRdfTypes: astType.toRdfTypes,
+        });
+        this.cachedObjectTypesByShapeIdentifier.set(astType.shapeIdentifier, objectType);
+        return objectType;
+    }
+    createObjectUnionType(astType) {
+        {
+            const cachedObjectUnionType = this.cachedObjectUnionTypesByShapeIdentifier.get(astType.shapeIdentifier);
+            if (cachedObjectUnionType) {
+                return cachedObjectUnionType;
+            }
+        }
+        const objectUnionType = new ObjectUnionType({
+            comment: astType.comment,
+            configuration: this.configuration,
+            identifierType: Maybe.of(this.createIdentifierType(ast.StructCompoundType.identifierType(astType))),
+            label: astType.label,
+            logger: this.logger,
+            members: ast.StructCompoundType.memberStructTypes(astType).map((astStructType) => ({
+                discriminantValue: Maybe.empty(),
+                type: this.createObjectType(astStructType),
+            })),
+            name: astType.name.map((name) => this.tsName(name)),
+            recursive: astType.recursive,
+            reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
+            synthetic: astType.synthetic,
+        });
+        this.cachedObjectUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, objectUnionType);
+        return objectUnionType;
+    }
+    createType(astType, parameters) {
+        switch (astType.kind) {
+            case "BlankNode":
+                return this.createBlankNodeType(astType);
+            case "DefaultValue":
+                return this.createDefaultValueType(astType);
+            case "Identifier":
+                return this.createIdentifierType(astType);
+            case "Intersection":
+                throw new Error("not implemented");
+            case "Iri":
+                return this.createIriType(astType);
+            case "Lazy":
+                return this.createLazyType(astType);
+            case "LazyOption":
+                return this.createLazyOptionType(astType);
+            case "LazySet":
+                return this.createLazySetType(astType);
+            case "List":
+                return this.createListType(astType);
+            case "Literal":
+                return this.createLiteralType(astType, parameters);
+            case "Option":
+                return this.createOptionType(astType);
+            case "Set":
+                return this.createSetType(astType);
+            case "Struct":
+                return this.createObjectType(astType);
+            case "Term":
+                return this.createTermType(astType);
+            case "Union":
+                return this.createUnionType(astType);
+        }
+    }
+    createUnionType(astType) {
+        if (astType.isStructUnionType()) {
+            return this.createObjectUnionType(astType);
+        }
+        return new UnionType({
+            comment: astType.comment,
+            configuration: this.configuration,
+            identifierType: Maybe.empty(),
+            label: astType.label,
+            logger: this.logger,
+            members: astType.members.map((member) => ({
+                discriminantValue: member.discriminantValue,
+                type: this.createType(member.type),
+            })),
+            name: astType.name.map((name) => this.tsName(name)),
+            recursive: astType.recursive,
+            reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
+            synthetic: astType.synthetic,
+        });
+    }
+    createBlankNodeType(astType) {
+        return new BlankNodeType({
+            comment: astType.comment,
+            configuration: this.configuration,
+            label: astType.label,
+            logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
+            reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
+        });
+    }
+    createDefaultValueType(astType) {
+        const itemType = this.createType(astType.itemType, {
+            defaultValue: astType.defaultValue,
+        });
+        invariant(DefaultValueType.isItemType(itemType));
+        return new DefaultValueType({
+            comment: astType.comment,
+            configuration: this.configuration,
+            defaultValue: astType.defaultValue,
+            itemType,
+            label: astType.label,
+            logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
+            reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
+        });
+    }
+    createIdentifierType(astType) {
+        switch (astType.kind) {
+            case "BlankNode":
+                return this.createBlankNodeType(astType);
+            case "Identifier":
+                return new IdentifierType({
+                    comment: astType.comment,
+                    configuration: this.configuration,
+                    label: astType.label,
+                    logger: this.logger,
+                    name: astType.name.map((name) => this.tsName(name)),
+                    reusables: this.reusables,
+                    shapeIdentifier: astType.shapeIdentifier,
+                });
+            case "Iri":
+                return this.createIriType(astType);
+        }
+    }
+    createIriType(astType) {
+        return new IriType({
+            comment: astType.comment,
+            configuration: this.configuration,
+            hasValues: astType.hasValues,
+            in_: astType.in_,
+            label: astType.label,
+            logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
+            reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
+        });
+    }
+    createLazyOptionType(astType) {
+        return new LazyOptionType({
+            comment: astType.comment,
+            configuration: this.configuration,
+            label: astType.label,
+            logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
+            partialType: this.createOptionType(astType.partialType),
+            resolveType: this.createOptionType(astType.resolveType),
+            reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
+        });
+    }
+    createLazySetType(astType) {
+        return new LazySetType({
+            comment: astType.comment,
+            configuration: this.configuration,
+            label: astType.label,
+            logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
+            partialType: this.createSetType(astType.partialType),
+            resolveType: this.createSetType(astType.resolveType),
+            reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
+        });
+    }
+    createLazyType(astType) {
+        return new LazyType({
+            comment: astType.comment,
+            configuration: this.configuration,
+            label: astType.label,
+            logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
+            partialType: this.createType(astType.partialType),
+            resolveType: this.createType(astType.resolveType),
+            reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
+        });
+    }
+    createListType(astType) {
+        const itemType = this.createType(astType.itemType);
+        invariant(ListType.isItemType(itemType));
+        return new ListType({
+            comment: astType.comment,
+            configuration: this.configuration,
+            identifierNodeKind: astType.identifierNodeKind,
+            itemType,
+            label: astType.label,
+            logger: this.logger,
+            mutable: astType.mutable,
+            name: astType.name.map((name) => this.tsName(name)),
+            reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
+            toRdfTypes: astType.toRdfTypes,
+        });
+    }
+    createLiteralType(astType, parameters) {
+        // Look at sh:datatype as well as sh:defaultValue, sh:hasValue, and sh:in 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));
+        if (datatypes.size === 0) {
+            if (parameters?.defaultValue &&
+                parameters.defaultValue.termType === "Literal") {
+                datatypes.add(parameters.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];
+            const datatypeDefinition = literalDatatypeDefinitions[datatype.value];
+            if (datatypeDefinition) {
+                switch (datatypeDefinition.kind) {
+                    case "bigdecimal":
+                        return new BigDecimalType({
+                            comment: astType.comment,
+                            configuration: this.configuration,
+                            hasValues: astType.hasValues,
+                            in_: astType.in_,
+                            label: astType.label,
+                            languageIn: [],
+                            logger: this.logger,
+                            name: astType.name.map((name) => this.tsName(name)),
+                            reusables: this.reusables,
+                            shapeIdentifier: astType.shapeIdentifier,
+                        });
+                    case "bigint":
+                        return new BigIntType({
+                            comment: astType.comment,
+                            configuration: this.configuration,
+                            datatype,
+                            hasValues: astType.hasValues,
+                            in_: astType.in_,
+                            label: astType.label,
+                            languageIn: [],
+                            logger: this.logger,
+                            name: astType.name.map((name) => this.tsName(name)),
+                            primitiveIn: astType.in_.map((value) => LiteralDecoder.decodeBigIntLiteral(value).unsafeCoerce()),
+                            reusables: this.reusables,
+                            shapeIdentifier: astType.shapeIdentifier,
+                        });
+                    case "boolean":
+                        return new BooleanType({
+                            comment: astType.comment,
+                            configuration: this.configuration,
+                            datatype,
+                            hasValues: astType.hasValues,
+                            label: astType.label,
+                            languageIn: [],
+                            in_: astType.in_,
+                            logger: this.logger,
+                            name: astType.name.map((name) => this.tsName(name)),
+                            primitiveIn: astType.in_.map((value) => LiteralDecoder.decodeBooleanLiteral(value).unsafeCoerce()),
+                            reusables: this.reusables,
+                            shapeIdentifier: astType.shapeIdentifier,
+                        });
+                    case "date":
+                    case "datetime":
+                        return new (datatypeDefinition.kind === "date" ? DateType : DateTimeType)({
+                            comment: astType.comment,
+                            configuration: this.configuration,
+                            datatype,
+                            hasValues: astType.hasValues,
+                            in_: astType.in_,
+                            label: astType.label,
+                            languageIn: [],
+                            logger: this.logger,
+                            name: astType.name.map((name) => this.tsName(name)),
+                            primitiveIn: astType.in_.map((value) => (datatypeDefinition.kind === "date"
+                                ? LiteralDecoder.decodeDateLiteral
+                                : LiteralDecoder.decodeDateTimeLiteral)(value).unsafeCoerce()),
+                            reusables: this.reusables,
+                            shapeIdentifier: astType.shapeIdentifier,
+                        });
+                    case "float":
+                    case "int":
+                        return new (datatypeDefinition.kind === "float" ? FloatType : IntType)({
+                            comment: astType.comment,
+                            configuration: this.configuration,
+                            datatype,
+                            hasValues: astType.hasValues,
+                            in_: astType.in_,
+                            label: astType.label,
+                            languageIn: [],
+                            logger: this.logger,
+                            name: astType.name.map((name) => this.tsName(name)),
+                            primitiveIn: astType.in_.map((value) => (datatypeDefinition.kind === "float"
+                                ? LiteralDecoder.decodeFloatLiteral
+                                : LiteralDecoder.decodeIntLiteral)(value).unsafeCoerce()),
+                            reusables: this.reusables,
+                            shapeIdentifier: astType.shapeIdentifier,
+                        });
+                    case "string":
+                        if (!datatype.equals(rdf.langString)) {
+                            return new StringType({
+                                comment: astType.comment,
+                                configuration: this.configuration,
+                                datatype,
+                                hasValues: astType.hasValues,
+                                in_: astType.in_,
+                                label: astType.label,
+                                languageIn: astType.languageIn,
+                                logger: this.logger,
+                                name: astType.name.map((name) => this.tsName(name)),
+                                primitiveIn: astType.in_.map((value) => value.value),
+                                reusables: this.reusables,
+                                shapeIdentifier: astType.shapeIdentifier,
+                            });
+                        }
+                        break;
+                }
+            }
+            if (datatype.equals(rdf.langString)) {
+                // Drop down
+            }
+            else {
+                this.logger.warn("unrecognized literal datatype: %s", datatype.value);
+            }
+        }
+        else if (datatypes.size > 0) {
+            this.logger.warn("literal type has multiple datatypes: %s", JSON.stringify([...datatypes].map((datatype) => datatype.value)));
+        }
+        // } else {
+        //   // this.logger.debug("literal type has no datatypes");
+        // }
+        return new LiteralType({
+            comment: astType.comment,
+            configuration: this.configuration,
+            hasValues: astType.hasValues,
+            in_: astType.in_,
+            label: astType.label,
+            languageIn: astType.languageIn,
+            logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
+            reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
+        });
+    }
+    createObjectTypeProperty({ astStructField, objectType, }) {
+        {
+            const cachedProperty = this.cachedObjectTypePropertiesByShapeIdentifier.get(astStructField.shapeIdentifier);
+            if (cachedProperty) {
+                return cachedProperty;
+            }
+        }
+        const property = new ObjectType.ShaclProperty({
+            comment: astStructField.comment,
+            configuration: this.configuration,
+            description: astStructField.description,
+            display: astStructField.display,
+            label: astStructField.label,
+            logger: this.logger,
+            mutable: astStructField.mutable,
+            name: this.tsName(astStructField.name),
+            objectType,
+            path: astStructField.path,
+            recursive: !!astStructField.recursive,
+            reusables: this.reusables,
+            type: this.createType(astStructField.type),
+        });
+        this.cachedObjectTypePropertiesByShapeIdentifier.set(astStructField.shapeIdentifier, property);
+        return property;
+    }
+    createOptionType(astType) {
+        const itemType = this.createType(astType.itemType);
+        invariant(OptionType.isItemType(itemType));
+        return new OptionType({
+            comment: astType.comment,
+            configuration: this.configuration,
+            itemType,
+            label: astType.label,
+            logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
+            reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
+        });
+    }
+    createSetType(astType) {
+        const itemType = this.createType(astType.itemType);
+        invariant(SetType.isItemType(itemType));
+        return new SetType({
+            comment: astType.comment,
+            configuration: this.configuration,
+            itemType,
+            label: astType.label,
+            logger: this.logger,
+            mutable: astType.mutable,
+            minCount: astType.minCount,
+            name: astType.name.map((name) => this.tsName(name)),
+            reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
+        });
+    }
+    createTermType(astType) {
+        return new TermType({
+            comment: astType.comment,
+            configuration: this.configuration,
+            hasValues: astType.hasValues,
+            in_: astType.in_,
+            label: astType.label,
+            logger: this.logger,
+            name: astType.name.map((name) => this.tsName(name)),
+            nodeKinds: astType.nodeKinds,
+            reusables: this.reusables,
+            shapeIdentifier: astType.shapeIdentifier,
+        });
+    }
+    tsName(name, options) {
+        if (name[0] === "$") {
+            return name;
+        }
+        // Adapted from https://github.com/sindresorhus/to-valid-identifier , MIT license
+        if (reservedTsIdentifiers.has(name)) {
+            // We prefix with underscore to avoid any potential conflicts with the Base62 encoded string.
+            return `$_${name}$`;
+        }
+        let tsName = name.replaceAll(/\P{ID_Continue}/gu, (x) => `$${base62.encodeInteger(x.codePointAt(0))}$`);
+        if (options?.synthetic) {
+            tsName = `${this.configuration.syntheticNamePrefix}${tsName}`;
+        }
+        return tsName;
+    }
+}
+const reservedTsIdentifiers = reservedTsIdentifiers_({
+    includeGlobalProperties: true,
+});
+//# sourceMappingURL=TypeFactory.js.map

package/dist/generators/ts/Typeof.d.ts

@@ -0,0 +1,2 @@
+export type Typeof = "bigint" | "boolean" | "function" | "number" | "object" | "string" | "symbol" | "undefined";
+//# sourceMappingURL=Typeof.d.ts.map

package/dist/generators/ts/Typeof.js

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

package/dist/generators/ts/UnionType.d.ts

@@ -0,0 +1,126 @@
+import { Maybe } from "purify-ts";
+import { AbstractType } from "./AbstractType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
+import type { IdentifierType } from "./IdentifierType.js";
+import type { IriType } from "./IriType.js";
+import type { Type } from "./Type.js";
+import type { Typeof } from "./Typeof.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class UnionType<MemberTypeT extends Type> extends AbstractType {
+    private readonly discriminant;
+    readonly graphqlArgs: AbstractType["graphqlArgs"];
+    readonly identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
+    readonly kind: "ObjectUnion" | "Union";
+    readonly recursive: boolean;
+    readonly synthetic: boolean;
+    readonly validationFunction: Maybe<Code>;
+    constructor({ identifierType, members, recursive, synthetic, ...superParameters }: {
+        identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
+        members: readonly (Pick<AbstractUnionType.Member<MemberTypeT>, "type"> & {
+            readonly discriminantValue: Maybe<number | string>;
+        })[];
+        recursive: boolean;
+        synthetic: boolean;
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
+    get declaration(): Maybe<Code>;
+    get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
+    get equalsFunction(): Code;
+    get expression(): Code;
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get fromRdfResourceValuesFunction(): Code;
+    get graphqlType(): AbstractType.GraphqlType;
+    get hashFunction(): Code;
+    get jsTypes(): AbstractType["jsTypes"];
+    get jsonSchemaFunctionDeclaration(): Code;
+    get jsonTypeAliasDeclaration(): Code;
+    get members(): readonly AbstractUnionType.Member<MemberTypeT>[];
+    get mutable(): boolean;
+    get referencesNamedType(): boolean;
+    get schema(): Code;
+    get schemaType(): Code;
+    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
+    protected get schemaInitializers(): readonly Code[];
+    protected get schemaTypeExpression(): Code;
+    protected get staticModuleDeclarations(): Record<string, Code>;
+    private get equalsFunctionExpression();
+    private get filterFunctionExpression();
+    private get filterTypeLiteral();
+    private get fromJsonFunctionExpression();
+    private get fromRdfResourceValuesFunctionExpression();
+    private get hashFunctionExpression();
+    /**
+     * An inline expression of this type rather than a type reference/name.
+     */
+    private get inlineExpression();
+    private get jsonSchemaExpression();
+    private get jsonTypeLiteral();
+    private get toJsonFunctionExpression();
+    private get toRdfResourceValuesFunctionExpression();
+    private get toStringFunctionExpression();
+    private get valueSparqlConstructTriplesFunctionExpression();
+    private get valueSparqlWherePatternsFunctionExpression();
+    fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
+    graphqlResolveExpression({ variables, }: {
+        variables: {
+            value: Code;
+        };
+    }): Code;
+    jsonSchema({ context, }: Parameters<AbstractType["jsonSchema"]>[0]): Code;
+    jsonType(): AbstractType.JsonType;
+    jsonUiSchemaElement(): Maybe<Code>;
+    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
+    private readonly lazyMembers;
+}
+type Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;
+type ExtrinsicDiscriminant = {
+    readonly jsonName: string;
+    readonly kind: "Extrinsic";
+    readonly memberValues: readonly AbstractType.DiscriminantProperty.Value[];
+    readonly name: string;
+};
+type HybridDiscriminant = {
+    readonly jsonName: string;
+    readonly kind: "Hybrid";
+    readonly memberValues: readonly {
+        readonly kind: "Extrinsic" | "Intrinsic";
+        readonly values: readonly AbstractType.DiscriminantProperty.Value[];
+    }[];
+    readonly name: string;
+};
+type IntrinsicDiscriminant = {
+    readonly jsonName: string;
+    readonly kind: "Intrinsic";
+    readonly memberValues: readonly AbstractType.DiscriminantProperty.Value[];
+    readonly name: string;
+};
+type TypeofDiscriminant = {
+    readonly kind: "Typeof";
+    readonly memberValues: readonly Typeof[];
+};
+export declare namespace Discriminant {
+    function infer(members: readonly {
+        readonly discriminantValue: Maybe<number | string>;
+        readonly type: Type;
+    }[]): Discriminant;
+}
+export declare namespace AbstractUnionType {
+    interface Member<TypeT extends Type> {
+        readonly discriminantValues: readonly AbstractType.DiscriminantProperty.Value[];
+        readonly jsonType: Code | string;
+        readonly jsonTypeCheck: (instance: Code) => Code;
+        readonly primaryDiscriminantValue: AbstractType.DiscriminantProperty.Value;
+        readonly type: TypeT;
+        readonly typeCheck: (instance: Code) => Code;
+        readonly typeToJsonExpression: (valueVariable: Code) => Code;
+        readonly unwrap: (instance: Code) => Code;
+        readonly wrap: (instance: Code) => Code;
+    }
+}
+export {};
+//# sourceMappingURL=UnionType.d.ts.map