@shaclmate/compiler 3.0.4 → 4.0.0

package/dist/generators/ts/_ObjectType/TypeDiscriminantProperty.js

@@ -0,0 +1,142 @@
+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 { imports } from "../imports.js";
+import { removeUndefined } from "../removeUndefined.js";
+import { snippets } from "../snippets.js";
+import { arrayOf, code, literalOf } from "../ts-poet-wrapper.js";
+import { AbstractProperty } from "./AbstractProperty.js";
+export class TypeDiscriminantProperty extends AbstractProperty {
+    constructorParametersSignature = Maybe.empty();
+    equalsFunction = Maybe.of(code `${snippets.strictEquals}`);
+    filterProperty = Maybe.empty();
+    getAccessorDeclaration = Maybe.empty();
+    graphqlField = Maybe.empty();
+    kind = "TypeDiscriminantProperty";
+    mutable = false;
+    recursive = false;
+    constructor({ type, ...superParameters }) {
+        super({ ...superParameters, type });
+        invariant(this.visibility === "public");
+    }
+    get declaration() {
+        switch (this.objectType.declarationType) {
+            case "class":
+                return Maybe.of(code `${this.abstract ? "abstract " : ""}${this.override ? "override " : ""}readonly ${this.name}: ${this.type.name}${!this.abstract ? code ` = ${this.initializer};` : ";"}`);
+            case "interface":
+                return Maybe.of(code `readonly ${this.name}: ${this.type.name};`);
+            default:
+                this.objectType.declarationType;
+                throw new Error("should never reach this point");
+        }
+    }
+    get jsonSignature() {
+        return Maybe.of(code `readonly ${this.name}: ${this.type.name}`);
+    }
+    get jsonZodSchema() {
+        return Maybe.of({
+            key: this.name,
+            schema: this.type.values.length > 1
+                ? code `${imports.z}.enum(${arrayOf(...this.type.values)})`
+                : code `${imports.z}.literal(${literalOf(this.type.values[0])})`,
+        });
+    }
+    get abstract() {
+        return this.objectType.abstract;
+    }
+    get initializer() {
+        return code `${literalOf(this.objectType.discriminantValue)} as const`;
+    }
+    get override() {
+        return this.objectType.parentObjectTypes.length > 0;
+    }
+    constructorStatements() {
+        switch (this.objectType.declarationType) {
+            case "class":
+                return [];
+            case "interface":
+                if (this.abstract) {
+                    return [];
+                }
+                return [code `const ${this.name} = ${this.initializer};`];
+        }
+    }
+    fromJsonStatements() {
+        return !this.abstract && this.objectType.declarationType === "interface"
+            ? [code `const ${this.name} = ${this.initializer};`]
+            : [];
+    }
+    fromRdfExpression() {
+        return !this.abstract && this.objectType.declarationType === "interface"
+            ? Maybe.of(code `${imports.Right}<${literalOf(this.objectType.discriminantValue)}>(${this.initializer})`)
+            : Maybe.empty();
+    }
+    hashStatements({ variables, }) {
+        return [code `${variables.hasher}.update(${variables.value});`];
+    }
+    jsonUiSchemaElement({ variables, }) {
+        const scope = code `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
+        return Maybe.of(code `{ rule: { condition: { schema: { const: ${this.initializer} }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
+    }
+    sparqlConstructTriplesExpression() {
+        return Maybe.empty();
+    }
+    sparqlWherePatternsExpression() {
+        return Maybe.empty();
+    }
+    toJsonObjectMemberExpression({ variables, }) {
+        return Maybe.of(code `${this.name}: ${variables.value}`);
+    }
+    toRdfStatements() {
+        return [];
+    }
+}
+__decorate([
+    Memoize()
+], TypeDiscriminantProperty.prototype, "jsonSignature", null);
+__decorate([
+    Memoize()
+], TypeDiscriminantProperty.prototype, "jsonZodSchema", null);
+(function (TypeDiscriminantProperty) {
+    class Type {
+        filterFunction = code `nonextant`;
+        mutable;
+        descendantValues;
+        ownValues;
+        constructor({ descendantValues, mutable, ownValues, }) {
+            this.descendantValues = descendantValues;
+            this.mutable = mutable;
+            this.ownValues = ownValues;
+        }
+        get name() {
+            return `${this.values.map((name) => `"${name}"`).join(" | ")}`;
+        }
+        get schema() {
+            return code `${removeUndefined({
+                descendantValues: this.descendantValues.length > 0 ? this.descendantValues : undefined,
+                kind: code `${literalOf("TypeDiscriminant")} as const`,
+                ownValues: this.ownValues.length > 0 ? this.ownValues : undefined,
+            })}`;
+        }
+        get values() {
+            return this.ownValues.concat(this.descendantValues);
+        }
+    }
+    __decorate([
+        Memoize()
+    ], Type.prototype, "name", null);
+    __decorate([
+        Memoize()
+    ], Type.prototype, "schema", null);
+    __decorate([
+        Memoize()
+    ], Type.prototype, "values", null);
+    TypeDiscriminantProperty.Type = Type;
+})(TypeDiscriminantProperty || (TypeDiscriminantProperty = {}));
+//# sourceMappingURL=TypeDiscriminantProperty.js.map

package/dist/generators/ts/_ObjectType/identifierTypeDeclarations.d.ts

@@ -1,7 +1,4 @@
-import { type VariableStatementStructure } from "ts-morph";
-import { type FunctionDeclarationStructure, type ModuleDeclarationStructure, type TypeAliasDeclarationStructure } from "ts-morph";
 import type { ObjectType } from "../ObjectType.js";
-type IdentifierTypeDeclarations = readonly (FunctionDeclarationStructure | ModuleDeclarationStructure | TypeAliasDeclarationStructure | VariableStatementStructure)[];
-export declare function identifierTypeDeclarations(this: ObjectType): IdentifierTypeDeclarations;
-export {};
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function identifierTypeDeclarations(this: ObjectType): readonly Code[];
 //# sourceMappingURL=identifierTypeDeclarations.d.ts.map

package/dist/generators/ts/_ObjectType/identifierTypeDeclarations.js

@@ -1,54 +1,19 @@
-import { VariableDeclarationKind, } from "ts-morph";
-import { StructureKind, } from "ts-morph";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
 export function identifierTypeDeclarations() {
-    if (this.extern) {
-        return [];
-    }
     const ancestorObjectTypeWithSameIdentifierType = this.ancestorObjectTypes.find((ancestorObjectType) => ancestorObjectType.identifierType.name === this.identifierType.name);
     if (ancestorObjectTypeWithSameIdentifierType) {
-        return reExportAncestorIdentifierTypeDeclarations(ancestorObjectTypeWithSameIdentifierType);
+        // This object type's identifier type has the same identifier type as an ancestor object type,
+        // so just reuse the latter.
+        return [
+            code `export type ${syntheticNamePrefix}Identifier = ${ancestorObjectTypeWithSameIdentifierType.identifierTypeAlias};`,
+            code `export const ${syntheticNamePrefix}Identifier = ${ancestorObjectTypeWithSameIdentifierType.identifierTypeAlias};`,
+        ];
     }
     // Bespoke identifier type and associated functions
     return [
-        {
-            isExported: true,
-            kind: StructureKind.TypeAlias,
-            name: `${syntheticNamePrefix}Identifier`,
-            type: this.identifierType.name,
-        },
-        {
-            isExported: true,
-            kind: StructureKind.Module,
-            name: `${syntheticNamePrefix}Identifier`,
-            statements: [
-                this.identifierType.fromStringFunctionDeclaration,
-                this.identifierType.toStringFunctionDeclaration,
-            ],
-        },
-    ];
-}
-function reExportAncestorIdentifierTypeDeclarations(ancestorObjectType) {
-    // This object type's identifier type has the same identifier type as an ancestor object type,
-    // so just reuse the latter.
-    return [
-        {
-            isExported: true,
-            kind: StructureKind.TypeAlias,
-            name: `${syntheticNamePrefix}Identifier`,
-            type: ancestorObjectType.identifierTypeAlias,
-        },
-        {
-            isExported: true,
-            kind: StructureKind.VariableStatement,
-            declarationKind: VariableDeclarationKind.Const,
-            declarations: [
-                {
-                    initializer: ancestorObjectType.identifierTypeAlias,
-                    name: `${syntheticNamePrefix}Identifier`,
-                },
-            ],
-        },
+        code `export type ${syntheticNamePrefix}Identifier = ${this.identifierType.name};`,
+        code `export namespace ${syntheticNamePrefix}Identifier { ${joinCode([this.identifierType.fromStringFunction, this.identifierType.toStringFunction])} }`,
     ];
 }
 //# sourceMappingURL=identifierTypeDeclarations.js.map

package/dist/generators/ts/_ObjectUnionType/MemberType.d.ts

@@ -0,0 +1,34 @@
+import type { AbstractDeclaredType } from "../AbstractDeclaredType.js";
+import type { ObjectType } from "../ObjectType.js";
+export declare class MemberType {
+    private readonly delegate;
+    private readonly universe;
+    constructor({ delegate, universe, }: {
+        delegate: ObjectType;
+        universe: readonly ObjectType[];
+    });
+    get _discriminantProperty(): import("../AbstractType.js").AbstractType.DiscriminantProperty;
+    get abstract(): boolean;
+    get ancestorObjectTypes(): readonly ObjectType[];
+    get declarationType(): import("../../../enums/TsObjectDeclarationType.js").TsObjectDeclarationType;
+    get descendantFromRdfTypeVariables(): readonly import("ts-poet").Code[];
+    get discriminantPropertyValues(): readonly string[];
+    get features(): ReadonlySet<import("../../../enums/TsFeature.js").TsFeature>;
+    get filterFunction(): import("ts-poet").Code;
+    get filterType(): import("ts-poet").Code;
+    get fromRdfType(): import("purify-ts").Maybe<import("@rdfjs/types").NamedNode<string>>;
+    get fromRdfTypeVariable(): import("purify-ts").Maybe<import("ts-poet").Code>;
+    get graphqlType(): import("../AbstractType.js").AbstractType.GraphqlType;
+    get identifierTypeAlias(): import("ts-poet").Code;
+    get mutable(): boolean;
+    get name(): string;
+    get ownProperties(): readonly import("../_ObjectType/Property.js").Property[];
+    get properties(): readonly import("../_ObjectType/Property.js").Property[];
+    get staticModuleName(): string;
+    get toRdfjsResourceType(): import("ts-poet").Code;
+    jsonType(): import("../AbstractType.js").AbstractType.JsonType;
+    jsonZodSchema(parameters: Parameters<AbstractDeclaredType["jsonZodSchema"]>[0]): import("ts-poet").Code;
+    newExpression(parameters: Parameters<ObjectType["newExpression"]>[0]): import("ts-poet").Code;
+    toObjectType(): ObjectType;
+}
+//# sourceMappingURL=MemberType.d.ts.map

package/dist/generators/ts/_ObjectUnionType/MemberType.js

@@ -0,0 +1,105 @@
+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 { Memoize } from "typescript-memoize";
+export class MemberType {
+    delegate;
+    universe;
+    constructor({ delegate, universe, }) {
+        this.delegate = delegate;
+        this.universe = universe;
+    }
+    get _discriminantProperty() {
+        return this.delegate._discriminantProperty;
+    }
+    get abstract() {
+        return this.delegate.abstract;
+    }
+    get ancestorObjectTypes() {
+        return this.delegate.ancestorObjectTypes;
+    }
+    get declarationType() {
+        return this.delegate.declarationType;
+    }
+    get descendantFromRdfTypeVariables() {
+        return this.delegate.descendantFromRdfTypeVariables;
+    }
+    get discriminantPropertyValues() {
+        // 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
+        // A has
+        //   own discriminant property values: ["A"]
+        //   descendant discriminant property values: ["B"]
+        // and B has
+        //  own discriminant property values: ["B"]
+        //  descendant discriminant property values ["B"]
+        // In this case A shouldn't have "B" as a combined discriminant property value since it's "claimed" by B.
+        const memberOwnDiscriminantPropertyValues = new Set();
+        for (const memberType of this.universe) {
+            for (const ownDiscriminantPropertyValue of memberType.discriminantProperty.unsafeCoerce()
+                .ownValues) {
+                memberOwnDiscriminantPropertyValues.add(ownDiscriminantPropertyValue);
+            }
+        }
+        return this.delegate._discriminantProperty.ownValues.concat(this.delegate._discriminantProperty.descendantValues.filter((value) => !memberOwnDiscriminantPropertyValues.has(value)));
+    }
+    get features() {
+        return this.delegate.features;
+    }
+    get filterFunction() {
+        return this.delegate.filterFunction;
+    }
+    get filterType() {
+        return this.delegate.filterType;
+    }
+    get fromRdfType() {
+        return this.delegate.fromRdfType;
+    }
+    get fromRdfTypeVariable() {
+        return this.delegate.fromRdfTypeVariable;
+    }
+    get graphqlType() {
+        return this.delegate.graphqlType;
+    }
+    get identifierTypeAlias() {
+        return this.delegate.identifierTypeAlias;
+    }
+    get mutable() {
+        return this.delegate.mutable;
+    }
+    get name() {
+        return this.delegate.name;
+    }
+    get ownProperties() {
+        return this.delegate.ownProperties;
+    }
+    get properties() {
+        return this.delegate.properties;
+    }
+    get staticModuleName() {
+        return this.delegate.staticModuleName;
+    }
+    get toRdfjsResourceType() {
+        return this.delegate.toRdfjsResourceType;
+    }
+    jsonType() {
+        return this.delegate.jsonType();
+    }
+    jsonZodSchema(parameters) {
+        return this.delegate.jsonZodSchema(parameters);
+    }
+    newExpression(parameters) {
+        return this.delegate.newExpression(parameters);
+    }
+    toObjectType() {
+        return this.delegate;
+    }
+}
+__decorate([
+    Memoize()
+], MemberType.prototype, "discriminantPropertyValues", null);
+//# sourceMappingURL=MemberType.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_equalsFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectUnionType_equalsFunctionDeclaration(this: ObjectUnionType): Maybe<Code>;
+//# sourceMappingURL=ObjectUnionType_equalsFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_equalsFunctionDeclaration.js

@@ -0,0 +1,29 @@
+import { Maybe } from "purify-ts";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectUnionType_equalsFunctionDeclaration() {
+    if (!this.features.has("equals")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}equals(left: ${this.name}, right: ${this.name}): ${snippets.EqualsResult} {
+    return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right.${syntheticNamePrefix}type).chain(() => {
+      ${joinCode(this.concreteMemberTypes
+        .map((memberType) => {
+        let returnExpression;
+        switch (memberType.declarationType) {
+            case "class":
+                returnExpression = code `left.${syntheticNamePrefix}equals(right as unknown as ${memberType.name})`;
+                break;
+            case "interface":
+                returnExpression = code `${memberType.staticModuleName}.${syntheticNamePrefix}equals(left, right as unknown as ${memberType.name})`;
+                break;
+        }
+        return code `if (${memberType.staticModuleName}.is${memberType.name}(left)) { return ${returnExpression}; }`;
+    })
+        .concat(code `return ${snippets.EqualsResult}.Equal;`))}
+      });
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_equalsFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_filterFunctionDeclaration.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectUnionType_filterFunctionDeclaration(this: ObjectUnionType): Code;
+//# sourceMappingURL=ObjectUnionType_filterFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_filterFunctionDeclaration.js

@@ -0,0 +1,19 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectUnionType_filterFunctionDeclaration() {
+    return code `\
+export function ${syntheticNamePrefix}filter(filter: ${this.filterType}, value: ${this.name}): boolean {
+${joinCode([
+        code `\
+if (filter.${syntheticNamePrefix}identifier !== undefined && !${this.identifierType.filterFunction}(filter.${syntheticNamePrefix}identifier, value.${syntheticNamePrefix}identifier)) {
+  return false;
+}`,
+        ...this.memberTypes.map((memberType) => code `\
+if (${memberType.staticModuleName}.is${memberType.name}(value) && filter.on?.${memberType.name} && !${memberType.filterFunction}(filter.on.${memberType.name}, value as ${memberType.name})) {
+  return false;
+}`),
+        code `return true;`,
+    ])}
+}`;
+}
+//# sourceMappingURL=ObjectUnionType_filterFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_filterTypeDeclaration.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectUnionType_filterTypeDeclaration(this: ObjectUnionType): Code;
+//# sourceMappingURL=ObjectUnionType_filterTypeDeclaration.d.ts.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_filterTypeDeclaration.js

@@ -0,0 +1,10 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectUnionType_filterTypeDeclaration() {
+    return code `\
+export interface ${syntheticNamePrefix}Filter {
+  readonly ${syntheticNamePrefix}identifier?: ${this.identifierType.filterType};
+  readonly on?: { ${joinCode(this.memberTypes.map((memberType) => code `readonly ${memberType.name}?: Omit<${memberType.filterType}, "${syntheticNamePrefix}identifier">;`))} }
+}`;
+}
+//# sourceMappingURL=ObjectUnionType_filterTypeDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_graphqlTypeVariableStatement.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectUnionType_graphqlTypeVariableStatement(this: ObjectUnionType): Maybe<Code>;
+//# sourceMappingURL=ObjectUnionType_graphqlTypeVariableStatement.d.ts.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_graphqlTypeVariableStatement.js

@@ -0,0 +1,18 @@
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectUnionType_graphqlTypeVariableStatement() {
+    if (!this.features.has("graphql")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export const ${syntheticNamePrefix}GraphQL = new ${imports.GraphQLUnionType}(${{
+        description: this.comment.map(JSON.stringify).extract(),
+        name: this.name,
+        resolveType: code `(value: ${this.name}) => value.${syntheticNamePrefix}type`,
+        types: code `[${joinCode(this.concreteMemberTypes.map((memberType) => memberType.graphqlType.nullableName), { on: ", " })}]`,
+    }});
+`);
+}
+//# sourceMappingURL=ObjectUnionType_graphqlTypeVariableStatement.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_hashFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectUnionType_hashFunctionDeclaration(this: ObjectUnionType): Maybe<Code>;
+//# sourceMappingURL=ObjectUnionType_hashFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_hashFunctionDeclaration.js

@@ -0,0 +1,28 @@
+import { Maybe } from "purify-ts";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+const hasherVariable = code `_hasher`;
+export function ObjectUnionType_hashFunctionDeclaration() {
+    if (!this.features.has("hash")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}hash<HasherT extends ${snippets.Hasher}>(${this.thisVariable}: ${this.name}, ${hasherVariable}: HasherT): HasherT {
+${joinCode(this.concreteMemberTypes
+        .map((memberType) => {
+        let returnExpression;
+        switch (memberType.declarationType) {
+            case "class":
+                returnExpression = code `${this.thisVariable}.${syntheticNamePrefix}hash(${hasherVariable})`;
+                break;
+            case "interface":
+                returnExpression = code `${memberType.staticModuleName}.${syntheticNamePrefix}hash(${this.thisVariable}, ${hasherVariable})`;
+                break;
+        }
+        return code `if (${memberType.staticModuleName}.is${memberType.name}(${this.thisVariable})) { return ${returnExpression}; }`;
+    })
+        .concat(code `throw new Error("unrecognized type");`))}
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_hashFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_identifierTypeDeclarations.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectUnionType_identifierTypeDeclarations(this: ObjectUnionType): readonly Code[];
+//# sourceMappingURL=ObjectUnionType_identifierTypeDeclarations.d.ts.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_identifierTypeDeclarations.js

@@ -0,0 +1,9 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectUnionType_identifierTypeDeclarations() {
+    return [
+        code `export type ${syntheticNamePrefix}Identifier = ${this.identifierType.name};`,
+        code `export namespace ${syntheticNamePrefix}Identifier { ${joinCode([this.identifierType.fromStringFunction, this.identifierType.toStringFunction])} }`,
+    ];
+}
+//# sourceMappingURL=ObjectUnionType_identifierTypeDeclarations.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_isTypeFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectUnionType_isTypeFunctionDeclaration(this: ObjectUnionType): Maybe<Code>;
+//# sourceMappingURL=ObjectUnionType_isTypeFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_isTypeFunctionDeclaration.js

@@ -0,0 +1,13 @@
+import { Maybe } from "purify-ts";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectUnionType_isTypeFunctionDeclaration() {
+    if (this.name === `${syntheticNamePrefix}Object`) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function is${this.name}(object: ${syntheticNamePrefix}Object): object is ${this.name} {
+  return ${joinCode(this.memberTypes.map((memberType) => code `${memberType.staticModuleName}.is${memberType.name}(object)`), { on: " || " })};
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_isTypeFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_jsonFunctionDeclarations.d.ts

@@ -0,0 +1,4 @@
+import { type Code } from "ts-poet";
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+export declare function jsonFunctionDeclarations(this: ObjectUnionType): readonly Code[];
+//# sourceMappingURL=ObjectUnionType_jsonFunctionDeclarations.d.ts.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_jsonFunctionDeclarations.js

@@ -0,0 +1,50 @@
+import { code, joinCode } from "ts-poet";
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+function ObjectUnionType_fromJsonFunctionDeclaration() {
+    return code `\
+export function ${syntheticNamePrefix}fromJson(json: unknown): ${imports.Either}<${imports.z}.ZodError, ${this.name}> {
+  return ${this.concreteMemberTypes.reduce((expression, memberType) => {
+        const memberTypeExpression = code `(${memberType.staticModuleName}.${syntheticNamePrefix}fromJson(json) as ${imports.Either}<${imports.z}.ZodError, ${this.name}>)`;
+        return expression !== null
+            ? code `${expression}.altLazy(() => ${memberTypeExpression})`
+            : memberTypeExpression;
+    }, null)};
+}`;
+}
+export function jsonFunctionDeclarations() {
+    if (!this.features.has("json")) {
+        return [];
+    }
+    return [
+        ObjectUnionType_fromJsonFunctionDeclaration.bind(this)(),
+        jsonZodSchemaFunctionDeclaration.bind(this)(),
+        toJsonFunctionDeclaration.bind(this)(),
+    ];
+}
+function jsonZodSchemaFunctionDeclaration() {
+    return code `\
+export function ${syntheticNamePrefix}jsonZodSchema() {
+  return ${imports.z}.discriminatedUnion("${this._discriminantProperty.name}", [${joinCode(this.concreteMemberTypes.map((memberType) => memberType.jsonZodSchema({ context: "type" })), { on: ", " })}]);
+}`;
+}
+function toJsonFunctionDeclaration() {
+    return code `\
+export function ${syntheticNamePrefix}toJson(${this.thisVariable}: ${this.name}): ${this.jsonType().name} {
+${joinCode(this.concreteMemberTypes
+        .map((memberType) => {
+        let returnExpression;
+        switch (memberType.declarationType) {
+            case "class":
+                returnExpression = code `${this.thisVariable}.${syntheticNamePrefix}toJson()`;
+                break;
+            case "interface":
+                returnExpression = code `${memberType.staticModuleName}.${syntheticNamePrefix}toJson(${this.thisVariable})`;
+                break;
+        }
+        return code `if (${memberType.staticModuleName}.is${memberType.name}(${this.thisVariable})) { return ${returnExpression}; }`;
+    })
+        .concat(code `throw new Error("unrecognized type");`))}
+}`;
+}
+//# sourceMappingURL=ObjectUnionType_jsonFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_jsonTypeAliasDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectUnionType_jsonTypeAliasDeclaration(this: ObjectUnionType): Maybe<Code>;
+//# sourceMappingURL=ObjectUnionType_jsonTypeAliasDeclaration.d.ts.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_jsonTypeAliasDeclaration.js

@@ -0,0 +1,10 @@
+import { Maybe } from "purify-ts";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectUnionType_jsonTypeAliasDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `export type ${syntheticNamePrefix}Json = ${joinCode(this.concreteMemberTypes.map((memberType) => code `${memberType.jsonType().name}`), { on: " | " })};`);
+}
+//# sourceMappingURL=ObjectUnionType_jsonTypeAliasDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_rdfFunctionDeclarations.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function rdfFunctionDeclarations(this: ObjectUnionType): readonly Code[];
+//# sourceMappingURL=ObjectUnionType_rdfFunctionDeclarations.d.ts.map