@shaclmate/compiler 2.0.22 → 2.0.24

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

@@ -1,6 +1,7 @@
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { StructureKind } from "ts-morph";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 export function createFunctionDeclaration() {
     if (!this.features.has("create")) {
         return Maybe.empty();
@@ -11,23 +12,34 @@ export function createFunctionDeclaration() {
     if (this.extern) {
         return Maybe.empty();
     }
-    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersPropertySignature
-        .map((propertySignature) => `readonly ${propertySignature.name}${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
-        .toList());
-    // Should always have at least an identifier
-    invariant(parametersPropertySignatures.length > 0);
-    const parametersType = [`{ ${parametersPropertySignatures.join(", ")} }`]
-        .concat(this.parentObjectTypes.map((parentObjectType) => `Parameters<typeof ${parentObjectType.name}.create>[0]`))
-        .join(" & ");
+    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersPropertySignature.toList());
+    const parametersType = [];
+    if (parametersPropertySignatures.length > 0) {
+        parametersType.push(`{ ${parametersPropertySignatures
+            .map((propertySignature) => `readonly ${propertySignature.name}${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
+            .join(", ")} }`);
+    }
+    for (const parentObjectType of this.parentObjectTypes) {
+        parametersType.push(`Parameters<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}create>[0]`);
+    }
+    if (parametersType.length === 0) {
+        parametersType.push("object");
+    }
     const propertyInitializers = [];
     const omitPropertyNames = [];
     const propertyStatements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        propertyInitializers.push(`...${parentObjectType.name}.create(parameters)`);
+        propertyInitializers.push(`...${parentObjectType.staticModuleName}.${syntheticNamePrefix}create(parameters)`);
     }
+    const parametersHasQuestionToken = this.parentObjectTypes.length === 0 &&
+        parametersPropertySignatures.every((propertySignature) => !!propertySignature.hasQuestionToken);
+    const parametersVariable = `parameters${parametersHasQuestionToken ? "?" : ""}`;
     for (const property of this.properties) {
-        const thisPropertyStatements = property.interfaceConstructorStatements({
-            variables: { parameter: `parameters.${property.name}` },
+        const thisPropertyStatements = property.constructorStatements({
+            variables: {
+                parameter: `${parametersVariable}.${property.name}`,
+                parameters: parametersVariable,
+            },
         });
         if (thisPropertyStatements.length > 0) {
             propertyInitializers.push(property.name);
@@ -42,11 +54,12 @@ export function createFunctionDeclaration() {
     return Maybe.of({
         isExported: true,
         kind: StructureKind.Function,
-        name: "create",
+        name: `${syntheticNamePrefix}create`,
         parameters: [
             {
+                hasQuestionToken: parametersHasQuestionToken,
                 name: "parameters",
-                type: parametersType,
+                type: parametersType.join(" & "),
             },
         ],
         returnType: omitPropertyNames.length === 0

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

@@ -1,4 +1,5 @@
 import { Maybe } from "purify-ts";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 export function equalsFunctionOrMethodDeclaration() {
     if (!this.features.has("equals")) {
         return Maybe.empty();
@@ -23,25 +24,27 @@ export function equalsFunctionOrMethodDeclaration() {
     if (this.parentObjectTypes.length > 0) {
         switch (this.declarationType) {
             case "class": {
-                chain.push("super.equals(other)");
+                chain.push(`super.${syntheticNamePrefix}equals(other)`);
                 hasOverrideKeyword = true;
                 break;
             }
             case "interface": {
                 // For every parent, find the nearest equals implementation
                 for (const parentObjectType of this.parentObjectTypes) {
-                    chain.push(`${parentObjectType.name}.equals(left, right)`);
+                    chain.push(`${parentObjectType.staticModuleName}.${syntheticNamePrefix}equals(left, right)`);
                 }
                 break;
             }
         }
     }
     for (const property of this.ownProperties) {
-        chain.push(`(${property.equalsFunction})(${leftVariable}.${property.name}, ${rightVariable}.${property.name}).mapLeft(propertyValuesUnequal => ({ left: ${leftVariable}, right: ${rightVariable}, propertyName: "${property.name}", propertyValuesUnequal, type: "Property" as const }))`);
+        property.equalsFunction.ifJust((equalsFunction) => {
+            chain.push(`(${equalsFunction})(${leftVariable}.${property.name}, ${rightVariable}.${property.name}).mapLeft(propertyValuesUnequal => ({ left: ${leftVariable}, right: ${rightVariable}, propertyName: "${property.name}", propertyValuesUnequal, type: "Property" as const }))`);
+        });
     }
     return Maybe.of({
         hasOverrideKeyword,
-        name: "equals",
+        name: `${syntheticNamePrefix}equals`,
         parameters: this.declarationType === "interface"
             ? [
                 {
@@ -59,7 +62,7 @@ export function equalsFunctionOrMethodDeclaration() {
                     type: this.name,
                 },
             ],
-        returnType: "EqualsResult",
+        returnType: `${syntheticNamePrefix}EqualsResult`,
         statements: [
             `return ${chain
                 .map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : `chain(() => ${chainPart})`)

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

@@ -1,5 +1,5 @@
 import { Maybe } from "purify-ts";
 import { type VariableStatementStructure } from "ts-morph";
 import type { ObjectType } from "../ObjectType.js";
-export declare function fromRdfTypeVariableDeclaration(this: ObjectType): Maybe<VariableStatementStructure>;
+export declare function fromRdfTypeVariableStatement(this: ObjectType): Maybe<VariableStatementStructure>;
 //# sourceMappingURL=fromRdfTypeVariableStatement.d.ts.map

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

@@ -1,7 +1,9 @@
 import { Maybe } from "purify-ts";
-import { StructureKind } from "ts-morph";
-export function fromRdfTypeVariableDeclaration() {
-    if (!this.features.has("fromRdf")) {
+import { StructureKind, VariableDeclarationKind, } from "ts-morph";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+export function fromRdfTypeVariableStatement() {
+    if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
     if (this.extern) {
@@ -11,11 +13,12 @@ export function fromRdfTypeVariableDeclaration() {
         return Maybe.empty();
     }
     return Maybe.of({
+        declarationKind: VariableDeclarationKind.Const,
         kind: StructureKind.VariableStatement,
         declarations: [
             {
-                name: "fromRdfType",
-                initializer: this.rdfjsTermExpression(this.fromRdfType.unsafeCoerce()),
+                name: `${syntheticNamePrefix}fromRdfType`,
+                initializer: rdfjsTermExpression(this.fromRdfType.unsafeCoerce()),
                 type: "rdfjs.NamedNode<string>",
             },
         ],

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

@@ -0,0 +1,5 @@
+import { type VariableStatementStructure } from "ts-morph";
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+export declare function graphqlTypeVariableStatement(this: ObjectType): Maybe<VariableStatementStructure>;
+//# sourceMappingURL=graphqlTypeVariableStatement.d.ts.map

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

@@ -0,0 +1,49 @@
+import { StructureKind, VariableDeclarationKind, } from "ts-morph";
+import { Maybe } from "purify-ts";
+import { objectInitializer } from "../objectInitializer.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+export function graphqlTypeVariableStatement() {
+    if (!this.features.has("graphql")) {
+        return Maybe.empty();
+    }
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    if (this.synthetic) {
+        return Maybe.empty();
+    }
+    return Maybe.of({
+        declarationKind: VariableDeclarationKind.Const,
+        kind: StructureKind.VariableStatement,
+        declarations: [
+            {
+                name: `${syntheticNamePrefix}GraphQL`,
+                initializer: `new graphql.GraphQLObjectType<${this.name}, { objectSet: ${syntheticNamePrefix}ObjectSet }>(${objectInitializer({
+                    description: this.comment.map(JSON.stringify).extract(),
+                    fields: `() => (${objectInitializer(this.properties.reduce((fields, property) => {
+                        property.graphqlField.ifJust((field) => {
+                            fields[field.name] = objectInitializer({
+                                args: field.args
+                                    .map((args) => objectInitializer(Object.entries(args).reduce((argObjects, [argName, arg]) => {
+                                    argObjects[argName] = objectInitializer(arg);
+                                    return argObjects;
+                                }, {})))
+                                    .extract(),
+                                description: field.description
+                                    .map(JSON.stringify)
+                                    .extract(),
+                                name: JSON.stringify(field.name),
+                                resolve: field.resolve,
+                                type: field.type,
+                            });
+                        });
+                        return fields;
+                    }, {}))})`,
+                    name: `"${this.name}"`,
+                })})`,
+            },
+        ],
+        isExported: true,
+    });
+}
+//# sourceMappingURL=graphqlTypeVariableStatement.js.map

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

@@ -1,5 +1,6 @@
 import { Scope, } from "ts-morph";
 import { ObjectType } from "../ObjectType.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 const hasherVariable = "_hasher";
 export const hasherTypeConstraint = "{ update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; }";
 export function hashFunctionOrMethodDeclarations() {
@@ -35,13 +36,13 @@ export function hashFunctionOrMethodDeclarations() {
     if (this.parentObjectTypes.length > 0) {
         switch (this.declarationType) {
             case "class": {
-                hashShaclPropertiesStatements.push(`super.hashShaclProperties(${hasherVariable});`);
+                hashShaclPropertiesStatements.push(`super.${syntheticNamePrefix}hashShaclProperties(${hasherVariable});`);
                 hasOverrideKeyword = true;
                 break;
             }
             case "interface": {
                 for (const parentObjectType of this.parentObjectTypes) {
-                    hashShaclPropertiesStatements.push(`${parentObjectType.name}.${parentObjectType.hashShaclPropertiesFunctionName}(${this.thisVariable}, ${hasherVariable});`);
+                    hashShaclPropertiesStatements.push(`${parentObjectType.staticModuleName}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
                 }
                 break;
             }
@@ -58,7 +59,7 @@ export function hashFunctionOrMethodDeclarations() {
     return [
         {
             hasOverrideKeyword,
-            name: this.declarationType === "class" ? "hash" : this.hashFunctionName,
+            name: `${syntheticNamePrefix}hash`,
             parameters,
             returnType,
             statements: [
@@ -72,17 +73,15 @@ export function hashFunctionOrMethodDeclarations() {
                     },
                 })),
                 this.declarationType === "class"
-                    ? `this.hashShaclProperties(${hasherVariable});`
-                    : `${this.name}.${this.hashShaclPropertiesFunctionName}(${this.thisVariable}, ${hasherVariable});`,
+                    ? `this.${syntheticNamePrefix}hashShaclProperties(${hasherVariable});`
+                    : `${this.staticModuleName}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`,
                 `return ${hasherVariable};`,
             ],
             typeParameters,
         },
         {
             hasOverrideKeyword,
-            name: this.declarationType === "class"
-                ? "hashShaclProperties"
-                : this.hashShaclPropertiesFunctionName,
+            name: `${syntheticNamePrefix}hashShaclProperties`,
             parameters,
             returnType,
             scope: this.declarationType === "class" ? Scope.Protected : undefined,

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

@@ -0,0 +1,7 @@
+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 {};
+//# sourceMappingURL=identifierTypeDeclarations.d.ts.map

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

@@ -0,0 +1,54 @@
+import { VariableDeclarationKind, } from "ts-morph";
+import { StructureKind, } from "ts-morph";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.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);
+    }
+    // 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`,
+                },
+            ],
+        },
+    ];
+}
+//# sourceMappingURL=identifierTypeDeclarations.js.map

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

@@ -1,20 +1,22 @@
 export * from "./classDeclaration.js";
 export * from "./createFunctionDeclaration.js";
+export * from "./EagerShaclProperty.js";
 export * from "./equalsFunctionDeclaration.js";
-export * from "./fromJsonFunctionDeclarations.js";
-export * from "./fromRdfFunctionDeclarations.js";
 export * from "./fromRdfTypeVariableStatement.js";
+export * from "./graphqlTypeVariableStatement.js";
 export * from "./hashFunctionDeclarations.js";
+export * from "./identifierTypeDeclarations.js";
 export * from "./IdentifierPrefixProperty.js";
 export * from "./IdentifierProperty.js";
 export * from "./interfaceDeclaration.js";
-export * from "./jsonSchemaFunctionDeclaration.js";
-export * from "./jsonUiSchemaFunctionDeclaration.js";
-export * from "./jsonZodSchemaFunctionDeclaration.js";
+export * from "./jsonFunctionDeclarations.js";
+export * from "./jsonTypeAliasDeclaration.js";
+export * from "./LazyShaclProperty.js";
+export * from "./objectSetMethodNames.js";
+export * from "./propertiesVariableStatement.js";
 export * from "./Property.js";
+export * from "./rdfFunctionDeclarations.js";
 export * from "./ShaclProperty.js";
 export * from "./sparqlFunctionDeclarations.js";
-export * from "./toJsonFunctionDeclaration.js";
-export * from "./toRdfFunctionDeclaration.js";
 export * from "./TypeDiscriminatorProperty.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,20 +1,22 @@
 export * from "./classDeclaration.js";
 export * from "./createFunctionDeclaration.js";
+export * from "./EagerShaclProperty.js";
 export * from "./equalsFunctionDeclaration.js";
-export * from "./fromJsonFunctionDeclarations.js";
-export * from "./fromRdfFunctionDeclarations.js";
 export * from "./fromRdfTypeVariableStatement.js";
+export * from "./graphqlTypeVariableStatement.js";
 export * from "./hashFunctionDeclarations.js";
+export * from "./identifierTypeDeclarations.js";
 export * from "./IdentifierPrefixProperty.js";
 export * from "./IdentifierProperty.js";
 export * from "./interfaceDeclaration.js";
-export * from "./jsonSchemaFunctionDeclaration.js";
-export * from "./jsonUiSchemaFunctionDeclaration.js";
-export * from "./jsonZodSchemaFunctionDeclaration.js";
+export * from "./jsonFunctionDeclarations.js";
+export * from "./jsonTypeAliasDeclaration.js";
+export * from "./LazyShaclProperty.js";
+export * from "./objectSetMethodNames.js";
+export * from "./propertiesVariableStatement.js";
 export * from "./Property.js";
+export * from "./rdfFunctionDeclarations.js";
 export * from "./ShaclProperty.js";
 export * from "./sparqlFunctionDeclarations.js";
-export * from "./toJsonFunctionDeclaration.js";
-export * from "./toRdfFunctionDeclaration.js";
 export * from "./TypeDiscriminatorProperty.js";
 //# sourceMappingURL=index.js.map

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

@@ -8,7 +8,7 @@ export function interfaceDeclaration() {
     if (this.extern) {
         return Maybe.empty();
     }
-    const properties = this.properties.flatMap((property) => property.interfacePropertySignature.toList());
+    const properties = this.properties.flatMap((property) => property.propertySignature.toList());
     return Maybe.of({
         extends: this.parentObjectTypes.map((parentObjectType) => parentObjectType.name),
         isExported: true,

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

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

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

@@ -0,0 +1,189 @@
+import { Maybe } from "purify-ts";
+import { StructureKind } from "ts-morph";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { toJsonFunctionOrMethodDeclaration } from "./toJsonFunctionOrMethodDeclaration.js";
+function fromJsonFunctionDeclarations() {
+    const deserializePropertiesReturnType = [];
+    const initializers = [];
+    const propertyReturnTypeSignatures = [];
+    const propertiesFromJsonStatements = [];
+    propertiesFromJsonStatements.push(`const ${syntheticNamePrefix}jsonSafeParseResult = ${syntheticNamePrefix}jsonZodSchema().safeParse(_json);`, `if (!${syntheticNamePrefix}jsonSafeParseResult.success) { return purify.Left(${syntheticNamePrefix}jsonSafeParseResult.error); }`, `const ${variables.jsonObject} = ${syntheticNamePrefix}jsonSafeParseResult.data;`);
+    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
+        propertiesFromJsonStatements.push(`const ${syntheticNamePrefix}super${parentObjectTypeI}Either = ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromJson(${variables.jsonObject});`, `if (${syntheticNamePrefix}super${parentObjectTypeI}Either.isLeft()) { return ${syntheticNamePrefix}super${parentObjectTypeI}Either; }`, `const ${syntheticNamePrefix}super${parentObjectTypeI} = ${syntheticNamePrefix}super${parentObjectTypeI}Either.unsafeCoerce()`);
+        initializers.push(`...${syntheticNamePrefix}super${parentObjectTypeI}`);
+        deserializePropertiesReturnType.push(`${syntheticNamePrefix}UnwrapR<ReturnType<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromJson>>`);
+    });
+    for (const property of this.properties) {
+        const propertyFromJsonStatements = property.fromJsonStatements({
+            variables,
+        });
+        if (propertyFromJsonStatements.length > 0) {
+            propertiesFromJsonStatements.push(...propertyFromJsonStatements);
+            initializers.push(property.name);
+            propertyReturnTypeSignatures.push(`${property.name}: ${property.type.name};`);
+        }
+    }
+    propertiesFromJsonStatements.push(`return purify.Either.of({ ${initializers.join(", ")} })`);
+    if (propertyReturnTypeSignatures.length > 0) {
+        deserializePropertiesReturnType.splice(0, 0, `{ ${propertyReturnTypeSignatures.join(" ")} }`);
+    }
+    const functionDeclarations = [];
+    functionDeclarations.push({
+        isExported: true,
+        kind: StructureKind.Function,
+        name: `${syntheticNamePrefix}propertiesFromJson`,
+        parameters: [
+            {
+                name: "_json",
+                type: "unknown",
+            },
+        ],
+        returnType: `purify.Either<zod.ZodError, ${deserializePropertiesReturnType.join(" & ")}>`,
+        statements: propertiesFromJsonStatements,
+    });
+    let fromJsonStatements;
+    if (this.abstract) {
+        if (this.childObjectTypes.length > 0) {
+            // Similar to an object union type, alt-chain the fromJson of the different concrete subclasses together
+            fromJsonStatements = [
+                `return ${this.childObjectTypes.reduce((expression, childObjectType) => {
+                    const childObjectTypeExpression = `(${childObjectType.staticModuleName}.${syntheticNamePrefix}fromJson(json) as purify.Either<zod.ZodError, ${this.name}>)`;
+                    return expression.length > 0
+                        ? `${expression}.altLazy(() => ${childObjectTypeExpression})`
+                        : childObjectTypeExpression;
+                }, "")};`,
+            ];
+        }
+        else {
+            fromJsonStatements = [];
+        }
+    }
+    else {
+        let propertiesFromJsonExpression = `${syntheticNamePrefix}propertiesFromJson(json)`;
+        if (this.declarationType === "class") {
+            propertiesFromJsonExpression = `${propertiesFromJsonExpression}.map(properties => new ${this.name}(properties))`;
+        }
+        if (this.childObjectTypes.length > 0) {
+            fromJsonStatements = [
+                `return ${this.childObjectTypes.reduce((expression, childObjectType) => {
+                    const childObjectTypeExpression = `(${childObjectType.staticModuleName}.${syntheticNamePrefix}fromJson(json) as purify.Either<zod.ZodError, ${this.name}>)`;
+                    return expression.length > 0
+                        ? `${expression}.altLazy(() => ${childObjectTypeExpression})`
+                        : childObjectTypeExpression;
+                }, "")}.altLazy(() => ${propertiesFromJsonExpression});`,
+            ];
+        }
+        else {
+            fromJsonStatements = [`return ${propertiesFromJsonExpression};`];
+        }
+    }
+    if (fromJsonStatements.length > 0) {
+        functionDeclarations.push({
+            isExported: true,
+            kind: StructureKind.Function,
+            name: `${syntheticNamePrefix}fromJson`,
+            parameters: [
+                {
+                    name: "json",
+                    type: "unknown",
+                },
+            ],
+            returnType: `purify.Either<zod.ZodError, ${this.name}>`,
+            statements: fromJsonStatements,
+        });
+    }
+    return functionDeclarations;
+}
+function jsonSchemaFunctionDeclaration() {
+    return {
+        isExported: true,
+        kind: StructureKind.Function,
+        name: `${syntheticNamePrefix}jsonSchema`,
+        statements: [
+            `return zodToJsonSchema(${syntheticNamePrefix}jsonZodSchema());`,
+        ],
+    };
+}
+function jsonUiSchemaFunctionDeclaration() {
+    const variables = { scopePrefix: "scopePrefix" };
+    const elements = this.parentObjectTypes
+        .map((parentObjectType) => `${parentObjectType.staticModuleName}.${syntheticNamePrefix}jsonUiSchema({ scopePrefix })`)
+        .concat(this.ownProperties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
+    return {
+        isExported: true,
+        kind: StructureKind.Function,
+        name: `${syntheticNamePrefix}jsonUiSchema`,
+        parameters: [
+            {
+                hasQuestionToken: true,
+                name: "parameters",
+                type: "{ scopePrefix?: string }",
+            },
+        ],
+        returnType: "any",
+        statements: [
+            'const scopePrefix = parameters?.scopePrefix ?? "#";',
+            `return { "elements": [ ${elements.join(", ")} ], label: "${this.label.orDefault(this.name)}", type: "Group" }`,
+        ],
+    };
+}
+function jsonZodSchemaFunctionDeclaration() {
+    const variables = { zod: "zod" };
+    const mergeZodObjectSchemas = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        mergeZodObjectSchemas.push(`${parentObjectType.jsonZodSchema({ context: "type", variables })}`);
+    }
+    if (this.properties.length > 0) {
+        mergeZodObjectSchemas.push(`${variables.zod}.object({ ${this.properties
+            .flatMap((property) => property.jsonZodSchema({ variables }).toList())
+            .map(({ key, schema }) => `"${key}": ${schema}`)
+            .join(",")} })`);
+    }
+    return {
+        isExported: true,
+        kind: StructureKind.Function,
+        name: `${syntheticNamePrefix}jsonZodSchema`,
+        statements: [
+            `return ${mergeZodObjectSchemas.length > 0
+                ? mergeZodObjectSchemas.reduce((merged, zodObjectSchema) => {
+                    if (merged.length === 0) {
+                        return zodObjectSchema;
+                    }
+                    return `${merged}.merge(${zodObjectSchema})`;
+                }, "")
+                : `${variables.zod}.object()`} satisfies zod.ZodType<${syntheticNamePrefix}Json>;`,
+        ],
+    };
+}
+function toJsonFunctionDeclaration() {
+    if (this.declarationType !== "interface") {
+        return Maybe.empty();
+    }
+    return toJsonFunctionOrMethodDeclaration
+        .bind(this)()
+        .map((toJsonFunctionOrMethodDeclaration) => ({
+        ...toJsonFunctionOrMethodDeclaration,
+        isExported: true,
+        kind: StructureKind.Function,
+        name: `${syntheticNamePrefix}toJson`,
+    }));
+}
+export function jsonFunctionDeclarations() {
+    if (!this.features.has("json")) {
+        return [];
+    }
+    if (this.extern) {
+        return [];
+    }
+    return [
+        ...fromJsonFunctionDeclarations.bind(this)(),
+        jsonSchemaFunctionDeclaration.bind(this)(),
+        jsonUiSchemaFunctionDeclaration.bind(this)(),
+        ...toJsonFunctionDeclaration.bind(this)().toList(),
+        jsonZodSchemaFunctionDeclaration.bind(this)(),
+    ];
+}
+const variables = {
+    jsonObject: `${syntheticNamePrefix}jsonObject`,
+};
+//# sourceMappingURL=jsonFunctionDeclarations.js.map

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

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import { type TypeAliasDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare function jsonTypeAliasDeclaration(this: ObjectType): Maybe<TypeAliasDeclarationStructure>;
+//# sourceMappingURL=jsonTypeAliasDeclaration.d.ts.map

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

@@ -0,0 +1,28 @@
+import { Maybe } from "purify-ts";
+import { StructureKind } from "ts-morph";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+export function jsonTypeAliasDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    const members = [];
+    if (this.ownProperties.length > 0) {
+        members.push(`{ ${this.ownProperties
+            .flatMap((property) => property.jsonPropertySignature.toList())
+            .map((propertySignature) => `readonly "${propertySignature.name}"${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
+            .join("; ")} }`);
+    }
+    for (const parentObjectType of this.parentObjectTypes) {
+        members.push(parentObjectType.jsonName.toString());
+    }
+    return Maybe.of({
+        isExported: true,
+        kind: StructureKind.TypeAlias,
+        name: `${syntheticNamePrefix}Json`,
+        type: members.length > 0 ? members.join(" & ") : "object",
+    });
+}
+//# sourceMappingURL=jsonTypeAliasDeclaration.js.map

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

@@ -0,0 +1,9 @@
+export declare function objectSetMethodNames(this: {
+    readonly name: string;
+}): {
+    object: string;
+    objectIdentifiers: string;
+    objects: string;
+    objectsCount: string;
+};
+//# sourceMappingURL=objectSetMethodNames.d.ts.map