@shaclmate/compiler 4.0.39 → 4.0.41

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

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

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

@@ -1,18 +1,17 @@
 import type { Literal, NamedNode } from "@rdfjs/types";
 import type { Logger } from "ts-log";
 import * as ast from "../../ast/index.js";
-import { AnonymousUnionType } from "./AnonymousUnionType.js";
-import { NamedObjectType } from "./NamedObjectType.js";
-import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import { NamedUnionType } from "./NamedUnionType.js";
+import { ObjectType } from "./ObjectType.js";
+import { ObjectUnionType } from "./ObjectUnionType.js";
 import type { Reusables } from "./Reusables.js";
 import type { TsGenerator } from "./TsGenerator.js";
 import type { Type } from "./Type.js";
+import { UnionType } from "./UnionType.js";
 export declare class TypeFactory {
     private readonly configuration;
     private readonly logger;
     private readonly reusables;
-    private cachedNamedObjectUnionTypesByShapeIdentifier;
+    private cachedObjectUnionTypesByShapeIdentifier;
     private cachedObjectTypePropertiesByShapeIdentifier;
     private cachedObjectTypesByShapeIdentifier;
     constructor({ configuration, logger, reusables, }: {
@@ -20,12 +19,12 @@ export declare class TypeFactory {
         logger: Logger;
         reusables: Reusables;
     });
-    createNamedObjectType(astType: ast.ObjectType): NamedObjectType;
-    createNamedObjectUnionType(astType: ast.ObjectUnionType): NamedObjectUnionType;
+    createObjectType(astType: ast.ObjectType): ObjectType;
+    createObjectUnionType(astType: ast.ObjectUnionType): ObjectUnionType;
     createType(astType: ast.Type, parameters?: {
         defaultValue?: Literal | NamedNode;
     }): Type;
-    createUnionType(astType: ast.UnionType): AnonymousUnionType | NamedUnionType | NamedObjectUnionType;
+    createUnionType(astType: ast.UnionType): ObjectUnionType | UnionType<Type>;
     private createBlankNodeType;
     private createDefaultValueType;
     private createIdentifierType;

package/dist/generators/ts/TypeFactory.js

@@ -7,7 +7,6 @@ import { Maybe } from "purify-ts";
 import reservedTsIdentifiers_ from "reserved-identifiers";
 import { invariant } from "ts-invariant";
 import * as ast from "../../ast/index.js";
-import { AnonymousUnionType } from "./AnonymousUnionType.js";
 import { BigDecimalType } from "./BigDecimalType.js";
 import { BigIntType } from "./BigIntType.js";
 import { BlankNodeType } from "./BlankNodeType.js";
@@ -24,19 +23,18 @@ import { LazyObjectSetType } from "./LazyObjectSetType.js";
 import { LazyObjectType } from "./LazyObjectType.js";
 import { ListType } from "./ListType.js";
 import { LiteralType } from "./LiteralType.js";
-import { NamedObjectType } from "./NamedObjectType.js";
-import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import { NamedUnionType } from "./NamedUnionType.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 { code } from "./ts-poet-wrapper.js";
+import { UnionType } from "./UnionType.js";
 export class TypeFactory {
     configuration;
     logger;
     reusables;
-    cachedNamedObjectUnionTypesByShapeIdentifier = new TermMap();
+    cachedObjectUnionTypesByShapeIdentifier = new TermMap();
     cachedObjectTypePropertiesByShapeIdentifier = new TermMap();
     cachedObjectTypesByShapeIdentifier = new TermMap();
     constructor({ configuration, logger, reusables, }) {
@@ -44,48 +42,32 @@ export class TypeFactory {
         this.logger = logger;
         this.reusables = reusables;
     }
-    createNamedObjectType(astType) {
+    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: { alias: astType.name },
+            reusables: this.reusables,
+            value: name,
+        }));
         const identifierType = this.createIdentifierType(astType.identifierType);
-        const name = this.tsName(astType.name.unsafeCoerce(), {
-            synthetic: astType.synthetic,
-        });
-        const namedObjectType = new NamedObjectType({
+        const objectType = new ObjectType({
+            alias: astType.name.map((name) => this.tsName(name, { synthetic: astType.synthetic })),
+            discriminantProperty,
             comment: astType.comment,
             configuration: this.configuration,
             extern: astType.extern,
             fromRdfType: astType.fromRdfType,
             identifierType,
             label: astType.label,
-            lazyAncestorObjectTypes: () => astType.ancestorObjectTypes.map((astType) => this.createNamedObjectType(astType)),
-            lazyChildObjectTypes: () => astType.childObjectTypes.map((astType) => this.createNamedObjectType(astType)),
-            lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createNamedObjectType(astType)),
-            lazyDiscriminantProperty: (namedObjectType) => {
-                // Discriminant property
-                const discriminantDescendantValues = new Set();
-                for (const descendantObjectType of namedObjectType.descendantObjectTypes) {
-                    discriminantDescendantValues.add(descendantObjectType.discriminantValue);
-                }
-                return new NamedObjectType.DiscriminantProperty({
-                    configuration: this.configuration,
-                    logger: this.logger,
-                    name: `${this.configuration.syntheticNamePrefix}type`,
-                    namedObjectType,
-                    reusables: this.reusables,
-                    type: new NamedObjectType.DiscriminantProperty.Type({
-                        descendantValues: [...discriminantDescendantValues].sort(),
-                        mutable: false,
-                        ownValues: [namedObjectType.discriminantValue],
-                    }),
-                });
-            },
-            lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createNamedObjectType(astType)),
-            lazyProperties: (namedObjectType) => {
+            lazyProperties: (objectType) => {
                 const properties = astType.properties
                     .toSorted((left, right) => {
                     if (left.order < right.order) {
@@ -98,54 +80,54 @@ export class TypeFactory {
                 })
                     .map((astProperty) => this.createObjectTypeProperty({
                     astObjectTypeProperty: astProperty,
-                    namedObjectType,
+                    objectType,
                 }));
-                properties.splice(0, 0, namedObjectType._discriminantProperty);
-                properties.splice(0, 0, new NamedObjectType.IdentifierProperty({
+                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`,
-                    namedObjectType,
+                    objectType,
                     reusables: this.reusables,
                     type: identifierType,
-                    typeAlias: code `${name}.Identifier`,
                 }));
                 return properties;
             },
             logger: this.logger,
-            name,
             recursive: astType.recursive,
             reusables: this.reusables,
             synthetic: astType.synthetic,
             toRdfTypes: astType.toRdfTypes,
         });
-        this.cachedObjectTypesByShapeIdentifier.set(astType.shapeIdentifier, namedObjectType);
-        return namedObjectType;
+        this.cachedObjectTypesByShapeIdentifier.set(astType.shapeIdentifier, objectType);
+        return objectType;
     }
-    createNamedObjectUnionType(astType) {
+    createObjectUnionType(astType) {
         {
-            const cachedNamedObjectUnionType = this.cachedNamedObjectUnionTypesByShapeIdentifier.get(astType.shapeIdentifier);
-            if (cachedNamedObjectUnionType) {
-                return cachedNamedObjectUnionType;
+            const cachedObjectUnionType = this.cachedObjectUnionTypesByShapeIdentifier.get(astType.shapeIdentifier);
+            if (cachedObjectUnionType) {
+                return cachedObjectUnionType;
             }
         }
-        const namedObjectUnionType = new NamedObjectUnionType({
+        const objectUnionType = new ObjectUnionType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
-            identifierType: this.createIdentifierType(ast.ObjectCompoundType.identifierType(astType)),
+            identifierType: Maybe.of(this.createIdentifierType(ast.ObjectCompoundType.identifierType(astType))),
             label: astType.label,
             logger: this.logger,
             members: ast.ObjectCompoundType.memberObjectTypes(astType).map((namedObjectType) => ({
                 discriminantValue: Maybe.empty(),
-                type: this.createNamedObjectType(namedObjectType),
+                type: this.createObjectType(namedObjectType),
             })),
-            name: this.tsName(astType.name.unsafeCoerce()),
             recursive: astType.recursive,
             reusables: this.reusables,
             synthetic: astType.synthetic,
         });
-        this.cachedNamedObjectUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, namedObjectUnionType);
-        return namedObjectUnionType;
+        this.cachedObjectUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, objectUnionType);
+        return objectUnionType;
     }
     createType(astType, parameters) {
         switch (astType.kind) {
@@ -170,7 +152,7 @@ export class TypeFactory {
             case "Literal":
                 return this.createLiteralType(astType, parameters);
             case "Object":
-                return this.createNamedObjectType(astType);
+                return this.createObjectType(astType);
             case "Option":
                 return this.createOptionType(astType);
             case "Set":
@@ -183,10 +165,10 @@ export class TypeFactory {
     }
     createUnionType(astType) {
         if (astType.isObjectUnionType()) {
-            return this.createNamedObjectUnionType(astType);
+            return this.createObjectUnionType(astType);
         }
-        return astType.name
-            .map((name) => new NamedUnionType({
+        return new UnionType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             identifierType: Maybe.empty(),
@@ -196,26 +178,14 @@ export class TypeFactory {
                 discriminantValue: member.discriminantValue,
                 type: this.createType(member.type),
             })),
-            name,
             recursive: astType.recursive,
             reusables: this.reusables,
-        }))
-            .orDefaultLazy(() => new AnonymousUnionType({
-            comment: astType.comment,
-            configuration: this.configuration,
-            label: astType.label,
-            identifierType: Maybe.empty(),
-            logger: this.logger,
-            members: astType.members.map((member) => ({
-                discriminantValue: member.discriminantValue,
-                type: this.createType(member.type),
-            })),
-            recursive: astType.recursive,
-            reusables: this.reusables,
-        }));
+            synthetic: astType.synthetic,
+        });
     }
     createBlankNodeType(astType) {
         return new BlankNodeType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             label: astType.label,
@@ -229,6 +199,7 @@ export class TypeFactory {
         });
         invariant(DefaultValueType.isItemType(itemType));
         return new DefaultValueType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             defaultValue: astType.defaultValue,
@@ -244,6 +215,7 @@ export class TypeFactory {
                 return this.createBlankNodeType(astType);
             case "Identifier":
                 return new IdentifierType({
+                    alias: astType.name.map((name) => this.tsName(name)),
                     comment: astType.comment,
                     configuration: this.configuration,
                     label: astType.label,
@@ -256,6 +228,7 @@ export class TypeFactory {
     }
     createIriType(astType) {
         return new IriType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             hasValues: astType.hasValues,
@@ -267,6 +240,7 @@ export class TypeFactory {
     }
     createLazyObjectOptionType(astType) {
         return new LazyObjectOptionType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             label: astType.label,
@@ -278,6 +252,7 @@ export class TypeFactory {
     }
     createLazyObjectSetType(astType) {
         return new LazyObjectSetType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             label: astType.label,
@@ -289,6 +264,7 @@ export class TypeFactory {
     }
     createLazyObjectType(astType) {
         return new LazyObjectType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             label: astType.label,
@@ -302,13 +278,13 @@ export class TypeFactory {
         const itemType = this.createType(astType.itemType);
         invariant(ListType.isItemType(itemType));
         return new ListType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             identifierNodeKind: astType.identifierNodeKind,
             itemType,
             label: astType.label,
             logger: this.logger,
-            minCount: 0n,
             mutable: astType.mutable,
             reusables: this.reusables,
             toRdfTypes: astType.toRdfTypes,
@@ -339,6 +315,7 @@ export class TypeFactory {
                 switch (datatypeDefinition.kind) {
                     case "bigdecimal":
                         return new BigDecimalType({
+                            alias: astType.name.map((name) => this.tsName(name)),
                             comment: astType.comment,
                             configuration: this.configuration,
                             hasValues: astType.hasValues,
@@ -350,6 +327,7 @@ export class TypeFactory {
                         });
                     case "bigint":
                         return new BigIntType({
+                            alias: astType.name.map((name) => this.tsName(name)),
                             comment: astType.comment,
                             configuration: this.configuration,
                             datatype,
@@ -363,6 +341,7 @@ export class TypeFactory {
                         });
                     case "boolean":
                         return new BooleanType({
+                            alias: astType.name.map((name) => this.tsName(name)),
                             comment: astType.comment,
                             configuration: this.configuration,
                             datatype,
@@ -377,6 +356,7 @@ export class TypeFactory {
                     case "date":
                     case "datetime":
                         return new (datatypeDefinition.kind === "date" ? DateType : DateTimeType)({
+                            alias: astType.name.map((name) => this.tsName(name)),
                             comment: astType.comment,
                             configuration: this.configuration,
                             datatype,
@@ -393,6 +373,7 @@ export class TypeFactory {
                     case "float":
                     case "int":
                         return new (datatypeDefinition.kind === "float" ? FloatType : IntType)({
+                            alias: astType.name.map((name) => this.tsName(name)),
                             comment: astType.comment,
                             configuration: this.configuration,
                             datatype,
@@ -409,6 +390,7 @@ export class TypeFactory {
                     case "string":
                         if (!datatype.equals(rdf.langString)) {
                             return new StringType({
+                                alias: astType.name.map((name) => this.tsName(name)),
                                 comment: astType.comment,
                                 configuration: this.configuration,
                                 datatype,
@@ -438,6 +420,7 @@ export class TypeFactory {
         //   // this.logger.debug("literal type has no datatypes");
         // }
         return new LiteralType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             hasValues: astType.hasValues,
@@ -448,14 +431,14 @@ export class TypeFactory {
             reusables: this.reusables,
         });
     }
-    createObjectTypeProperty({ astObjectTypeProperty, namedObjectType, }) {
+    createObjectTypeProperty({ astObjectTypeProperty, objectType, }) {
         {
             const cachedProperty = this.cachedObjectTypePropertiesByShapeIdentifier.get(astObjectTypeProperty.shapeIdentifier);
             if (cachedProperty) {
                 return cachedProperty;
             }
         }
-        const property = new NamedObjectType.ShaclProperty({
+        const property = new ObjectType.ShaclProperty({
             comment: astObjectTypeProperty.comment,
             configuration: this.configuration,
             description: astObjectTypeProperty.description,
@@ -463,7 +446,7 @@ export class TypeFactory {
             label: astObjectTypeProperty.label,
             logger: this.logger,
             mutable: astObjectTypeProperty.mutable,
-            namedObjectType,
+            objectType,
             name: this.tsName(astObjectTypeProperty.name),
             path: astObjectTypeProperty.path,
             recursive: !!astObjectTypeProperty.recursive,
@@ -477,6 +460,7 @@ export class TypeFactory {
         const itemType = this.createType(astType.itemType);
         invariant(OptionType.isItemType(itemType));
         return new OptionType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             itemType,
@@ -489,6 +473,7 @@ export class TypeFactory {
         const itemType = this.createType(astType.itemType);
         invariant(SetType.isItemType(itemType));
         return new SetType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             itemType,
@@ -501,6 +486,7 @@ export class TypeFactory {
     }
     createTermType(astType) {
         return new TermType({
+            alias: astType.name.map((name) => this.tsName(name)),
             comment: astType.comment,
             configuration: this.configuration,
             hasValues: astType.hasValues,

package/dist/generators/ts/{AbstractUnionType.d.ts → UnionType.d.ts}

@@ -6,26 +6,41 @@ 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 {
+export declare class UnionType<MemberTypeT extends Type> extends AbstractType {
     private readonly discriminant;
-    private readonly identifierType;
+    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, ...superParameters }: {
+    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 filterFunction(): Code;
+    get filterType(): Code;
+    get graphqlType(): AbstractType.GraphqlType;
+    get hashFunction(): Code;
+    get jsonSchemaFunctionDeclaration(): Code;
+    get jsonTypeAliasDeclaration(): Code;
     get members(): readonly AbstractUnionType.Member<MemberTypeT>[];
     get mutable(): boolean;
+    get expression(): Code;
     get referencesObjectType(): boolean;
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
-    get typeofs(): AbstractType["typeofs"];
+    get jsTypes(): AbstractType["jsTypes"];
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
     protected get inlineEqualsFunction(): Code;
     protected get inlineFilterFunction(): Code;
     protected get inlineFilterType(): Code;
@@ -34,14 +49,27 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     protected get inlineHashFunction(): Code;
     protected get inlineJsonSchema(): Code;
     protected get inlineJsonType(): AbstractType.JsonType;
-    protected get inlineName(): Code;
+    protected get inlineExpression(): Code;
     protected get inlineToJsonFunction(): Code;
     protected get inlineToRdfResourceValuesFunction(): Code;
     protected get inlineToStringFunction(): Code;
     protected get inlineValueSparqlConstructTriplesFunction(): Code;
     protected get inlineValueSparqlWherePatternsFunction(): Code;
     protected get schemaInitializers(): readonly Code[];
+    protected get staticModuleDeclarations(): Record<string, Code>;
+    fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
+    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[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;
@@ -56,17 +84,14 @@ type HybridDiscriminant = {
     readonly kind: "Hybrid";
     readonly memberValues: readonly {
         readonly kind: "Extrinsic" | "Intrinsic";
-        readonly ownValues: readonly AbstractType.DiscriminantProperty.Value[];
+        readonly values: readonly AbstractType.DiscriminantProperty.Value[];
     }[];
     readonly name: string;
 };
 type IntrinsicDiscriminant = {
     readonly jsonName: string;
     readonly kind: "Intrinsic";
-    readonly memberValues: readonly {
-        readonly descendantValues: readonly AbstractType.DiscriminantProperty.Value[];
-        readonly ownValues: readonly AbstractType.DiscriminantProperty.Value[];
-    }[];
+    readonly memberValues: readonly AbstractType.DiscriminantProperty.Value[];
     readonly name: string;
 };
 type TypeofDiscriminant = {
@@ -93,4 +118,4 @@ export declare namespace AbstractUnionType {
     }
 }
 export {};
-//# sourceMappingURL=AbstractUnionType.d.ts.map
+//# sourceMappingURL=UnionType.d.ts.map