@postxl/schema 0.0.2

package/LICENSE

@@ -0,0 +1,50 @@
+PostXL Non-Commercial License
+
+Copyright (c) 2025 PostXL GmbH
+
+NON-COMMERCIAL USE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to use,
+copy, modify, and distribute the Software for non-commercial purposes only,
+subject to the following conditions:
+
+1. The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+2. The Software may not be used for commercial purposes without obtaining a
+   commercial license from PostXL GmbH.
+
+DEFINITION OF NON-COMMERCIAL USE
+
+"Non-commercial use" means personal, educational, research, or evaluation use
+where the primary purpose is not to generate revenue or commercial advantage.
+
+Non-commercial use includes:
+
+- Personal projects and learning
+- Academic research and education
+- Open source projects that are not commercially monetized
+- Evaluation and testing of the Software
+
+COMMERCIAL USE
+
+For commercial use of this Software, including but not limited to:
+
+- Use in products or services sold or licensed to third parties
+- Use in internal business operations that generate revenue
+- Use by for-profit organizations in production environments
+
+You must obtain a commercial license from PostXL GmbH.
+
+Contact: licensing@postxl.com
+
+DISCLAIMER
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,320 @@
+# PXL Schema
+
+A utility package that defines the schema for PXL projects & generators - together with the tooling to read/validate the schema.
+
+## Concept
+
+A PXL project is defined by a "ProjectSchema" - typically through a JSON file.
+
+The project schema contains:
+
+- Overall project configuration (e.g. name, description)
+- Definition of database schemas
+- Configuration of generators
+- Definition of models
+- Definition of enums
+
+## Fields
+
+The project schema currently defines the following field types:
+
+- id: the primary key of the model
+- scalar: a scalar value, e.g. string, int, boolean, date
+- discriminated union (see below)
+- relation: a relation to another model
+- enum: an enum value
+
+### Discriminated Union
+
+A discriminated union represents a a state that can be one of multiple values (differentiated by a discriminator value). E.g in case of a blog post, the author can be either a user or an anonymous user.
+Both types might need an email address - but for the user we want to store the userId and for the anonymous user we want to store the name.
+With this field, we can define the above states as follows:
+
+```json
+{
+  "name": "AuthorType",
+  "type": "DiscriminatedUnion",
+  "commonFields": [
+    {
+      "name": "email",
+      "type": "String"
+    }
+  ],
+  "members": [
+    {
+      "type": "User",
+      "label": "existing user",
+      "fields": [
+        {
+          "name": "userId",
+          "type": "User"
+        }
+      ]
+    },
+    {
+      "type": "Anonymous",
+      "label": "Anonymous user",
+      "fields": [
+        {
+          "name": "name",
+          "type": "String"
+        }
+      ]
+    }
+  ]
+}
+```
+
+## API
+
+The package exposes the following:
+
+- `type ProjectSchema`: The overall project configuration. This includes the models, enums, generators, etc.
+- `type ProjectSchemaJSON`: The JSON format of a `ProjectSchema`
+- `zProjectSchema`: Zod decoder that converts `ProjectSchemaJSON` to a `ProjectSchema`
+
+## Under the hood
+
+We use (Zod decoders)[https://zod.dev/] and transformers to convert from JSON to the final type and also perform validations.
+
+For each element (`Field`, `Model`, `Enum`, `ProjectSchema`), we follow the following steps (and naming conventions):
+
+1. Raw JSON decoder
+
+- This decoder only performs type checking and provides descriptions for each property.
+- Naming:
+  - Decoder: `z<ElementName>JSON`
+  - Type: `<ElementName>JSON`
+  - File: `<elementName>.json-schema.ts`
+
+2. Transform individual elements
+
+- This transformation applies default values and branding to strings
+- In case of `FieldJSON`, it also splits it into a discriminated union (Id, Scalar, RelationOrEnum)
+- These transformations only require the decoded element from the previous step and are independent of the other elements.
+  \*Importantly, these transformations do not check any consistency with their parent elements.
+- Naming:
+  - Type: `<ElementName>Enriched`
+  - Transformation: `<elementName>JSONTransformer`
+  - File: `<elementName>.transformer.ts`
+
+3. Transform entire schema:
+
+- Naming:
+  - Decoder: `zProjectSchema` (there is only this one decoder which combines all other decoders)
+  - Type: `<ElementName>`
+  - Transformation: `<elementName>Transformer`, `<elementNames>Transformer`
+  - Files: `project-schema.transformer.ts`
+
+Additionally, for each element, we provide the following files:
+
+- `<elementName>.defaults.ts`: contains the default values for the element. To be used in tests and in the individual transformers
+- `<elementName>.brands.ts`: contains the branded names for the element
+- `<elementName>.test.ts`: contains tests
+
+## Example schema
+
+```json
+{
+  "name": "PostXL Demo project",
+  "slug": "postxl-demo",
+  "description": "A demo project for PostXL",
+  "version": "0.0.1",
+  "generators": {
+    "@PXL/core": {},
+    "@PXL/Types": {},
+    "@PXL/Backend/Data/Prisma": {
+      "prisma": {
+        "datasource": {
+          "name": "db",
+          "provider": "postgres",
+          "url": "env(\"DATABASE_CONNECTION\")"
+        },
+        "generator": {
+          "name": "client",
+          "provider": "prisma-client-js",
+          "previewFeatures": ["multiSchema"]
+        }
+      }
+    }
+  },
+  "systemUser": {
+    "id": "root",
+    "sub": null,
+    "email": "admin@postxl.com",
+    "name": "Root",
+    "profilePictureUrl": "https://postxl.com/images/team/user.png"
+  },
+  "standardModels": ["File", "Action", "Mutation", "Config"],
+  "models": [
+    {
+      "name": "User",
+      "description": "A user of the application.",
+      "schema": "PXL",
+      "standardFields": ["id", "createdAt", "updatedAt", "name"],
+      "fields": [
+        {
+          "name": "sub",
+          "type": "String?",
+          "isUnique": true,
+          "hasIndex": true,
+          "description": "The OpenID Connect provided subject identifier."
+        },
+        {
+          "name": "email",
+          "type": "String",
+          // validation: [
+          //   {
+          //     type: 'email',
+          //     message: 'The email is not valid.',
+          //   },
+          // ],
+          "description": "The email of the user."
+          // generation: 'faker("internet.email")',
+        },
+        {
+          "name": "profilePictureUrl",
+          "type": "String?",
+          "description": "The URL of the profile picture of the user."
+          // generation: 'faker("internet.avatar")',
+        }
+      ],
+      "seed": [
+        {
+          "id": "System",
+          "name": "System",
+          "email": "admin@postxl.com",
+          "profilePictureUrl": "https://postxl.com/images/team/user.png"
+        },
+        {
+          "id": "User 1",
+          "name": "John Doe",
+          "email": "john.doe@company.com",
+          "profilePictureUrl": "https://postxl.com/images/team/user.png"
+        }
+      ]
+    },
+    {
+      "name": "Country",
+      "description": "A lookup table, demonstrating the use of a @@IsDefault. See description of `isDefault` field for details.",
+      "standardFields": ["id", "createdAt", "updatedAt"],
+      "labelField": "name",
+      "fields": [
+        {
+          "name": "countryCode",
+          "type": "String",
+          "description": "The country's ISO 3166-1 alpha-2 code.",
+          "isUnique": true
+          // generation: 'faker("address.countryCode")',
+        },
+        {
+          "name": "name",
+          "type": "String",
+          "description": "The name of the country.",
+          "isUnique": true
+          // generation: 'faker("address.country")',
+        },
+        {
+          "name": "isDefault",
+          "type": "Boolean?",
+          "description": "Tells that the country is the default country."
+        }
+      ],
+      "defaultField": "isDefault",
+      "examples": [
+        {
+          "id": "Global",
+          "countryCode": "GLOBAL",
+          "name": "Global",
+          "isDefault": true
+        },
+        {
+          "id": "US",
+          "countryCode": "US",
+          "name": "United States"
+        },
+        {
+          "id": "DE",
+          "countryCode": "DE",
+          "name": "Germany"
+        }
+      ]
+    },
+    {
+      "name": "Post",
+      "description": "A blog post entry.",
+      // fakerSeed: '12345',
+      "fields": [
+        {
+          "name": "body",
+          "type": "String",
+          "description": "The post that you should see after reading this one."
+          // generation: 'faker("lorem.paragraph")',
+        },
+        {
+          "name": "authorId",
+          "type": "User",
+          "description": "The user that authored the post.",
+          "prismaRelationFieldName": "author"
+        },
+        {
+          "name": "nextPostId",
+          "type": "Post?",
+          "description": "The next post that you should see after reading this one.",
+          "prismaRelationFieldName": "nextPost"
+        },
+        {
+          "name": "publicationId",
+          "type": "Publication?",
+          "description": "Posts are bundled in publications.",
+          "prismaRelationFieldName": "posts"
+          // cloningStrategy: 'withParent',
+        }
+      ],
+      "examples": [
+        {
+          "id": "Post 1",
+          "body": "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed non risus.",
+          "authorId": "User 1",
+          "nextPostId": "Post 2",
+          "publicationId": "Publication 1"
+        },
+        {
+          "id": "Post 2",
+          "body": "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
+          "authorId": "User 1",
+          "publicationId": "Publication 1"
+        }
+      ]
+    },
+    {
+      "name": "Publication",
+      "description": "A collection of posts.",
+      "fields": [
+        {
+          "name": "featuredPostId",
+          "type": "Post?",
+          "description": "The post that is featured in the publication.",
+          "prismaRelationFieldName": "featuredPost"
+        },
+        {
+          "name": "mostLikedPostId",
+          "type": "Post?",
+          "description": "The post that is most liked in the publication.",
+          "prismaRelationFieldName": "mostLikedPost"
+        }
+      ]
+    }
+  ]
+}
+```
+
+## Next steps
+
+- Extend validations:
+  - Validate seed, example and systemUser structure
+  - Verify/extend Prisma relations:
+    Currently, we only store the `databaseName` (e.g. "nextPostId") and `prismaRelationFieldName` (e.g. ("nextPost")). However, for full schema generation, we probably also need the back reference (e.g. "previousPosts").
+- Extend schema:
+  - Add cloning strategy: withParent
+  - Generators config

package/dist/enum/enum.brands.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+declare const zEnumName: z.ZodBranded<z.ZodEffects<z.ZodString, string, string>, "PXL.EnumName">;
+export type EnumName = z.infer<typeof zEnumName>;
+export declare const toEnumName: (input: string) => string & z.BRAND<"PXL.EnumName">;
+declare const zEnumValue: z.ZodBranded<z.ZodString, "PXL.EnumValue">;
+export type EnumValue = z.infer<typeof zEnumValue>;
+export declare const toEnumValue: (input: string) => string & z.BRAND<"PXL.EnumValue">;
+export declare const zDatabaseEnumName: z.ZodBranded<z.ZodString, "PXL.DatabaseEnumName">;
+export type DatabaseEnumName = z.infer<typeof zDatabaseEnumName>;
+export declare const toDatabaseEnumName: (input: string) => string & z.BRAND<"PXL.DatabaseEnumName">;
+export {};

package/dist/enum/enum.brands.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDatabaseEnumName = exports.zDatabaseEnumName = exports.toEnumValue = exports.toEnumName = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("@postxl/utils");
+const zEnumName = zod_1.z
+    .string()
+    .refine((v) => (0, utils_1.isCamelCase)(v) || (0, utils_1.isPascalCase)(v), (v) => ({
+    message: `Enum name must be camelCase (${(0, utils_1.toCamelCase)(v)} or PascalCase ${(0, utils_1.toPascalCase)(v)})! Received ${v}.`,
+}))
+    .brand('PXL.EnumName');
+const toEnumName = (input) => zEnumName.parse(input);
+exports.toEnumName = toEnumName;
+const zEnumValue = zod_1.z.string().brand('PXL.EnumValue');
+const toEnumValue = (input) => zEnumValue.parse(input);
+exports.toEnumValue = toEnumValue;
+exports.zDatabaseEnumName = zod_1.z.string().brand('PXL.DatabaseEnumName');
+const toDatabaseEnumName = (input) => exports.zDatabaseEnumName.parse(input);
+exports.toDatabaseEnumName = toDatabaseEnumName;

package/dist/enum/enum.d.ts

@@ -0,0 +1,49 @@
+export declare const zEnum: import("zod").ZodEffects<import("zod").ZodObject<{
+    name: import("zod").ZodEffects<import("zod").ZodString, string, string>;
+    description: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+    schema: import("zod").ZodOptional<import("zod").ZodString>;
+    databaseName: import("zod").ZodOptional<import("zod").ZodString>;
+    members: import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodObject<{
+        value: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        value: string;
+        description?: string | undefined;
+    }, {
+        value: string;
+        description?: string | undefined;
+    }>, import("zod").ZodString]>, "many">;
+}, "strip", import("zod").ZodTypeAny, {
+    description: string;
+    name: string;
+    members: (string | {
+        value: string;
+        description?: string | undefined;
+    })[];
+    schema?: string | undefined;
+    databaseName?: string | undefined;
+}, {
+    name: string;
+    members: (string | {
+        value: string;
+        description?: string | undefined;
+    })[];
+    description?: string | undefined;
+    schema?: string | undefined;
+    databaseName?: string | undefined;
+}>, {
+    name: string & import("zod").BRAND<"PXL.EnumName">;
+    description: string;
+    members: Map<string & import("zod").BRAND<"PXL.EnumValue">, import("./enum.types").EnumMember>;
+    databaseSchema: (string & import("zod").BRAND<"PXL.DatabaseSchemaName">) | undefined;
+    databaseName: string & import("zod").BRAND<"PXL.DatabaseEnumName">;
+}, {
+    name: string;
+    members: (string | {
+        value: string;
+        description?: string | undefined;
+    })[];
+    description?: string | undefined;
+    schema?: string | undefined;
+    databaseName?: string | undefined;
+}>;

package/dist/enum/enum.defaults.d.ts

@@ -0,0 +1,41 @@
+import * as Branded from './enum.brands';
+import { EnumJSON } from './enum.json-decoder';
+export declare const defaultEnumName_ActionStatus: string & import("zod").BRAND<"PXL.EnumName">;
+export declare const defaultEnumName_MutationStatus: string & import("zod").BRAND<"PXL.EnumName">;
+export declare const defaultEnumName_MutationKind: string & import("zod").BRAND<"PXL.EnumName">;
+export declare const defaultEnumNames: {
+    actionStatus: string & import("zod").BRAND<"PXL.EnumName">;
+    mutationStatus: string & import("zod").BRAND<"PXL.EnumName">;
+    mutationKind: string & import("zod").BRAND<"PXL.EnumName">;
+};
+export declare const defaultEnumJson_ActionStatus: {
+    description: string;
+    name: string;
+    members: (string | {
+        value: string;
+        description?: string | undefined;
+    })[];
+    schema?: string | undefined;
+    databaseName?: string | undefined;
+};
+export declare const defaultEnumJson_MutationStatus: {
+    description: string;
+    name: string;
+    members: (string | {
+        value: string;
+        description?: string | undefined;
+    })[];
+    schema?: string | undefined;
+    databaseName?: string | undefined;
+};
+export declare const defaultEnumJson_MutationKind: {
+    description: string;
+    name: string;
+    members: (string | {
+        value: string;
+        description?: string | undefined;
+    })[];
+    schema?: string | undefined;
+    databaseName?: string | undefined;
+};
+export declare const defaultEnumsJson: Record<Branded.EnumName, EnumJSON>;

package/dist/enum/enum.defaults.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultEnumsJson = exports.defaultEnumJson_MutationKind = exports.defaultEnumJson_MutationStatus = exports.defaultEnumJson_ActionStatus = exports.defaultEnumNames = exports.defaultEnumName_MutationKind = exports.defaultEnumName_MutationStatus = exports.defaultEnumName_ActionStatus = void 0;
+const project_schema_defaults_1 = require("../project-schema/project-schema.defaults");
+const Branded = __importStar(require("./enum.brands"));
+const enum_json_decoder_1 = require("./enum.json-decoder");
+exports.defaultEnumName_ActionStatus = Branded.toEnumName('ActionStatus');
+exports.defaultEnumName_MutationStatus = Branded.toEnumName('MutationStatus');
+exports.defaultEnumName_MutationKind = Branded.toEnumName('MutationKind');
+exports.defaultEnumNames = {
+    actionStatus: exports.defaultEnumName_ActionStatus,
+    mutationStatus: exports.defaultEnumName_MutationStatus,
+    mutationKind: exports.defaultEnumName_MutationKind,
+};
+exports.defaultEnumJson_ActionStatus = enum_json_decoder_1.zEnumJSON.parse({
+    name: exports.defaultEnumName_ActionStatus,
+    description: 'The status of an action.',
+    schema: project_schema_defaults_1.databaseSchemaNameConfig,
+    members: [
+        {
+            value: 'Started',
+            description: 'The action has been started but is not completed yet.',
+        },
+        {
+            value: 'Success',
+            description: 'The action has been completed successfully.',
+        },
+        {
+            value: 'Error',
+            description: 'The action has been completed with an error.',
+        },
+    ],
+});
+exports.defaultEnumJson_MutationStatus = enum_json_decoder_1.zEnumJSON.parse({
+    name: exports.defaultEnumName_MutationStatus,
+    description: 'The status of a mutation.',
+    schema: project_schema_defaults_1.databaseSchemaNameConfig,
+    members: [
+        {
+            value: 'Started',
+            description: 'The mutation has been started but is not completed yet.',
+        },
+        {
+            value: 'Success',
+            description: 'The mutation has been completed successfully.',
+        },
+        {
+            value: 'Error',
+            description: 'The mutation has been completed with an error.',
+        },
+    ],
+});
+exports.defaultEnumJson_MutationKind = enum_json_decoder_1.zEnumJSON.parse({
+    name: exports.defaultEnumName_MutationKind,
+    description: 'The kind/type of a mutation.',
+    schema: project_schema_defaults_1.databaseSchemaNameConfig,
+    members: [
+        { value: 'Create', description: 'Create a new entity.' },
+        { value: 'CreateMany', description: 'Create multiple new entities.' },
+        { value: 'Update', description: 'Update an existing item.' },
+        { value: 'UpdateMany', description: 'Update multiple existing items.' },
+        { value: 'Delete', description: 'Delete an existing item.' },
+        { value: 'DeleteMany', description: 'Delete multiple existing items.' },
+        { value: 'Clone', description: 'Clone an existing item.' },
+        { value: 'CloneMany', description: 'Clone multiple existing items.' },
+    ],
+});
+exports.defaultEnumsJson = {
+    [exports.defaultEnumName_ActionStatus]: exports.defaultEnumJson_ActionStatus,
+    [exports.defaultEnumName_MutationStatus]: exports.defaultEnumJson_MutationStatus,
+    [exports.defaultEnumName_MutationKind]: exports.defaultEnumJson_MutationKind,
+};

package/dist/enum/enum.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zEnum = void 0;
+const enum_json_decoder_1 = require("./enum.json-decoder");
+const enum_transformer_1 = require("./enum.transformer");
+exports.zEnum = enum_json_decoder_1.zEnumJSON.transform(enum_transformer_1.enumTransformer);

package/dist/enum/enum.json-decoder.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+export declare const zEnumMemberNameJSON: z.ZodString;
+export declare const zEnumMemberDescriptionJSON: z.ZodOptional<z.ZodString>;
+export declare const zEnumMemberJSONDetailed: z.ZodObject<{
+    value: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    description?: string | undefined;
+}, {
+    value: string;
+    description?: string | undefined;
+}>;
+export declare const zEnumMemberCompact: z.ZodString;
+export declare const zEnumMemberJSON: z.ZodUnion<[z.ZodObject<{
+    value: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    description?: string | undefined;
+}, {
+    value: string;
+    description?: string | undefined;
+}>, z.ZodString]>;
+export type EnumMemberJSON = z.infer<typeof zEnumMemberJSON>;
+export declare const zEnumNameJSON: z.ZodEffects<z.ZodString, string, string>;
+export declare const zEnumJSON: z.ZodObject<{
+    name: z.ZodEffects<z.ZodString, string, string>;
+    description: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    schema: z.ZodOptional<z.ZodString>;
+    databaseName: z.ZodOptional<z.ZodString>;
+    members: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        value: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        description?: string | undefined;
+    }, {
+        value: string;
+        description?: string | undefined;
+    }>, z.ZodString]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    name: string;
+    members: (string | {
+        value: string;
+        description?: string | undefined;
+    })[];
+    schema?: string | undefined;
+    databaseName?: string | undefined;
+}, {
+    name: string;
+    members: (string | {
+        value: string;
+        description?: string | undefined;
+    })[];
+    description?: string | undefined;
+    schema?: string | undefined;
+    databaseName?: string | undefined;
+}>;
+export type EnumJSON = z.infer<typeof zEnumJSON>;