@shaclmate/compiler 4.0.48 → 4.0.50

package/dist/generators/ts/TypeFactory.js

@@ -1,540 +0,0 @@
-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

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

package/dist/generators/ts/Typeof.js

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

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

@@ -1,126 +0,0 @@
-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