@shaclmate/compiler 4.0.79 → 4.0.81

package/dist/ast/AbstractCompoundType.d.ts

@@ -39,7 +39,7 @@ export declare namespace AbstractCompoundType {
     interface Member<TypeT extends MemberType> {
         readonly type: TypeT;
     }
-    type MemberType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | StructType | TermType | DiscriminatedUnionType;
+    type MemberType = BlankNodeType | DiscriminatedUnionType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | StructType | TermType;
     function isMemberType(type: Type): type is MemberType;
 }
 //# sourceMappingURL=AbstractCompoundType.d.ts.map

package/dist/ast/AbstractCompoundType.js

@@ -58,6 +58,7 @@ __decorate([
     function isMemberType(type) {
         switch (type.kind) {
             case "BlankNode":
+            case "DiscriminatedUnion":
             case "Identifier":
             case "Intersection":
             case "Iri":
@@ -65,7 +66,6 @@ __decorate([
             case "Literal":
             case "Struct":
             case "Term":
-            case "DiscriminatedUnion":
                 return true;
             case "DefaultValue":
             case "LazyOption":

package/dist/ast/AbstractContainerType.d.ts

@@ -38,7 +38,7 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
     };
 }
 export declare namespace AbstractContainerType {
-    type ItemType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | StructType | TermType | DiscriminatedUnionType;
+    type ItemType = BlankNodeType | DiscriminatedUnionType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | StructType | TermType;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=AbstractContainerType.d.ts.map

package/dist/ast/AbstractContainerType.js

@@ -40,6 +40,7 @@ export class AbstractContainerType extends AbstractType {
     function isItemType(type) {
         switch (type.kind) {
             case "BlankNode":
+            case "DiscriminatedUnion":
             case "Identifier":
             case "Intersection":
             case "Iri":
@@ -47,7 +48,6 @@ export class AbstractContainerType extends AbstractType {
             case "Literal":
             case "Struct":
             case "Term":
-            case "DiscriminatedUnion":
                 return true;
             case "DefaultValue":
             case "LazyOption":

package/dist/ast/ListType.d.ts

@@ -38,7 +38,7 @@ export declare class ListType<ItemTypeT extends ListType.ItemType = ListType.Ite
     equals(other: ListType<ItemTypeT>): boolean;
 }
 export declare namespace ListType {
-    type ItemType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | StructType | TermType | DiscriminatedUnionType;
+    type ItemType = BlankNodeType | DiscriminatedUnionType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | StructType | TermType;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=ListType.d.ts.map

package/dist/ast/ListType.js

@@ -33,6 +33,7 @@ export class ListType extends AbstractCollectionType {
     function isItemType(type) {
         switch (type.kind) {
             case "BlankNode":
+            case "DiscriminatedUnion":
             case "Identifier":
             case "Intersection":
             case "Iri":
@@ -40,7 +41,6 @@ export class ListType extends AbstractCollectionType {
             case "Literal":
             case "Struct":
             case "Term":
-            case "DiscriminatedUnion":
                 return true;
             case "DefaultValue":
             case "LazyOption":

package/dist/ast/Type.d.ts

@@ -13,7 +13,7 @@ import type { OptionType } from "./OptionType.js";
 import type { SetType } from "./SetType.js";
 import type { StructType } from "./StructType.js";
 import type { TermType } from "./TermType.js";
-export type Type = BlankNodeType | DefaultValueType | IdentifierType | IntersectionType | IriType | LazyOptionType | LazySetType | LazyType | ListType | LiteralType | StructType | OptionType | SetType | TermType | DiscriminatedUnionType;
+export type Type = BlankNodeType | DefaultValueType | DiscriminatedUnionType | IdentifierType | IntersectionType | IriType | LazyOptionType | LazySetType | LazyType | ListType | LiteralType | StructType | OptionType | SetType | TermType;
 export declare namespace Type {
     function equals(left: Type, right: Type): boolean;
 }

package/dist/ast/Type.js

@@ -9,6 +9,8 @@ export var Type;
                 return left.equals(right);
             case "DefaultValue":
                 return left.equals(right);
+            case "DiscriminatedUnion":
+                return left.equals(right);
             case "Identifier":
                 return left.equals(right);
             case "Intersection":
@@ -31,8 +33,6 @@ export var Type;
                 return left.equals(right);
             case "Term":
                 return left.equals(right);
-            case "DiscriminatedUnion":
-                return left.equals(right);
             case "Set":
                 return left.equals(right);
         }

package/dist/generators/ts/AbstractContainerType.d.ts

@@ -44,7 +44,7 @@ export declare namespace AbstractContainerType {
     type DiscriminantProperty = AbstractType.DiscriminantProperty;
     const GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     type GraphqlType = AbstractType.GraphqlType;
-    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;
     const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractType.JsonType;

package/dist/generators/ts/AbstractContainerType.js

@@ -66,8 +66,9 @@ __decorate([
             case "BigInt":
             case "BlankNode":
             case "Boolean":
-            case "DateTime":
             case "Date":
+            case "DateTime":
+            case "DiscriminatedUnion":
             case "Float":
             case "Identifier":
             case "Int":
@@ -79,7 +80,6 @@ __decorate([
             case "ObjectDiscriminatedUnion":
             case "String":
             case "Term":
-            case "DiscriminatedUnion":
                 return true;
             case "DefaultValue":
             case "LazyOption":

package/dist/generators/ts/AbstractDiscriminatedUnionType.d.ts

@@ -0,0 +1,74 @@
+import { Maybe } from "purify-ts";
+import type { AbstractDiscriminatedUnionType_Discriminant } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_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 type { Type } from "./Type.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare abstract class AbstractDiscriminatedUnionType<MemberTypeT extends Type> extends AbstractType {
+    protected readonly discriminant: AbstractDiscriminatedUnionType.Discriminant;
+    readonly graphqlArgs: AbstractType["graphqlArgs"];
+    readonly identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
+    abstract readonly kind: "ObjectDiscriminatedUnion" | "DiscriminatedUnion";
+    readonly recursive: boolean;
+    readonly validationFunction: Maybe<Code>;
+    constructor({ identifierType, members, recursive, ...superParameters }: {
+        identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
+        members: readonly (Pick<AbstractDiscriminatedUnionType.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 AbstractDiscriminatedUnionType.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 AbstractDiscriminatedUnionType {
+    type Discriminant = AbstractDiscriminatedUnionType_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;
+    }
+}
+//# sourceMappingURL=AbstractDiscriminatedUnionType.d.ts.map

package/dist/generators/ts/AbstractDiscriminatedUnionType.js

@@ -0,0 +1,430 @@
+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 { AbstractDiscriminatedUnionType_conversionFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_conversionFunctionExpression.js";
+import { AbstractDiscriminatedUnionType_equalsFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_equalsFunctionExpression.js";
+import { AbstractDiscriminatedUnionType_filterFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_filterFunctionExpression.js";
+import { AbstractDiscriminatedUnionType_filterTypeExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_filterTypeExpression.js";
+import { AbstractDiscriminatedUnionType_fromJsonFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_fromJsonFunctionExpression.js";
+import { AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.js";
+import { AbstractDiscriminatedUnionType_hashFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_hashFunctionExpression.js";
+import { AbstractDiscriminatedUnionType_inferDiscriminant } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inferDiscriminant.js";
+import { AbstractDiscriminatedUnionType_inlineExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inlineExpression.js";
+import { AbstractDiscriminatedUnionType_jsonSchemaExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_jsonSchemaExpression.js";
+import { AbstractDiscriminatedUnionType_jsonTypeLiteral } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_jsonTypeLiteral.js";
+import { AbstractDiscriminatedUnionType_schemaTypeExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_schemaTypeExpression.js";
+import { AbstractDiscriminatedUnionType_toJsonFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toJsonFunctionExpression.js";
+import { AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression.js";
+import { AbstractDiscriminatedUnionType_toStringFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toStringFunctionExpression.js";
+import { AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.js";
+import { AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.js";
+import { AbstractType } from "./AbstractType.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+export class AbstractDiscriminatedUnionType extends AbstractType {
+    discriminant;
+    graphqlArgs = Maybe.empty();
+    identifierType;
+    recursive;
+    validationFunction = Maybe.empty();
+    constructor({ identifierType, members, recursive, ...superParameters }) {
+        super(superParameters);
+        this.identifierType = identifierType;
+        invariant(members.length >= 2);
+        this.recursive = recursive;
+        this.discriminant = AbstractDiscriminatedUnionType_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(AbstractDiscriminatedUnionType_equalsFunctionExpression.call(this));
+    }
+    get filterFunction() {
+        return this.name
+            .map((name) => code `${name}.filter`)
+            .orDefault(AbstractDiscriminatedUnionType_filterFunctionExpression.call(this));
+    }
+    get filterType() {
+        return this.name
+            .map((name) => code `${name}.Filter`)
+            .orDefault(AbstractDiscriminatedUnionType_filterTypeExpression.call(this));
+    }
+    get fromRdfResourceValuesFunction() {
+        return this.name
+            .map((name) => code `${name}.fromRdfResourceValues`)
+            .orDefault(AbstractDiscriminatedUnionType_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(AbstractDiscriminatedUnionType_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 = AbstractDiscriminatedUnionType_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 = ${AbstractDiscriminatedUnionType_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(AbstractDiscriminatedUnionType_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(AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.call(this));
+    }
+    get valueSparqlWherePatternsFunction() {
+        return this.name
+            .map((name) => code `${name}.valueSparqlWherePatterns`)
+            .orDefault(AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.call(this));
+    }
+    get inlineExpression() {
+        return AbstractDiscriminatedUnionType_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 AbstractDiscriminatedUnionType_conversionFunctionExpression.call(this);
+    }
+    fromJsonExpression({ variables, }) {
+        return code `${this.name.map((name) => code `${name}.fromJson`).orDefault(AbstractDiscriminatedUnionType_fromJsonFunctionExpression.call(this))}(${variables.value})`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
+    jsonSchema({ context, }) {
+        const expression = this.name
+            .map((name) => code `${name}.Json.schema()`)
+            .orDefault(AbstractDiscriminatedUnionType_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(AbstractDiscriminatedUnionType_jsonTypeLiteral.call(this));
+    }
+    jsonUiSchemaElement() {
+        return Maybe.empty();
+    }
+    toJsonExpression({ variables, }) {
+        return code `${this.name.map((name) => code `${name}.toJson`).orDefault(AbstractDiscriminatedUnionType_toJsonFunctionExpression.call(this))}(${variables.value})`;
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        const { value: valueVariable, ...otherVariables } = variables;
+        return code `${this.name.map((name) => code `${name}.toRdfResourceValues`).orDefault(AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression.call(this))}(${valueVariable}, ${otherVariables})`;
+    }
+    toStringExpression({ variables, }) {
+        return code `${this.name.map((name) => code `${name}.${this.configuration.syntheticNamePrefix}toString`).orDefault(AbstractDiscriminatedUnionType_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 = ${AbstractDiscriminatedUnionType_equalsFunctionExpression.call(this)};`;
+        }
+        if (this.configuration.features.has("Object.filter")) {
+            staticModuleDeclarations["Filter"] =
+                code `export type Filter = ${AbstractDiscriminatedUnionType_filterTypeExpression.call(this)};`;
+            staticModuleDeclarations["filter"] =
+                code `export const filter = ${AbstractDiscriminatedUnionType_filterFunctionExpression.call(this)};`;
+        }
+        if (this.configuration.features.has("Object.hash")) {
+            staticModuleDeclarations["hash"] =
+                code `export const hash = ${AbstractDiscriminatedUnionType_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 = ${AbstractDiscriminatedUnionType_fromJsonFunctionExpression.call(this)};`;
+        }
+        if (this.configuration.features.has("Object.fromRdf")) {
+            staticModuleDeclarations["fromRdfResourceValues"] =
+                code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${name}, ${this.schemaType}> = ${AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.call(this)};`;
+        }
+        if (this.configuration.features.has("Object.toJson")) {
+            staticModuleDeclarations["toJson"] =
+                code `export const toJson = ${AbstractDiscriminatedUnionType_toJsonFunctionExpression.call(this)};`;
+        }
+        if (this.configuration.features.has("Object.toRdf")) {
+            staticModuleDeclarations["toRdfResourceValues"] =
+                code `export const toRdfResourceValues = ${AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression.call(this)};`;
+        }
+        if (this.configuration.features.has("Object.SPARQL")) {
+            staticModuleDeclarations["valueSparqlConstructTriples"] =
+                code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.call(this)};`;
+            staticModuleDeclarations["valueSparqlWherePatterns"] =
+                code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.call(this)};`;
+        }
+        if (this.configuration.features.has("Object.toString")) {
+            const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+            staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
+                code `export const ${syntheticNamePrefix}toString = ${AbstractDiscriminatedUnionType_toStringFunctionExpression.call(this)};`;
+        }
+        return staticModuleDeclarations;
+    }
+    lazyMembers;
+}
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "discriminantProperty", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "graphqlType", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "hashFunction", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "jsTypes", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "members", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "mutable", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "toRdfResourceValueTypes", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "valueSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "inlineExpression", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "conversionFunctionExpression", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "jsonType", null);
+//# sourceMappingURL=AbstractDiscriminatedUnionType.js.map