@shaclmate/compiler 4.0.38 → 4.0.40

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

@@ -8,31 +8,34 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
-import { removeUndefined } from "./removeUndefined.js";
-import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
-export class AbstractUnionType extends AbstractType {
+import { code, def, joinCode, literalOf, } from "./ts-poet-wrapper.js";
+export class UnionType extends AbstractType {
     discriminant;
+    graphqlArgs = Maybe.empty();
     identifierType;
+    kind = "Union";
     recursive;
+    synthetic;
     validationFunction = Maybe.empty();
-    constructor({ identifierType, members, recursive, ...superParameters }) {
+    constructor({ identifierType, members, recursive, synthetic, ...superParameters }) {
         super(superParameters);
         this.identifierType = identifierType;
         invariant(members.length >= 2);
         this.recursive = recursive;
         this.discriminant = Discriminant.infer(members);
+        this.synthetic = synthetic;
         this.lazyMembers = () => members.map((member, memberI) => {
             let discriminantValues;
             invariant(this.discriminant.memberValues.length === members.length);
             switch (this.discriminant.kind) {
-                case "extrinsic":
+                case "Extrinsic":
                     discriminantValues = [this.discriminant.memberValues[memberI]];
                     break;
-                case "hybrid":
+                case "Hybrid":
                     discriminantValues =
                         this.discriminant.memberValues[memberI].ownValues;
                     break;
-                case "intrinsic": {
+                case "Intrinsic": {
                     // A member type's combined discriminant property values are its "own" values plus any descendant values that are
                     // not the "own" values of some other member type.
                     // So if you have type A, type B, and B inherits A, then
@@ -57,7 +60,7 @@ export class AbstractUnionType extends AbstractType {
                         .descendantValues.filter((value) => !memberOwnDiscriminantPropertyValues.has(value)));
                     break;
                 }
-                case "typeof":
+                case "Typeof":
                     discriminantValues = [this.discriminant.memberValues[memberI]];
                     break;
                 default:
@@ -66,15 +69,14 @@ export class AbstractUnionType extends AbstractType {
             invariant(discriminantValues.length > 0);
             const typeCheck = (json) => (instance) => {
                 const discriminant = this.discriminant; // To get type narrowing to work
-                if (discriminant.kind === "typeof") {
+                if (discriminant.kind === "Typeof") {
                     return code `(${joinCode(discriminantValues.map((discriminantValue) => code `typeof ${instance} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
                 }
-                if (discriminant.kind === "intrinsic" && !json) {
+                if (discriminant.kind === "Intrinsic" && !json) {
                     switch (member.type.kind) {
-                        case "NamedObjectUnionType":
-                        case "NamedUnionType":
-                        case "NamedObjectType":
-                            return code `${member.type.name}.is${member.type.name}(${instance})`;
+                        case "Object":
+                        case "ObjectUnion":
+                            return code `${member.type.alias.unsafeCoerce()}.is${member.type.alias.unsafeCoerce()}(${instance})`;
                     }
                 }
                 const discriminantName = json
@@ -85,45 +87,45 @@ export class AbstractUnionType extends AbstractType {
             return {
                 discriminantValues,
                 jsonType: member.type.jsonType({
-                    includeDiscriminantProperty: this.discriminant.kind === "intrinsic" ||
-                        (this.discriminant.kind === "hybrid" &&
-                            this.discriminant.memberValues[memberI].kind === "intrinsic"),
+                    includeDiscriminantProperty: this.discriminant.kind === "Intrinsic" ||
+                        (this.discriminant.kind === "Hybrid" &&
+                            this.discriminant.memberValues[memberI].kind === "Intrinsic"),
                 }).name,
                 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"),
+                    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":
+                        case "Extrinsic":
                             return code `${instance}.value`;
-                        case "hybrid":
+                        case "Hybrid":
                             return this.discriminant.memberValues[memberI].kind ===
-                                "intrinsic"
+                                "Intrinsic"
                                 ? instance
                                 : code `${instance}.value`;
-                        case "intrinsic":
-                        case "typeof":
+                        case "Intrinsic":
+                        case "Typeof":
                             return instance;
                     }
                 },
                 wrap: (instance) => {
                     switch (this.discriminant.kind) {
-                        case "extrinsic":
+                        case "Extrinsic":
                             return code `{ ${this.discriminant.name}: ${literalOf(discriminantValues[0])} as const, value: ${instance} }`;
-                        case "hybrid":
+                        case "Hybrid":
                             return this.discriminant.memberValues[memberI].kind ===
-                                "intrinsic"
+                                "Intrinsic"
                                 ? instance
                                 : code `{ ${this.discriminant.name}: ${literalOf(discriminantValues[0])} as const, value: ${instance} }`;
-                        case "intrinsic":
-                        case "typeof":
+                        case "Intrinsic":
+                        case "Typeof":
                             return instance;
                     }
                 },
@@ -133,64 +135,128 @@ export class AbstractUnionType extends AbstractType {
     get conversionFunction() {
         return Maybe.of({
             code: code `${this.reusables.snippets.identityConversionFunction}`,
-            sourceTypes: this.discriminant.kind === "typeof"
+            sourceTypes: this.discriminant.kind === "Typeof"
                 ? this.members.map(({ primaryDiscriminantValue, type }) => ({
-                    name: type.name,
+                    expression: type.expression,
                     typeof: primaryDiscriminantValue,
                 }))
                 : [
                     {
-                        name: this.name,
+                        expression: this.expression,
                         typeof: "object",
                     },
                 ],
         });
     }
+    get declaration() {
+        const alias = this.alias.extract();
+        if (!alias) {
+            return Maybe.empty();
+        }
+        const declarations = [];
+        if (this.configuration.features.has("Object.type")) {
+            declarations.push(code `export type ${def(alias)} = ${this.inlineExpression};`);
+        }
+        const staticModuleDeclarations = Object.entries(this.staticModuleDeclarations);
+        if (staticModuleDeclarations.length > 0) {
+            declarations.push(code `\
+export namespace ${def(alias)} {
+${joinCode(staticModuleDeclarations
+                .sort((left, right) => left[0].localeCompare(right[0]))
+                .map((_) => _[1]), { on: "\n\n" })}
+}`);
+        }
+        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
+    }
     get discriminantProperty() {
         switch (this.discriminant.kind) {
-            case "extrinsic":
+            case "Extrinsic":
                 return Maybe.of({
                     descendantValues: [],
                     jsonName: this.discriminant.jsonName,
                     ownValues: this.discriminant.memberValues,
                     name: this.discriminant.name,
                 });
-            case "hybrid":
+            case "Hybrid":
                 return Maybe.of({
                     descendantValues: [],
                     jsonName: this.discriminant.jsonName,
                     ownValues: this.discriminant.memberValues.flatMap((_) => _.ownValues),
                     name: "termType",
                 });
-            case "intrinsic":
+            case "Intrinsic":
                 return Maybe.of({
                     descendantValues: this.discriminant.memberValues.flatMap((_) => _.descendantValues),
                     jsonName: this.discriminant.jsonName,
                     name: this.discriminant.name,
                     ownValues: this.discriminant.memberValues.flatMap((_) => _.ownValues),
                 });
-            case "typeof":
+            case "Typeof":
                 return Maybe.empty();
             default:
                 throw this.discriminant;
         }
     }
+    get equalsFunction() {
+        return this.alias
+            .map((alias) => code `${alias}.equals`)
+            .orDefault(this.inlineEqualsFunction);
+    }
+    get filterFunction() {
+        return this.alias
+            .map((alias) => code `${alias}.filter`)
+            .orDefault(this.inlineFilterFunction);
+    }
+    get filterType() {
+        return this.alias
+            .map((alias) => code `${alias}.Filter`)
+            .orDefault(this.inlineFilterType);
+    }
+    get graphqlType() {
+        const alias = this.alias.extract();
+        if (!alias ||
+            !this.members.every((member) => member.type.kind === "Object")) {
+            throw new Error("not implemented");
+        }
+        return new AbstractType.GraphqlType(code `${alias}.GraphQL`, this.reusables);
+    }
+    get hashFunction() {
+        return this.alias
+            .map((alias) => code `${alias}.hash`)
+            .orDefault(this.inlineHashFunction);
+    }
+    get jsonSchemaFunctionDeclaration() {
+        const meta = {
+        // id: this.name,
+        };
+        this.comment.ifJust((description) => {
+            meta["description"] = description;
+        });
+        this.label.ifJust((label) => {
+            meta["title"] = label;
+        });
+        return code `export const schema = () => ${this.inlineJsonSchema}.meta(${meta});`;
+    }
+    get jsonTypeAliasDeclaration() {
+        return code `export type Json = ${this.inlineJsonType.name}`;
+    }
     get members() {
         return this.lazyMembers();
     }
     get mutable() {
         return this.members.some((member) => member.type.mutable);
     }
-    get schema() {
-        return code `${removeUndefined(this.schemaObject)}`;
+    get expression() {
+        return this.alias
+            .map((alias) => code `${alias}`)
+            .orDefault(this.inlineExpression);
+    }
+    get referencesObjectType() {
+        return this.members.some((member) => member.type.referencesObjectType);
     }
     get schemaType() {
-        invariant(this.kind.endsWith("Type"));
         return code `${{
-            // discriminant: {
-            //   kind: '"extrinsic" | "intrinsic" | "typeof"',
-            // },
-            kind: code `${literalOf(this.kind.substring(0, this.kind.length - "Type".length))}`,
+            kind: this.kind,
             members: code `{ ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}: ${{
                 discriminantValues: code `readonly (number | string)[]`,
                 type: type.schemaType,
@@ -209,11 +275,21 @@ export class AbstractUnionType extends AbstractType {
     get typeofs() {
         return [...new Set(this.members.flatMap((member) => member.type.typeofs))];
     }
+    get valueSparqlConstructTriplesFunction() {
+        return this.alias
+            .map((alias) => code `${alias}.valueSparqlConstructTriples`)
+            .orDefault(this.inlineValueSparqlConstructTriplesFunction);
+    }
+    get valueSparqlWherePatternsFunction() {
+        return this.alias
+            .map((alias) => code `${alias}.valueSparqlWherePatterns`)
+            .orDefault(this.inlineValueSparqlWherePatternsFunction);
+    }
     get inlineEqualsFunction() {
         return code `\
-((left: ${this.name}, right: ${this.name}) => {
+((left: ${this.expression}, right: ${this.expression}) => {
 ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `left`)} && ${typeCheck(code `right`)}) {
-  return ${type.equalsFunction}(${unwrap(code `left`)} as ${type.name}, ${unwrap(code `right`)} as ${type.name});
+  return ${type.equalsFunction}(${unwrap(code `left`)} as ${type.expression}, ${unwrap(code `right`)} as ${type.expression});
 }`))}
 
   return ${this.reusables.imports.Left}({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "boolean" as const }, type: "property" as const });
@@ -222,7 +298,7 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
     get inlineFilterFunction() {
         const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
         return code `\
-((filter: ${this.filterType}, value: ${this.name}) => {
+((filter: ${this.filterType}, value: ${this.expression}) => {
 ${joinCode([
             ...this.identifierType
                 .map((identifierType) => code `\
@@ -251,7 +327,7 @@ if (filter.on?.[${literalOf(primaryDiscriminantValue)}] !== undefined && ${typeC
     }
     get inlineFromJsonFunction() {
         return code `\
-((value: ${this.jsonType().name}): ${this.reusables.imports.Either}<Error, ${this.name}> => {
+((value: ${this.jsonType().name}): ${this.reusables.imports.Either}<Error, ${this.expression}> => {
 ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) => code `if (${jsonTypeCheck(code `value`)}) { return ${type.fromJsonExpression({
             variables: {
                 value: code `(${unwrap(code `value`)} as ${jsonType})`,
@@ -288,22 +364,22 @@ ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) =>
                     resourceValues: code `valueAsValues`,
                 },
             });
-            if (this.discriminant.kind === "extrinsic" ||
-                (this.discriminant.kind === "hybrid" &&
-                    this.discriminant.memberValues[memberI].kind === "extrinsic")) {
-                typeExpression = code `${typeExpression}.map(values => values.map(value => ({ ${this.discriminant.name}: ${literalOf(primaryDiscriminantValue)} as const, value }) as (${this.name})))`;
+            if (this.discriminant.kind === "Extrinsic" ||
+                (this.discriminant.kind === "Hybrid" &&
+                    this.discriminant.memberValues[memberI].kind === "Extrinsic")) {
+                typeExpression = code `${typeExpression}.map(values => values.map(value => ({ ${this.discriminant.name}: ${literalOf(primaryDiscriminantValue)} as const, value }) as (${this.expression})))`;
             }
-            typeExpression = code `(${typeExpression} as ${this.reusables.imports.Either}<Error, ${this.reusables.imports.Resource}.Values<${this.name}>>)`;
+            typeExpression = code `(${typeExpression} as ${this.reusables.imports.Either}<Error, ${this.reusables.imports.Resource}.Values<${this.expression}>>)`;
             return expression !== null
                 ? code `${expression}.altLazy(() => ${typeExpression})`
                 : typeExpression;
         }, null)}.chain(values => values.head());
     }))
-) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.name}>)`;
+) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}>)`;
     }
     get inlineHashFunction() {
         return code `\
-(<HasherT extends ${this.reusables.snippets.Hasher}>(hasher: HasherT, value: ${this.name}): HasherT => {
+(<HasherT extends ${this.reusables.snippets.Hasher}>(hasher: HasherT, value: ${this.expression}): HasherT => {
 ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.hashFunction}(hasher, ${unwrap(code `value`)}); }`))}
   return hasher;
 })`;
@@ -311,14 +387,14 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
     get inlineJsonSchema() {
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
-            case "extrinsic":
+            case "Extrinsic":
                 return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `${this.reusables.imports.z}.object({ ${discriminant.name}: ${this.reusables.imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
-            case "hybrid":
+            case "Hybrid":
                 return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
-                        case "extrinsic":
+                        case "Extrinsic":
                             return code `${this.reusables.imports.z}.object({ ${discriminant.name}: ${this.reusables.imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`;
-                        case "intrinsic":
+                        case "Intrinsic":
                             return type.jsonSchema({
                                 includeDiscriminantProperty: true,
                                 context: "type",
@@ -327,12 +403,12 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
                             throw new Error();
                     }
                 }), { on: "," })}]).readonly()`;
-            case "intrinsic":
+            case "Intrinsic":
                 return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type }) => type.jsonSchema({
                     includeDiscriminantProperty: true,
                     context: "type",
                 })), { on: "," })}]).readonly()`;
-            case "typeof":
+            case "Typeof":
                 return code `${this.reusables.imports.z}.union([${joinCode(this.members.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
             default:
                 throw discriminant;
@@ -341,50 +417,50 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
     get inlineJsonType() {
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
-            case "extrinsic":
+            case "Extrinsic":
                 return new AbstractType.JsonType(code `(${joinCode(this.members.map(({ jsonType, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`), { on: "|" })})`);
-            case "hybrid":
+            case "Hybrid":
                 return new AbstractType.JsonType(code `(${joinCode(this.members.map(({ jsonType, primaryDiscriminantValue }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
-                        case "extrinsic":
+                        case "Extrinsic":
                             return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`;
-                        case "intrinsic":
+                        case "Intrinsic":
                             return code `${jsonType}`;
                         default:
                             throw new Error();
                     }
                 }), { on: "|" })})`);
-            case "intrinsic":
-            case "typeof":
+            case "Intrinsic":
+            case "Typeof":
                 return new AbstractType.JsonType(joinCode(this.members.map(({ jsonType }) => code `${jsonType}`), { on: "|" }));
             default:
                 throw discriminant;
         }
     }
-    get inlineName() {
+    get inlineExpression() {
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
-            case "extrinsic":
-                return code `(${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.name} }`), { on: "|" })})`;
-            case "hybrid":
+            case "Extrinsic":
+                return code `(${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.expression} }`), { on: "|" })})`;
+            case "Hybrid":
                 return code `(${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
-                        case "extrinsic":
-                            return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.name} }`;
-                        case "intrinsic":
-                            return code `${type.name}`;
+                        case "Extrinsic":
+                            return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.expression} }`;
+                        case "Intrinsic":
+                            return code `${type.expression}`;
                         default:
                             throw new Error();
                     }
                 }), { on: "|" })})`;
-            case "intrinsic":
-                // If every type shares a discriminant (e.g., RDF/JS "termType" or generated NamedObjectType "type"),
+            case "Intrinsic":
+                // If every type shares a discriminant (e.g., RDF/JS "termType" or generated ObjectType "type"),
                 // just join their names with "|"
-                return code `(${joinCode(this.members.map(({ type }) => code `${type.name}`), { on: "|" })})`;
-            case "typeof":
+                return code `(${joinCode(this.members.map(({ type }) => code `${type.expression}`), { on: "|" })})`;
+            case "Typeof":
                 // The type.name may include literal values, but they should still be unambiguous with other member types since the typeofs
                 // of the different member types are known to be different.
-                return code `(${joinCode(this.members.map(({ type }) => code `${type.name}`), { on: "|" })})`;
+                return code `(${joinCode(this.members.map(({ type }) => code `${type.expression}`), { on: "|" })})`;
             default:
                 discriminant;
                 throw new Error("should never reach this point");
@@ -392,7 +468,7 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
     }
     get inlineToJsonFunction() {
         return code `\
-((value: ${this.name}): ${this.jsonType().name} => {
+((value: ${this.expression}): ${this.jsonType().name} => {
 ${joinCode(this.members.map(({ typeCheck, typeToJsonExpression, unwrap, wrap }) => code `if (${typeCheck(code `value`)}) { return ${wrap(typeToJsonExpression(unwrap(code `value`)))}; }`))}
 
   throw new Error("unable to serialize to JSON");
@@ -424,11 +500,11 @@ ${joinCode(this.members.map(({ type, unwrap, typeCheck }) => code `if (${typeChe
         })}; }`))}
 
   throw new Error("unable to serialize to RDF");
-}) satisfies ${this.reusables.snippets.ToRdfResourceValuesFunction}<${this.name}>)`;
+}) satisfies ${this.reusables.snippets.ToRdfResourceValuesFunction}<${this.expression}>)`;
     }
     get inlineToStringFunction() {
         return code `\
-((value: ${this.name}): string => {
+((value: ${this.expression}): string => {
 ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.toStringExpression({
             variables: { value: unwrap(code `value`) },
         })}; }`))}
@@ -458,69 +534,193 @@ unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...oth
   return [{ patterns: unionPatterns, type: "union" }];
 }) satisfies ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>)`;
     }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            members: code `{ ${joinCode(this.members.map(({ discriminantValues, type, primaryDiscriminantValue }) => code `${literalOf(primaryDiscriminantValue)}: ${{
-                discriminantValues: discriminantValues,
-                type: type.schema,
-            }}`), { on: "," })} }`,
-        };
+    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 staticModuleDeclarations() {
+        const alias = this.alias.unsafeCoerce();
+        const staticModuleDeclarations = {};
+        if (this.configuration.features.has("Object.equals")) {
+            staticModuleDeclarations[`equals`] =
+                code `export const equals = ${this.inlineEqualsFunction};`;
+        }
+        if (this.configuration.features.has("Object.filter")) {
+            staticModuleDeclarations[`Filter`] =
+                code `export type Filter = ${this.inlineFilterType};`;
+            staticModuleDeclarations[`filter`] =
+                code `export const filter = ${this.inlineFilterFunction};`;
+        }
+        if (this.configuration.features.has("Object.hash")) {
+            staticModuleDeclarations[`hash`] =
+                code `export const hash = ${this.inlineHashFunction};`;
+        }
+        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 = ${this.inlineFromJsonFunction};`;
+        }
+        if (this.configuration.features.has("Object.fromRdf")) {
+            staticModuleDeclarations[`fromRdfResourceValues`] =
+                code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${alias}> = ${this.inlineFromRdfResourceValuesFunction};`;
+        }
+        if (this.configuration.features.has("Object.toJson")) {
+            staticModuleDeclarations[`toJson`] =
+                code `export const toJson = ${this.inlineToJsonFunction};`;
+        }
+        if (this.configuration.features.has("Object.toRdf")) {
+            staticModuleDeclarations[`toRdfResourceValues`] =
+                code `export const toRdfResourceValues = ${this.inlineToRdfResourceValuesFunction};`;
+        }
+        if (this.configuration.features.has("Object.SPARQL")) {
+            staticModuleDeclarations[`valueSparqlConstructTriples`] =
+                code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlConstructTriplesFunction};`;
+            staticModuleDeclarations[`valueSparqlWherePatterns`] =
+                code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlWherePatternsFunction};`;
+        }
+        if (this.configuration.features.has("Object.toString")) {
+            const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+            staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
+                code `export const ${syntheticNamePrefix}toString = ${this.inlineToStringFunction};`;
+        }
+        return staticModuleDeclarations;
+    }
+    fromJsonExpression({ variables, }) {
+        return code `${this.alias.map((alias) => code `${alias}.fromJson`).orDefault(this.inlineFromJsonFunction)}(${variables.value})`;
+    }
+    fromRdfResourceValuesExpression({ variables, }) {
+        const { resourceValues: resourceValuesVariable, ...fromRdfResourceValuesOptionsTemp } = variables;
+        const fromRdfResourceValuesOptions = fromRdfResourceValuesOptionsTemp;
+        if (!this.configuration.features.has("ObjectSet")) {
+            delete fromRdfResourceValuesOptions["objectSet"];
+        }
+        return code `${this.alias.map((alias) => code `${alias}.fromRdfResourceValues`).orDefault(this.inlineFromRdfResourceValuesFunction)}(${resourceValuesVariable}, ${fromRdfResourceValuesOptions})`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
+    jsonSchema({ context, }) {
+        const expression = this.alias
+            .map((alias) => code `${alias}.Json.schema()`)
+            .orDefault(this.inlineJsonSchema);
+        if (context === "property" && this.recursive) {
+            return code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.jsonType().name}> => ${expression})`;
+        }
+        return expression;
+    }
+    jsonType() {
+        return this.alias
+            .map((alias) => new AbstractType.JsonType(`${alias}.Json`))
+            .orDefault(this.inlineJsonType);
     }
     jsonUiSchemaElement() {
         return Maybe.empty();
     }
+    toJsonExpression({ variables, }) {
+        return code `${this.alias.map((alias) => code `${alias}.toJson`).orDefault(this.inlineToJsonFunction)}(${variables.value})`;
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        const { value: valueVariable, ...otherVariables } = variables;
+        return code `${this.alias.map((alias) => code `${alias}.toRdfResourceValues`).orDefault(this.inlineToRdfResourceValuesFunction)}(${valueVariable}, ${otherVariables})`;
+    }
+    toStringExpression({ variables, }) {
+        return code `${this.alias.map((alias) => code `${alias}.${this.configuration.syntheticNamePrefix}toString`).orDefault(this.inlineToStringFunction)}(${variables.value})`;
+    }
     lazyMembers;
 }
 __decorate([
     Memoize()
-], AbstractUnionType.prototype, "conversionFunction", null);
+], UnionType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "declaration", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "discriminantProperty", null);
 __decorate([
     Memoize()
-], AbstractUnionType.prototype, "discriminantProperty", null);
+], UnionType.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
-], AbstractUnionType.prototype, "members", null);
+], UnionType.prototype, "filterFunction", null);
 __decorate([
     Memoize()
-], AbstractUnionType.prototype, "mutable", null);
+], UnionType.prototype, "filterType", null);
 __decorate([
     Memoize()
-], AbstractUnionType.prototype, "schema", null);
+], UnionType.prototype, "graphqlType", null);
 __decorate([
     Memoize()
-], AbstractUnionType.prototype, "toRdfResourceValueTypes", null);
+], UnionType.prototype, "hashFunction", null);
 __decorate([
     Memoize()
-], AbstractUnionType.prototype, "typeofs", null);
+], UnionType.prototype, "members", null);
 __decorate([
     Memoize()
-], AbstractUnionType.prototype, "inlineEqualsFunction", null);
+], UnionType.prototype, "mutable", null);
 __decorate([
     Memoize()
-], AbstractUnionType.prototype, "inlineFilterFunction", null);
+], UnionType.prototype, "expression", null);
 __decorate([
     Memoize()
-], AbstractUnionType.prototype, "inlineFilterType", null);
+], UnionType.prototype, "toRdfResourceValueTypes", null);
 __decorate([
     Memoize()
-], AbstractUnionType.prototype, "inlineJsonType", null);
+], UnionType.prototype, "typeofs", null);
 __decorate([
     Memoize()
-], AbstractUnionType.prototype, "inlineName", null);
+], UnionType.prototype, "valueSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], AbstractUnionType.prototype, "inlineValueSparqlConstructTriplesFunction", null);
+], UnionType.prototype, "valueSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
-], AbstractUnionType.prototype, "inlineValueSparqlWherePatternsFunction", null);
+], UnionType.prototype, "inlineEqualsFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "inlineFilterFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "inlineFilterType", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "inlineJsonType", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "inlineExpression", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "inlineValueSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "inlineValueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "jsonType", null);
 function termTypes(type) {
     switch (type.kind) {
-        case "BlankNodeType":
-        case "IriType":
-        case "IdentifierType":
-        case "LiteralType":
-        case "TermType":
+        case "BlankNode":
+        case "Iri":
+        case "Identifier":
+        case "Literal":
+        case "Term":
             return type.termTypes;
         default:
             return emptyTermTypesSet;
@@ -534,7 +734,7 @@ export var Discriminant;
         if (members.some((member) => member.discriminantValue.isJust())) {
             return {
                 jsonName: "type",
-                kind: "extrinsic",
+                kind: "Extrinsic",
                 memberValues: members.map((member, memberI) => member.discriminantValue.orDefault(memberI)),
                 name: "type",
             };
@@ -566,7 +766,7 @@ export var Discriminant;
             if (inlineDiscriminantProperty) {
                 return {
                     jsonName: inlineDiscriminantProperty.jsonName,
-                    kind: "intrinsic",
+                    kind: "Intrinsic",
                     memberValues,
                     name: inlineDiscriminantProperty.name,
                 };
@@ -583,7 +783,7 @@ export var Discriminant;
             if (memberTypeofsSet.size === memberTypes.length) {
                 return {
                     memberValues: memberTypes.flatMap((memberType) => memberType.typeofs),
-                    kind: "typeof",
+                    kind: "Typeof",
                 };
             }
         }
@@ -597,8 +797,8 @@ export var Discriminant;
                     continue;
                 }
                 extrinsicMemberTypeCount++;
-                if (typeof memberType.name === "string") {
-                    extrinsicMemberTypeNamesSet.add(memberType.name);
+                if (memberType.alias.isJust()) {
+                    extrinsicMemberTypeNamesSet.add(memberType.alias.extract());
                 }
                 else {
                     break;
@@ -606,19 +806,19 @@ export var Discriminant;
             }
             return {
                 jsonName: "termType",
-                kind: "hybrid",
+                kind: "Hybrid",
                 memberValues: memberTypes.map((memberType, memberTypeI) => {
                     const memberTermTypes = termTypes(memberType);
                     if (memberTermTypes.size > 0) {
                         return {
-                            kind: "intrinsic",
+                            kind: "Intrinsic",
                             ownValues: [...memberTermTypes],
                         };
                     }
                     return {
-                        kind: "extrinsic",
+                        kind: "Extrinsic",
                         ownValues: extrinsicMemberTypeNamesSet.size === extrinsicMemberTypeCount
-                            ? [memberType.name]
+                            ? [memberType.alias.unsafeCoerce()]
                             : [memberTypeI.toString()],
                     };
                 }),
@@ -629,32 +829,25 @@ export var Discriminant;
         {
             let memberValues;
             {
-                const memberTypeNames = memberTypes.map((memberType) => memberType.name);
-                if (memberTypeNames.every((memberTypeName) => typeof memberTypeName === "string")) {
-                    const memberTypeNamesSet = new Set(memberTypeNames);
-                    if (memberTypeNamesSet.size === memberTypeNames.length) {
-                        memberValues = memberTypeNames;
-                    }
-                    else {
-                        // Otherwise prefix the non-unique strings with an index and use those as the discriminant values.
-                        memberValues = memberTypeNames.map((memberTypeName, memberTypeI) => `${memberTypeI}-${memberTypeName}`);
-                    }
+                const memberTypeNames = memberTypes.map((memberType) => memberType.alias.orDefault(memberType.typeofs[0]));
+                const memberTypeNamesSet = new Set(memberTypeNames);
+                if (memberTypeNamesSet.size === memberTypeNames.length) {
+                    memberValues = memberTypeNames;
                 }
                 else {
-                    // At least one member type name is Code
-                    // Use member type indices as the discriminant values.
-                    memberValues = memberTypes.map((_, memberTypeI) => memberTypeI);
+                    // Otherwise prefix the non-unique strings with an index and use those as the discriminant values.
+                    memberValues = memberTypeNames.map((memberTypeName, memberTypeI) => `${memberTypeI}-${memberTypeName}`);
                 }
             }
             invariant(memberValues.length === memberTypes.length);
             return {
                 jsonName: "type",
-                kind: "extrinsic",
+                kind: "Extrinsic",
                 name: "type",
-                memberValues: memberValues,
+                memberValues,
             };
         }
     }
     Discriminant.infer = infer;
 })(Discriminant || (Discriminant = {}));
-//# sourceMappingURL=AbstractUnionType.js.map
+//# sourceMappingURL=UnionType.js.map