@shaclmate/compiler 4.0.79 → 4.0.81

package/dist/generators/ts/DiscriminatedUnionType.d.ts

@@ -1,74 +1,6 @@
-import { Maybe } from "purify-ts";
-import type { DiscriminatedUnionType_Discriminant } from "./_DiscriminatedUnionType/DiscriminatedUnionType_Discriminant.js";
-import { AbstractType } from "./AbstractType.js";
-import type { BlankNodeType } from "./BlankNodeType.js";
-import type { IdentifierType } from "./IdentifierType.js";
-import type { IriType } from "./IriType.js";
+import { AbstractDiscriminatedUnionType } from "./AbstractDiscriminatedUnionType.js";
 import type { Type } from "./Type.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class DiscriminatedUnionType<MemberTypeT extends Type> extends AbstractType {
-    protected readonly discriminant: DiscriminatedUnionType.Discriminant;
-    readonly graphqlArgs: AbstractType["graphqlArgs"];
-    readonly identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
-    readonly kind: "ObjectDiscriminatedUnion" | "DiscriminatedUnion";
-    readonly recursive: boolean;
-    readonly validationFunction: Maybe<Code>;
-    constructor({ identifierType, members, recursive, ...superParameters }: {
-        identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
-        members: readonly (Pick<DiscriminatedUnionType.Member<MemberTypeT>, "type"> & {
-            readonly discriminantValue: Maybe<number | string>;
-        })[];
-        recursive: boolean;
-        synthetic: boolean;
-    } & ConstructorParameters<typeof AbstractType>[0]);
-    get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
-    get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
-    get equalsFunction(): 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 DiscriminatedUnionType.Member<MemberTypeT>[];
-    get mutable(): boolean;
-    get referencesNamedType(): boolean;
-    get schemaType(): Code;
-    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
-    get valueSparqlConstructTriplesFunction(): Code;
-    get valueSparqlWherePatternsFunction(): Code;
-    protected get inlineExpression(): Code;
-    protected get schemaInitializers(): readonly Code[];
-    private get conversionFunctionExpression();
-    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;
-    protected staticModuleDeclarations(name: string): Record<string, Code>;
-    private readonly lazyMembers;
-}
-export declare namespace DiscriminatedUnionType {
-    type Discriminant = DiscriminatedUnionType_Discriminant;
-    interface Member<TypeT extends Type> {
-        readonly discriminantValues: readonly AbstractType.DiscriminantProperty.Value[];
-        readonly jsonType: Code;
-        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 declare class DiscriminatedUnionType extends AbstractDiscriminatedUnionType<Type> {
+    readonly kind = "DiscriminatedUnion";
 }
 //# sourceMappingURL=DiscriminatedUnionType.d.ts.map

package/dist/generators/ts/DiscriminatedUnionType.js

@@ -1,431 +1,5 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
-import { Memoize } from "typescript-memoize";
-import { DiscriminatedUnionType_conversionFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_conversionFunctionExpression.js";
-import { DiscriminatedUnionType_equalsFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_equalsFunctionExpression.js";
-import { DiscriminatedUnionType_filterFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_filterFunctionExpression.js";
-import { DiscriminatedUnionType_filterTypeExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_filterTypeExpression.js";
-import { DiscriminatedUnionType_fromJsonFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_fromJsonFunctionExpression.js";
-import { DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.js";
-import { DiscriminatedUnionType_hashFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_hashFunctionExpression.js";
-import { DiscriminatedUnionType_inferDiscriminant } from "./_DiscriminatedUnionType/DiscriminatedUnionType_inferDiscriminant.js";
-import { DiscriminatedUnionType_inlineExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_inlineExpression.js";
-import { DiscriminatedUnionType_jsonSchemaExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_jsonSchemaExpression.js";
-import { DiscriminatedUnionType_jsonTypeLiteral } from "./_DiscriminatedUnionType/DiscriminatedUnionType_jsonTypeLiteral.js";
-import { DiscriminatedUnionType_schemaTypeExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_schemaTypeExpression.js";
-import { DiscriminatedUnionType_toJsonFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_toJsonFunctionExpression.js";
-import { DiscriminatedUnionType_toRdfResourceValuesFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_toRdfResourceValuesFunctionExpression.js";
-import { DiscriminatedUnionType_toStringFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_toStringFunctionExpression.js";
-import { DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.js";
-import { DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.js";
-import { AbstractType } from "./AbstractType.js";
-import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
-export class DiscriminatedUnionType extends AbstractType {
-    discriminant;
-    graphqlArgs = Maybe.empty();
-    identifierType;
+import { AbstractDiscriminatedUnionType } from "./AbstractDiscriminatedUnionType.js";
+export class DiscriminatedUnionType extends AbstractDiscriminatedUnionType {
     kind = "DiscriminatedUnion";
-    recursive;
-    validationFunction = Maybe.empty();
-    constructor({ identifierType, members, recursive, ...superParameters }) {
-        super(superParameters);
-        this.identifierType = identifierType;
-        invariant(members.length >= 2);
-        this.recursive = recursive;
-        this.discriminant = DiscriminatedUnionType_inferDiscriminant.call(this, members);
-        this.lazyMembers = () => members.map((member, memberI) => {
-            let discriminantValues;
-            switch (this.discriminant.kind) {
-                case "Extrinsic":
-                    discriminantValues = [this.discriminant.memberValues[memberI]];
-                    break;
-                case "Hybrid":
-                    discriminantValues = this.discriminant.memberValues[memberI].values;
-                    break;
-                case "Intrinsic": {
-                    discriminantValues =
-                        member.type.discriminantProperty.unsafeCoerce().values;
-                    break;
-                }
-                case "Typeof":
-                    discriminantValues = [this.discriminant.memberValues[memberI]];
-                    break;
-                default:
-                    throw this.discriminant;
-            }
-            invariant(discriminantValues.length > 0);
-            const typeCheck = (json) => (instance) => {
-                const discriminant = this.discriminant; // To get type narrowing to work
-                if (discriminant.kind === "Typeof") {
-                    return code `(${joinCode(discriminantValues.map((discriminantValue) => code `typeof ${instance} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
-                }
-                // Causes problems in mixed Object | other dicriminated unions
-                // if (discriminant.kind === "Intrinsic" && !json) {
-                //   switch (member.type.kind) {
-                //     case "Object":
-                //     case "ObjectDiscriminatedUnion":
-                //       return code`${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(${instance})`;
-                //   }
-                // }
-                const discriminantName = json
-                    ? discriminant.jsonName
-                    : discriminant.name;
-                return code `(${joinCode(discriminantValues.map((discriminantValue) => code `${instance}["${discriminantName}"] === ${literalOf(discriminantValue)}`), { on: " || " })})`;
-            };
-            return {
-                discriminantValues,
-                jsonType: member.type.jsonType({
-                    includeDiscriminantProperty: this.discriminant.kind === "Intrinsic" ||
-                        (this.discriminant.kind === "Hybrid" &&
-                            this.discriminant.memberValues[memberI].kind === "Intrinsic"),
-                }).expression,
-                jsonTypeCheck: typeCheck(true),
-                primaryDiscriminantValue: discriminantValues[0],
-                type: member.type,
-                typeCheck: typeCheck(false),
-                typeToJsonExpression: (valueVariable) => member.type.toJsonExpression({
-                    includeDiscriminantProperty: this.discriminant.kind === "Intrinsic" ||
-                        (this.discriminant.kind === "Hybrid" &&
-                            this.discriminant.memberValues[memberI].kind === "Intrinsic"),
-                    variables: { value: valueVariable },
-                }),
-                unwrap: (instance) => {
-                    switch (this.discriminant.kind) {
-                        case "Extrinsic":
-                            return code `${instance}.value`;
-                        case "Hybrid":
-                            return this.discriminant.memberValues[memberI].kind ===
-                                "Intrinsic"
-                                ? instance
-                                : code `${instance}.value`;
-                        case "Intrinsic":
-                        case "Typeof":
-                            return instance;
-                    }
-                },
-                wrap: (instance) => {
-                    switch (this.discriminant.kind) {
-                        case "Extrinsic":
-                            return code `{ ${this.discriminant.name}: ${literalOf(discriminantValues[0])} as const, value: ${instance} }`;
-                        case "Hybrid":
-                            return this.discriminant.memberValues[memberI].kind ===
-                                "Intrinsic"
-                                ? instance
-                                : code `{ ${this.discriminant.name}: ${literalOf(discriminantValues[0])} as const, value: ${instance} }`;
-                        case "Intrinsic":
-                        case "Typeof":
-                            return instance;
-                    }
-                },
-            };
-        });
-    }
-    get conversionFunction() {
-        if (this.conversionFunctionExpression.isNothing()) {
-            return this.conversionFunctionExpression;
-        }
-        return this.name
-            .map((name) => Maybe.of({
-            code: code `${name}.convert`,
-            sourceTypes: this.conversionFunctionExpression.extract().sourceTypes,
-        }))
-            .orDefault(this.conversionFunctionExpression);
-    }
-    get discriminantProperty() {
-        switch (this.discriminant.kind) {
-            case "Extrinsic":
-                return Maybe.of({
-                    jsonName: this.discriminant.jsonName,
-                    name: this.discriminant.name,
-                    values: this.discriminant.memberValues,
-                });
-            case "Hybrid":
-                return Maybe.of({
-                    jsonName: this.discriminant.jsonName,
-                    name: "termType",
-                    values: this.discriminant.memberValues.flatMap((_) => _.values),
-                });
-            case "Intrinsic":
-                return Maybe.of({
-                    jsonName: this.discriminant.jsonName,
-                    name: this.discriminant.name,
-                    values: this.discriminant.memberValues,
-                });
-            case "Typeof":
-                return Maybe.empty();
-            default:
-                throw this.discriminant;
-        }
-    }
-    get equalsFunction() {
-        return this.name
-            .map((name) => code `${name}.equals`)
-            .orDefault(DiscriminatedUnionType_equalsFunctionExpression.call(this));
-    }
-    get filterFunction() {
-        return this.name
-            .map((name) => code `${name}.filter`)
-            .orDefault(DiscriminatedUnionType_filterFunctionExpression.call(this));
-    }
-    get filterType() {
-        return this.name
-            .map((name) => code `${name}.Filter`)
-            .orDefault(DiscriminatedUnionType_filterTypeExpression.call(this));
-    }
-    get fromRdfResourceValuesFunction() {
-        return this.name
-            .map((name) => code `${name}.fromRdfResourceValues`)
-            .orDefault(DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.call(this));
-    }
-    get graphqlType() {
-        const name = this.name.extract();
-        if (!name ||
-            !this.members.every((member) => member.type.kind === "Object")) {
-            throw new Error("not implemented");
-        }
-        return new AbstractType.GraphqlType(code `${name}.GraphQL`, this.reusables);
-    }
-    get hashFunction() {
-        return this.name
-            .map((name) => code `${name}.hash`)
-            .orDefault(DiscriminatedUnionType_hashFunctionExpression.call(this));
-    }
-    get jsTypes() {
-        const jsTypes = [];
-        for (const member of this.members) {
-            for (const memberJsType of member.type.jsTypes) {
-                if (!jsTypes.some((jsType) => AbstractType.JsType.equals(jsType, memberJsType))) {
-                    jsTypes.push(memberJsType);
-                }
-            }
-        }
-        return jsTypes;
-    }
-    get jsonSchemaFunctionDeclaration() {
-        let expression = DiscriminatedUnionType_jsonSchemaExpression.call(this);
-        const meta = {
-        // id: this.name,
-        };
-        this.comment.ifJust((description) => {
-            meta["description"] = description;
-        });
-        this.label.ifJust((label) => {
-            meta["title"] = label;
-        });
-        if (Object.keys(meta).length > 0) {
-            expression = code `${expression}.meta(${meta})`;
-        }
-        return code `export const schema = () => ${expression};`;
-    }
-    get jsonTypeAliasDeclaration() {
-        return code `export type Json = ${DiscriminatedUnionType_jsonTypeLiteral.call(this).expression}`;
-    }
-    get members() {
-        return this.lazyMembers();
-    }
-    get mutable() {
-        return this.members.some((member) => member.type.mutable);
-    }
-    get referencesNamedType() {
-        return (this.name.isJust() ||
-            this.members.some((member) => member.type.referencesNamedType));
-    }
-    get schemaType() {
-        return this.name
-            .map(() => code `typeof ${this.schema}`)
-            .orDefault(DiscriminatedUnionType_schemaTypeExpression.call(this));
-    }
-    get toRdfResourceValueTypes() {
-        const set = new Set();
-        for (const member of this.members) {
-            for (const value of member.type.toRdfResourceValueTypes) {
-                set.add(value);
-            }
-        }
-        return set;
-    }
-    get valueSparqlConstructTriplesFunction() {
-        return this.name
-            .map((name) => code `${name}.valueSparqlConstructTriples`)
-            .orDefault(DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.call(this));
-    }
-    get valueSparqlWherePatternsFunction() {
-        return this.name
-            .map((name) => code `${name}.valueSparqlWherePatterns`)
-            .orDefault(DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.call(this));
-    }
-    get inlineExpression() {
-        return DiscriminatedUnionType_inlineExpression.call(this);
-    }
-    get schemaInitializers() {
-        return super.schemaInitializers.concat(code `members: { ${joinCode(this.members.map(({ discriminantValues, type, primaryDiscriminantValue }) => code `${literalOf(primaryDiscriminantValue)}: ${{
-            discriminantValues: discriminantValues,
-            type: type.schema,
-        }}`), { on: "," })} }`);
-    }
-    get conversionFunctionExpression() {
-        return DiscriminatedUnionType_conversionFunctionExpression.call(this);
-    }
-    fromJsonExpression({ variables, }) {
-        return code `${this.name.map((name) => code `${name}.fromJson`).orDefault(DiscriminatedUnionType_fromJsonFunctionExpression.call(this))}(${variables.value})`;
-    }
-    graphqlResolveExpression({ variables, }) {
-        return variables.value;
-    }
-    jsonSchema({ context, }) {
-        const expression = this.name
-            .map((name) => code `${name}.Json.schema()`)
-            .orDefault(DiscriminatedUnionType_jsonSchemaExpression.call(this));
-        if (context === "property" && this.recursive) {
-            return code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.jsonType().expression}> => ${expression})`;
-        }
-        return expression;
-    }
-    jsonType() {
-        return this.name
-            .map((name) => new AbstractType.JsonType(code `${name}.Json`))
-            .orDefault(DiscriminatedUnionType_jsonTypeLiteral.call(this));
-    }
-    jsonUiSchemaElement() {
-        return Maybe.empty();
-    }
-    toJsonExpression({ variables, }) {
-        return code `${this.name.map((name) => code `${name}.toJson`).orDefault(DiscriminatedUnionType_toJsonFunctionExpression.call(this))}(${variables.value})`;
-    }
-    toRdfResourceValuesExpression({ variables, }) {
-        const { value: valueVariable, ...otherVariables } = variables;
-        return code `${this.name.map((name) => code `${name}.toRdfResourceValues`).orDefault(DiscriminatedUnionType_toRdfResourceValuesFunctionExpression.call(this))}(${valueVariable}, ${otherVariables})`;
-    }
-    toStringExpression({ variables, }) {
-        return code `${this.name.map((name) => code `${name}.${this.configuration.syntheticNamePrefix}toString`).orDefault(DiscriminatedUnionType_toStringFunctionExpression.call(this))}(${variables.value})`;
-    }
-    staticModuleDeclarations(name) {
-        const staticModuleDeclarations = {
-            ...super.staticModuleDeclarations(name),
-        };
-        this.conversionFunctionExpression.ifJust((conversionFunction) => {
-            staticModuleDeclarations["convert"] =
-                code `export const convert = ${conversionFunction.code};`;
-        });
-        if (this.configuration.features.has("Object.equals")) {
-            staticModuleDeclarations["equals"] =
-                code `export const equals = ${DiscriminatedUnionType_equalsFunctionExpression.call(this)};`;
-        }
-        if (this.configuration.features.has("Object.filter")) {
-            staticModuleDeclarations["Filter"] =
-                code `export type Filter = ${DiscriminatedUnionType_filterTypeExpression.call(this)};`;
-            staticModuleDeclarations["filter"] =
-                code `export const filter = ${DiscriminatedUnionType_filterFunctionExpression.call(this)};`;
-        }
-        if (this.configuration.features.has("Object.hash")) {
-            staticModuleDeclarations["hash"] =
-                code `export const hash = ${DiscriminatedUnionType_hashFunctionExpression.call(this)};`;
-        }
-        if (this.configuration.features.has("Object.JSON.type")) {
-            staticModuleDeclarations["Json.type"] =
-                code `${this.jsonTypeAliasDeclaration}`;
-        }
-        if (this.configuration.features.has("Object.JSON.schema")) {
-            staticModuleDeclarations["Json.namespace"] = code `\
-export namespace Json {
-  ${this.jsonSchemaFunctionDeclaration}
-
-  export function parse(json: unknown): ${this.reusables.imports.Either}<Error, Json> {
-    const jsonSafeParseResult = schema().safeParse(json);
-    if (!jsonSafeParseResult.success) { return ${this.reusables.imports.Left}(jsonSafeParseResult.error); }
-    return ${this.reusables.imports.Right}(jsonSafeParseResult.data);
-  }
-}`;
-        }
-        if (this.configuration.features.has("Object.fromJson")) {
-            staticModuleDeclarations["fromJson"] =
-                code `export const fromJson = ${DiscriminatedUnionType_fromJsonFunctionExpression.call(this)};`;
-        }
-        if (this.configuration.features.has("Object.fromRdf")) {
-            staticModuleDeclarations["fromRdfResourceValues"] =
-                code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${name}, ${this.schemaType}> = ${DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.call(this)};`;
-        }
-        if (this.configuration.features.has("Object.toJson")) {
-            staticModuleDeclarations["toJson"] =
-                code `export const toJson = ${DiscriminatedUnionType_toJsonFunctionExpression.call(this)};`;
-        }
-        if (this.configuration.features.has("Object.toRdf")) {
-            staticModuleDeclarations["toRdfResourceValues"] =
-                code `export const toRdfResourceValues = ${DiscriminatedUnionType_toRdfResourceValuesFunctionExpression.call(this)};`;
-        }
-        if (this.configuration.features.has("Object.SPARQL")) {
-            staticModuleDeclarations["valueSparqlConstructTriples"] =
-                code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.call(this)};`;
-            staticModuleDeclarations["valueSparqlWherePatterns"] =
-                code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.call(this)};`;
-        }
-        if (this.configuration.features.has("Object.toString")) {
-            const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-            staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
-                code `export const ${syntheticNamePrefix}toString = ${DiscriminatedUnionType_toStringFunctionExpression.call(this)};`;
-        }
-        return staticModuleDeclarations;
-    }
-    lazyMembers;
 }
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "conversionFunction", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "discriminantProperty", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "equalsFunction", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "filterFunction", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "filterType", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "fromRdfResourceValuesFunction", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "graphqlType", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "hashFunction", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "jsTypes", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "members", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "mutable", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "schemaType", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "toRdfResourceValueTypes", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "valueSparqlConstructTriplesFunction", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "valueSparqlWherePatternsFunction", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "inlineExpression", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "conversionFunctionExpression", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "jsonType", null);
 //# sourceMappingURL=DiscriminatedUnionType.js.map

package/dist/generators/ts/ListType.d.ts

@@ -44,7 +44,7 @@ export declare class ListType<ItemTypeT extends ListType.ItemType> extends Abstr
     toStringExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toStringExpression"]>[0]): Code;
 }
 export declare namespace ListType {
-    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | LangStringType | ListType<ListType.ItemType> | LiteralType | ObjectDiscriminatedUnionType | ObjectType | StringType | TermType | DiscriminatedUnionType<Type>;
+    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DiscriminatedUnionType | FloatType | IdentifierType | IntType | IriType | LangStringType | ListType<ListType.ItemType> | LiteralType | ObjectDiscriminatedUnionType | ObjectType | StringType | TermType;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=ListType.d.ts.map

package/dist/generators/ts/ListType.js

@@ -135,6 +135,7 @@ __decorate([
             case "Boolean":
             case "DateTime":
             case "Date":
+            case "DiscriminatedUnion":
             case "Float":
             case "Identifier":
             case "Iri":
@@ -146,7 +147,6 @@ __decorate([
             case "Object":
             case "String":
             case "Term":
-            case "DiscriminatedUnion":
                 return true;
             case "DefaultValue":
             case "LazyOption":

package/dist/generators/ts/ObjectDiscriminatedUnionType.d.ts

@@ -1,12 +1,11 @@
 import { Maybe } from "purify-ts";
-import { DiscriminatedUnionType } from "./DiscriminatedUnionType.js";
+import { AbstractDiscriminatedUnionType } from "./AbstractDiscriminatedUnionType.js";
 import type { ObjectType } from "./ObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare class ObjectDiscriminatedUnionType extends DiscriminatedUnionType<ObjectType> {
+export declare class ObjectDiscriminatedUnionType extends AbstractDiscriminatedUnionType<ObjectType> {
     readonly kind = "ObjectDiscriminatedUnion";
     get identifierTypeAlias(): Code;
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
-    get schemaType(): Code;
     get typeGuardFunction(): Maybe<Code>;
     protected staticModuleDeclarations(name: string): Record<string, Code>;
 }

package/dist/generators/ts/ObjectDiscriminatedUnionType.js

@@ -17,10 +17,10 @@ import { ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration } from "./_Ob
 import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
 import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
 import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
-import { DiscriminatedUnionType } from "./DiscriminatedUnionType.js";
+import { AbstractDiscriminatedUnionType } from "./AbstractDiscriminatedUnionType.js";
 import { singleEntryRecord } from "./singleEntryRecord.js";
 import { code } from "./ts-poet-wrapper.js";
-export class ObjectDiscriminatedUnionType extends DiscriminatedUnionType {
+export class ObjectDiscriminatedUnionType extends AbstractDiscriminatedUnionType {
     kind = "ObjectDiscriminatedUnion";
     get identifierTypeAlias() {
         return this.name.map((name) => code `${name}.Identifier`).unsafeCoerce();
@@ -33,11 +33,6 @@ export class ObjectDiscriminatedUnionType extends DiscriminatedUnionType {
         }))
             .unsafeCoerce();
     }
-    get schemaType() {
-        return this.name
-            .map(() => code `typeof ${this.schema}`)
-            .orDefault(super.schemaType);
-    }
     get typeGuardFunction() {
         if (Object.keys(ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration.call(this)).length === 0) {
             return Maybe.empty();
@@ -80,9 +75,6 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectDiscriminatedUnionType.prototype, "objectSetMethodNames", null);
-__decorate([
-    Memoize()
-], ObjectDiscriminatedUnionType.prototype, "schemaType", null);
 __decorate([
     Memoize()
 ], ObjectDiscriminatedUnionType.prototype, "typeGuardFunction", null);

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

@@ -22,5 +22,5 @@ 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 = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | FloatType | IdentifierType | IntType | IriType | LangStringType | LazyOptionType | LazySetType | LazyType | ListType<ListType.ItemType> | LiteralType | ObjectDiscriminatedUnionType | ObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType | DiscriminatedUnionType<Type>;
+export type Type = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | DiscriminatedUnionType | FloatType | IdentifierType | IntType | IriType | LangStringType | LazyOptionType | LazySetType | LazyType | ListType<ListType.ItemType> | LiteralType | ObjectDiscriminatedUnionType | ObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType;
 //# sourceMappingURL=Type.d.ts.map

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

@@ -24,7 +24,7 @@ export declare class TypeFactory {
     createType(astType: ast.Type, parameters?: {
         defaultValue?: Literal | NamedNode;
     }): Type;
-    createDiscriminatedUnionType(astType: ast.DiscriminatedUnionType): ObjectDiscriminatedUnionType | DiscriminatedUnionType<Type>;
+    createDiscriminatedUnionType(astType: ast.DiscriminatedUnionType): DiscriminatedUnionType | ObjectDiscriminatedUnionType;
     private createBlankNodeType;
     private createDefaultValueType;
     private createIdentifierType;

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_Discriminant.d.ts → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_Discriminant.d.ts}

@@ -1,6 +1,6 @@
 import type { AbstractType } from "../AbstractType.js";
 import type { Typeof } from "../Typeof.js";
-export type DiscriminatedUnionType_Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;
+export type AbstractDiscriminatedUnionType_Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;
 type ExtrinsicDiscriminant = {
     readonly jsonName: string;
     readonly kind: "Extrinsic";
@@ -27,4 +27,4 @@ type TypeofDiscriminant = {
     readonly memberValues: readonly Typeof[];
 };
 export {};
-//# sourceMappingURL=DiscriminatedUnionType_Discriminant.d.ts.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_Discriminant.d.ts.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_Discriminant.js

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

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_conversionFunctionExpression.d.ts

@@ -0,0 +1,6 @@
+import { Maybe } from "purify-ts";
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import { AbstractType } from "../AbstractType.js";
+import type { Type } from "../Type.js";
+export declare function AbstractDiscriminatedUnionType_conversionFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Maybe<AbstractType.ConversionFunction>;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_conversionFunctionExpression.d.ts.map

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_conversionFunctionExpression.js → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_conversionFunctionExpression.js}

@@ -2,7 +2,7 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { AbstractType } from "../AbstractType.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function DiscriminatedUnionType_conversionFunctionExpression() {
+export function AbstractDiscriminatedUnionType_conversionFunctionExpression() {
     if (this.discriminant.kind === "Typeof") {
         // If the members are discriminated by typeof, they can all be used as source types.
         return Maybe.of({
@@ -83,4 +83,4 @@ export function DiscriminatedUnionType_conversionFunctionExpression() {
     }
     return Maybe.empty();
 }
-//# sourceMappingURL=DiscriminatedUnionType_conversionFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_conversionFunctionExpression.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_equalsFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_equalsFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_equalsFunctionExpression.d.ts.map