@shaclmate/compiler 4.0.14 → 4.0.15

package/dist/Compiler.d.ts

@@ -1,10 +1,13 @@
 import type { Either } from "purify-ts";
+import type { TsFeature } from "./enums/TsFeature.js";
 import type { Generator } from "./generators/Generator.js";
 import type { ShapesGraph } from "./input/ShapesGraph.js";
 export declare class Compiler {
     private readonly generator;
-    constructor({ generator }: {
+    private readonly tsFeaturesDefault?;
+    constructor({ generator, }: {
         generator: Generator;
+        tsFeaturesDefault?: ReadonlySet<TsFeature>;
     });
     compile(shapesGraph: ShapesGraph): Either<Error, string>;
 }

package/dist/Compiler.js

@@ -1,12 +1,14 @@
 import { ShapesGraphToAstTransformer } from "./ShapesGraphToAstTransformer.js";
 export class Compiler {
     generator;
-    constructor({ generator }) {
+    tsFeaturesDefault;
+    constructor({ generator, }) {
         this.generator = generator;
     }
     compile(shapesGraph) {
         return new ShapesGraphToAstTransformer({
             shapesGraph,
+            tsFeaturesDefault: this.tsFeaturesDefault,
         })
             .transform()
             .map((ast) => this.generator.generate(ast));

package/dist/ShapesGraphToAstTransformer.d.ts

@@ -1,12 +1,19 @@
 import TermMap from "@rdfjs/term-map";
-import type * as rdfjs from "@rdfjs/types";
+import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { Either } from "purify-ts";
 import type * as ast from "./ast/index.js";
 import type { TsFeature } from "./enums/TsFeature.js";
 import type * as input from "./input/index.js";
+interface RelatedNodeShapes {
+    readonly ancestors: input.NodeShape[];
+    readonly children: input.NodeShape[];
+    readonly parents: input.NodeShape[];
+    readonly descendants: input.NodeShape[];
+}
 export declare class ShapesGraphToAstTransformer {
-    protected readonly cachedAstTypesByShapeIdentifier: TermMap<rdfjs.BlankNode | rdfjs.NamedNode, ast.Type>;
+    protected readonly cachedAstTypesByShapeIdentifier: TermMap<BlankNode | NamedNode, ast.Type>;
     protected readonly shapesGraph: input.ShapesGraph;
+    protected readonly relatedNodeShapesByIdentifier: TermMap<BlankNode | NamedNode, RelatedNodeShapes>;
     protected tsFeaturesDefault: ReadonlySet<TsFeature>;
     constructor({ shapesGraph, tsFeaturesDefault, }: {
         shapesGraph: input.ShapesGraph;
@@ -14,4 +21,5 @@ export declare class ShapesGraphToAstTransformer {
     });
     transform(): Either<Error, ast.Ast>;
 }
+export {};
 //# sourceMappingURL=ShapesGraphToAstTransformer.d.ts.map

package/dist/ShapesGraphToAstTransformer.js

@@ -1,15 +1,86 @@
 import TermMap from "@rdfjs/term-map";
 import { dash } from "@tpluscode/rdf-ns-builders";
 import { Either } from "purify-ts";
+import { Resource } from "rdfjs-resource";
 import { invariant } from "ts-invariant";
 import { ShapeStack } from "./_ShapesGraphToAstTransformer/ShapeStack.js";
 import { transformShapeToAstType } from "./_ShapesGraphToAstTransformer/transformShapeToAstType.js";
+import { logger } from "./logger.js";
+function relatedNodeShapes(shapesGraph) {
+    const immediateRelatedNodeShapes = new TermMap();
+    for (const childNodeShape of shapesGraph.nodeShapes) {
+        let childRelatedNodeShapes = immediateRelatedNodeShapes.get(childNodeShape.$identifier);
+        if (!childRelatedNodeShapes) {
+            childRelatedNodeShapes = {
+                children: new TermMap(),
+                parents: new TermMap(),
+            };
+            immediateRelatedNodeShapes.set(childNodeShape.$identifier, childRelatedNodeShapes);
+        }
+        for (const parentClassIdentifier of childNodeShape.subClassOf) {
+            shapesGraph
+                .nodeShape(parentClassIdentifier)
+                .ifLeft((error) => {
+                logger.error("%s is rdfs:subClassOf %s which is either missing or not a node shape: %s", childNodeShape, Resource.Identifier.toString(parentClassIdentifier), error.message);
+            })
+                .ifRight((parentNodeShape) => {
+                childRelatedNodeShapes.parents.set(parentNodeShape.$identifier, parentNodeShape);
+                let parentRelatedNodeShapes = immediateRelatedNodeShapes.get(parentNodeShape.$identifier);
+                if (!parentRelatedNodeShapes) {
+                    parentRelatedNodeShapes = {
+                        children: new TermMap(),
+                        parents: new TermMap(),
+                    };
+                    immediateRelatedNodeShapes.set(parentNodeShape.$identifier, parentRelatedNodeShapes);
+                }
+                parentRelatedNodeShapes.children.set(childNodeShape.$identifier, childNodeShape);
+            });
+        }
+    }
+    const result = new TermMap();
+    for (const nodeShape of shapesGraph.nodeShapes) {
+        const { children: childNodeShapes, parents: parentNodeShapes } = immediateRelatedNodeShapes.get(nodeShape.$identifier);
+        const ancestorNodeShapes = new TermMap();
+        function recurseAncestorNodeShapes(nodeShape) {
+            for (const parentNodeShape of immediateRelatedNodeShapes
+                .get(nodeShape.$identifier)
+                .parents.values()) {
+                if (!ancestorNodeShapes.has(parentNodeShape.$identifier)) {
+                    ancestorNodeShapes.set(parentNodeShape.$identifier, parentNodeShape);
+                    recurseAncestorNodeShapes(parentNodeShape);
+                }
+            }
+        }
+        recurseAncestorNodeShapes(nodeShape);
+        const descendantNodeShapes = new TermMap();
+        function recurseDescendantNodeShapes(nodeShape) {
+            for (const childNodeShape of immediateRelatedNodeShapes
+                .get(nodeShape.$identifier)
+                .children.values()) {
+                if (!descendantNodeShapes.has(childNodeShape.$identifier)) {
+                    descendantNodeShapes.set(childNodeShape.$identifier, childNodeShape);
+                    recurseDescendantNodeShapes(childNodeShape);
+                }
+            }
+        }
+        recurseDescendantNodeShapes(nodeShape);
+        result.set(nodeShape.$identifier, {
+            ancestors: [...ancestorNodeShapes.values()],
+            children: [...childNodeShapes.values()],
+            descendants: [...descendantNodeShapes.values()],
+            parents: [...parentNodeShapes.values()],
+        });
+    }
+    return result;
+}
 export class ShapesGraphToAstTransformer {
     // Members are protected so they're accessible to functions in other files
     cachedAstTypesByShapeIdentifier = new TermMap();
     shapesGraph;
+    relatedNodeShapesByIdentifier = new TermMap();
     tsFeaturesDefault;
     constructor({ shapesGraph, tsFeaturesDefault, }) {
+        this.relatedNodeShapesByIdentifier = relatedNodeShapes(shapesGraph);
         this.shapesGraph = shapesGraph;
         this.tsFeaturesDefault =
             tsFeaturesDefault ??
@@ -39,7 +110,7 @@ export class ShapesGraphToAstTransformer {
                     }
                     break;
                 case "ObjectType": {
-                    invariant(nodeShapeAstType.name.isJust());
+                    invariant(nodeShapeAstType.name.isJust(), `node shape missing name: ${nodeShapeAstType.shapeIdentifier}`);
                     astObjectTypes.push(nodeShapeAstType);
                     for (const property of nodeShapeAstType.properties) {
                         switch (property.type.kind) {

package/dist/_ShapesGraphToAstTransformer/nodeShapeIdentifierMintingStrategy.js

@@ -12,20 +12,21 @@ export function nodeShapeIdentifierMintingStrategy(nodeShape) {
         }
         return Either.of(nodeShape.identifierMintingStrategy.map(IdentifierMintingStrategy.fromIri));
     }
-    return Either.sequence(nodeShape.ancestorClassIris.map((nodeShapeIdentifier) => this.shapesGraph.nodeShape(nodeShapeIdentifier))).chain((ancestorNodeShapes) => {
-        for (const ancestorNodeShape of ancestorNodeShapes) {
-            if (ancestorNodeShape.identifierMintingStrategy.isJust()) {
-                return Either.of(ancestorNodeShape.identifierMintingStrategy.map(IdentifierMintingStrategy.fromIri));
-            }
+    // Recurse into parents
+    for (const parentNodeShape of this.relatedNodeShapesByIdentifier.get(nodeShape.$identifier).parents) {
+        const parentNodeShapeIdentifierMintingStrategy = nodeShapeIdentifierMintingStrategy.call(this, parentNodeShape);
+        if (parentNodeShapeIdentifierMintingStrategy.isRight() &&
+            parentNodeShapeIdentifierMintingStrategy.extract().isJust()) {
+            return parentNodeShapeIdentifierMintingStrategy;
         }
-        return shapeNodeKinds
-            .call(this, nodeShape, { defaultNodeShapeNodeKinds })
-            .map((nodeKinds) => {
-            if (nodeKinds.has("BlankNode")) {
-                return Maybe.of("blankNode");
-            }
-            return Maybe.empty();
-        });
+    }
+    return shapeNodeKinds
+        .call(this, nodeShape, { defaultNodeShapeNodeKinds })
+        .map((nodeKinds) => {
+        if (nodeKinds.has("BlankNode")) {
+            return Maybe.of("blankNode");
+        }
+        return Maybe.empty();
     });
 }
 //# sourceMappingURL=nodeShapeIdentifierMintingStrategy.js.map

package/dist/_ShapesGraphToAstTransformer/shapeNodeKinds.js

@@ -10,28 +10,29 @@ function nodeShapeNodeKinds(nodeShape) {
     const thisNodeKinds = nodeShape.nodeKind
         .map(NodeKind.fromIri)
         .orDefault(new Set());
-    return Either.sequence(nodeShape.parentClassIris.map((nodeShapeIdentifier) => this.shapesGraph.nodeShape(nodeShapeIdentifier))).chain((parentNodeShapes) => {
-        const parentNodeKinds = new Set();
-        for (const parentNodeShape of parentNodeShapes) {
-            for (const parentNodeKind of parentNodeShape.nodeKind
-                .map(NodeKind.fromIri)
-                .orDefault(new Set())) {
+    // Recurse into parents
+    const parentNodeKinds = new Set();
+    for (const parentNodeShape of this.relatedNodeShapesByIdentifier.get(nodeShape.$identifier).parents) {
+        nodeShapeNodeKinds
+            .call(this, parentNodeShape)
+            .ifRight((parentNodeKinds_) => {
+            for (const parentNodeKind of parentNodeKinds_) {
                 parentNodeKinds.add(parentNodeKind);
             }
+        });
+    }
+    if (parentNodeKinds.size > 0) {
+        if (thisNodeKinds.size === 0) {
+            return Either.of(parentNodeKinds);
         }
-        if (parentNodeKinds.size > 0) {
-            if (thisNodeKinds.size === 0) {
-                return Either.of(parentNodeKinds);
-            }
-            // Check that thisNodeKinds doesn't conflict with parent node kinds
-            for (const thisNodeKind of thisNodeKinds) {
-                if (!parentNodeKinds.has(thisNodeKind)) {
-                    return Left(new Error(`${nodeShape} has a nodeKind ${thisNodeKind} that is not in its parent's node kinds`));
-                }
+        // Check that thisNodeKinds doesn't conflict with parent node kinds
+        for (const thisNodeKind of thisNodeKinds) {
+            if (!parentNodeKinds.has(thisNodeKind)) {
+                return Left(new Error(`${nodeShape} has a nodeKind ${thisNodeKind} that is not in its parent's node kinds`));
             }
         }
-        return Either.of(thisNodeKinds);
-    });
+    }
+    return Either.of(thisNodeKinds);
 }
 function propertyShapeNodeKinds(propertyShape) {
     return Either.of(propertyShape.nodeKind.map(NodeKind.fromIri).orDefault(new Set()));

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompoundType.js

@@ -11,9 +11,13 @@ import { transformShapeToAstType } from "./transformShapeToAstType.js";
 export function transformShapeToAstCompoundType(shape, shapeStack) {
     shapeStack.push(shape);
     try {
-        return Eithers.chain4(Either.sequence(shape.and.flatMap((and) => and.map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier)))), Either.sequence(shape.nodes.map((nodeShapeIdentifier) => this.shapesGraph.nodeShape(nodeShapeIdentifier))), shape.$type === "NodeShape"
+        return Eithers.chain4(Either.sequence(shape.and
+            .orDefault([])
+            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier))), Either.sequence(shape.nodes.map((nodeShapeIdentifier) => this.shapesGraph.nodeShape(nodeShapeIdentifier))), shape.$type === "NodeShape"
             ? nodeShapeTsFeatures.call(this, shape)
-            : Either.of(new Set()), Either.sequence(shape.xone.flatMap((xone) => xone.map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier))))).chain(([andConstraintShapes, nodeConstraintShapes, tsFeatures, xoneConstraintShapes,]) => {
+            : Either.of(new Set()), Either.sequence(shape.xone
+            .orDefault([])
+            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier)))).chain(([andConstraintShapes, nodeConstraintShapes, tsFeatures, xoneConstraintShapes,]) => {
             let compoundTypeKind;
             // Distinguish constraints that take arbitrary shapes from those that only take node shapes
             // With the latter we'll do special transformations.

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.js

@@ -35,6 +35,7 @@ const astListTypePlaceholderItemType = new ast.BlankNodeType({
     name: Maybe.empty(),
     shapeIdentifier: dataFactory.blankNode(),
 });
+const empty = Either.of(Maybe.empty());
 /**
  * Is an ast.ObjectType actually the shape of an RDF list?
  * If so, return the type of its rdf:first.
@@ -43,13 +44,12 @@ export function transformShapeToAstListType(shape, shapeStack) {
     shapeStack.push(shape);
     try {
         if (shape.$type !== "NodeShape") {
-            return Either.of(Maybe.empty());
+            return empty;
         }
         const nodeShape = shape;
-        if (!nodeShape.isList) {
-            return Either.of(Maybe.empty());
-        }
-        return Eithers.chain3(nodeShapeIdentifierMintingStrategy.call(this, nodeShape), shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.xone.flatMap((xone) => xone.map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier))))).chain(([identifierMintingStrategy, nodeKinds, xone]) => {
+        return Eithers.chain3(nodeShapeIdentifierMintingStrategy.call(this, nodeShape), shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.xone
+            .orDefault([])
+            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier)))).chain(([identifierMintingStrategy, nodeKinds, xone]) => {
             // Put a placeholder in the cache to deal with cyclic references
             // Remove the placeholder if the transformation fails.
             const listType = new ast.ListType({
@@ -78,7 +78,7 @@ export function transformShapeToAstListType(shape, shapeStack) {
                     }
                 }
                 if (!emptyListShape || !nonEmptyListShape) {
-                    return Left(new Error(`${nodeShape} does not have an sh:xone with exactly two shapes, one for the empty list and one for the non-empty list`));
+                    return empty;
                 }
                 return Either.sequence(nonEmptyListShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier))).chain((nonEmptyListShapeProperties) => {
                     let firstPropertyShape;
@@ -95,14 +95,14 @@ export function transformShapeToAstListType(shape, shapeStack) {
                         }
                     }
                     if (!firstPropertyShape) {
-                        return Left(new Error(`${nodeShape} has a non-empty list shape without an sh:property shape whose sh:path is rdf:first`));
+                        return empty;
                     }
                     if (firstPropertyShape.maxCount.extract() !== 1 ||
                         firstPropertyShape.minCount.extract() !== 1) {
                         return Left(new Error(`${nodeShape} non-empty list shape rdf:first property shape does not have sh:maxCount=1 and/or sh:minCount=1`));
                     }
                     if (!restPropertyShape) {
-                        return Left(new Error(`${nodeShape} has a non-empty list shape without an sh:property shape whose sh:path is rdf:rest`));
+                        return empty;
                     }
                     if (restPropertyShape.maxCount.extract() !== 1 ||
                         restPropertyShape.minCount.extract() !== 1) {

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstObjectType.js

@@ -1,3 +1,4 @@
+import { owl, rdfs } from "@tpluscode/rdf-ns-builders";
 import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import * as ast from "../ast/index.js";
@@ -49,24 +50,28 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
             return Either.of(Maybe.empty());
         }
         const nodeShape = shape;
-        if (nodeShape.and.length > 0 || nodeShape.xone.length > 0) {
+        if (nodeShape.and.orDefault([]).length > 0 ||
+            nodeShape.xone.orDefault([]).length > 0) {
             return Either.of(Maybe.empty());
         }
         if (nodeShape.$identifier.termType !== "NamedNode") {
             return Either.of(Maybe.empty());
         }
-        return Eithers.chain9(Either.sequence(nodeShape.ancestorClassIris.map((nodeShapeIdentifier) => this.shapesGraph.nodeShape(nodeShapeIdentifier))), Either.sequence(nodeShape.childClassIris.map((nodeShapeIdentifier) => this.shapesGraph.nodeShape(nodeShapeIdentifier))), Either.sequence(nodeShape.descendantClassIris.map((nodeShapeIdentifier) => this.shapesGraph.nodeShape(nodeShapeIdentifier))), Either.sequence(nodeShape.parentClassIris.map((nodeShapeIdentifier) => this.shapesGraph.nodeShape(nodeShapeIdentifier))), nodeShapeIdentifierMintingStrategy.call(this, nodeShape), shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier))), nodeShapeTsFeatures.call(this, nodeShape), nodeShape.tsObjectDeclarationType.isJust()
+        return Eithers.chain5(nodeShapeIdentifierMintingStrategy.call(this, nodeShape), shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier))), nodeShapeTsFeatures.call(this, nodeShape), nodeShape.tsObjectDeclarationType.isJust()
             ? Either.of(nodeShape.tsObjectDeclarationType.map(TsObjectDeclarationType.fromIri))
             : shapeOntology
                 .call(this, nodeShape)
-                .map((ontology) => ontology.chain((ontology) => ontology.tsObjectDeclarationType.map(TsObjectDeclarationType.fromIri)))).chain(([ancestorNodeShapes, childNodeShapes, descendantNodeShapes, parentNodeShapes, identifierMintingStrategy, nodeKinds, propertyShapes, tsFeatures, tsObjectDeclarationType,]) => {
+                .map((ontology) => ontology.chain((ontology) => ontology.tsObjectDeclarationType.map(TsObjectDeclarationType.fromIri)))).chain(([identifierMintingStrategy, nodeKinds, propertyShapes, tsFeatures, tsObjectDeclarationType,]) => {
             const abstract = nodeShape.abstract.orDefault(false);
+            const { ancestors: ancestorNodeShapes, descendants: descendantNodeShapes, children: childNodeShapes, parents: parentNodeShapes, } = this.relatedNodeShapesByIdentifier.get(nodeShape.$identifier);
+            const isClass = nodeShape.subClassOf.length > 0 ||
+                descendantNodeShapes.length > 0 || // A node shape that is the object of an rdfs:subClassOf is itself an rdfs:Class
+                nodeShape.types.some((type) => type.equals(owl.Class) || type.equals(rdfs.Class));
             let fromRdfType;
             let toRdfTypes;
             if (!abstract) {
                 fromRdfType = nodeShape.fromRdfType.alt(nodeShape.rdfType);
-                if (nodeShape.isClass &&
-                    nodeShape.$identifier.termType === "NamedNode") {
+                if (isClass && nodeShape.$identifier.termType === "NamedNode") {
                     fromRdfType = fromRdfType.alt(Maybe.of(nodeShape.$identifier));
                 }
                 toRdfTypes = nodeShape.toRdfTypes.concat();

package/dist/generators/ts/AbstractCollectionType.js

@@ -55,12 +55,6 @@ export class AbstractCollectionType extends AbstractContainerType {
             }
         }
         if (this.minCount === 0) {
-            conversions.push({
-                conversionExpression: () => code `[]`,
-                sourceTypeCheckExpression: (value) => code `${value} === undefined`,
-                sourceTypeName: code `undefined`,
-                sourceTypeof: "undefined",
-            });
             if (Object.keys(itemTypeConversionsByTypeof).length <= 1) {
                 // There were no additional conversions with different item typeof's, so we don't need to check .every or do .map
                 // Just check that the original value is an array with typeof "object". Array.isArray() doesn't narrow types for some reason.
@@ -101,7 +95,7 @@ export class AbstractCollectionType extends AbstractContainerType {
                                 case "function":
                                 case "symbol":
                                 case "undefined":
-                                    throw new Error("not implemented");
+                                    throw new Error(`source type check on ${itemTypeof} not implemented`);
                             }
                         },
                         sourceTypeName: code `readonly (${itemTypeofConversion.sourceTypeName})[]`,

package/dist/generators/ts/AbstractTermType.d.ts

@@ -31,6 +31,7 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     get conversions(): readonly AbstractType.Conversion[];
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get schema(): Code;
+    get termTypes(): ReadonlySet<"BlankNode" | "Literal" | "NamedNode">;
     get valueSparqlConstructTriplesFunction(): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
     hashStatements({ variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];

package/dist/generators/ts/AbstractTermType.js

@@ -90,6 +90,9 @@ export class AbstractTermType extends AbstractType {
     get schema() {
         return code `${removeUndefined(this.schemaObject)}`;
     }
+    get termTypes() {
+        return new Set([...this.nodeKinds].map(NodeKind.toTermType));
+    }
     get valueSparqlConstructTriplesFunction() {
         return code `((_: object) => [])`;
     }
@@ -164,6 +167,9 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], AbstractTermType.prototype, "termTypes", null);
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "valueSparqlConstructTriplesFunction", null);

package/dist/generators/ts/AbstractUnionType.d.ts

@@ -4,6 +4,7 @@ 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 abstract class AbstractUnionType<MemberTypeT extends Type> extends AbstractType {
     private readonly discriminant;
@@ -45,18 +46,37 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     jsonUiSchemaElement(): Maybe<Code>;
     protected inlineHashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
 }
-type Discriminant = EnvelopeDiscriminant | InlineDiscriminant | TypeofDiscriminant;
-type EnvelopeDiscriminant = {
-    kind: "envelope";
-} & AbstractType.DiscriminantProperty;
-type InlineDiscriminant = {
-    kind: "inline";
-} & AbstractType.DiscriminantProperty;
+type Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;
+type ExtrinsicDiscriminant = {
+    readonly kind: "extrinsic";
+    readonly memberValues: readonly AbstractType.DiscriminantProperty.Value[];
+    readonly name: string;
+};
+type HybridDiscriminant = {
+    readonly kind: "hybrid";
+    readonly memberValues: readonly {
+        readonly kind: "extrinsic" | "intrinsic";
+        readonly ownValues: readonly AbstractType.DiscriminantProperty.Value[];
+    }[];
+    readonly name: string;
+};
+type IntrinsicDiscriminant = {
+    readonly kind: "intrinsic";
+    readonly memberValues: readonly {
+        readonly descendantValues: readonly AbstractType.DiscriminantProperty.Value[];
+        readonly ownValues: readonly AbstractType.DiscriminantProperty.Value[];
+    }[];
+    readonly name: string;
+};
 type TypeofDiscriminant = {
-    kind: "typeof";
+    readonly kind: "typeof";
+    readonly memberValues: readonly Typeof[];
 };
 export declare namespace Discriminant {
-    function infer(memberTypes: readonly Type[]): Discriminant;
+    function infer(members: readonly {
+        readonly discriminantValue: Maybe<number | string>;
+        readonly type: Type;
+    }[]): Discriminant;
 }
 export declare namespace AbstractUnionType {
     interface AbstractMember<TypeT extends Type> {
@@ -67,10 +87,12 @@ export declare namespace AbstractUnionType {
     interface ConcreteMember<TypeT extends Type> {
         readonly abstract: false;
         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;
     }