@postxl/schema 1.1.0 → 1.2.0

package/dist/field/id.d.ts

@@ -44,73 +44,33 @@ export type IdGenerationType =
  */
 export declare const zFieldIdJSON: z.ZodObject<{
     name: z.ZodLiteral<"id">;
-    type: z.ZodUnion<[z.ZodLiteral<"String">, z.ZodLiteral<"Int">]>;
+    type: z.ZodUnion<readonly [z.ZodLiteral<"String">, z.ZodLiteral<"Int">]>;
     databaseName: z.ZodOptional<z.ZodString>;
-    excelName: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    excelName: z.ZodOptional<z.ZodString>;
     label: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     isReadonly: z.ZodOptional<z.ZodBoolean>;
     faker: z.ZodOptional<z.ZodString>;
-    seed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, "many">]>>;
-}, "strip", z.ZodTypeAny, {
-    type: "String" | "Int";
-    name: "id";
-    description?: string | undefined;
-    databaseName?: string | undefined;
-    excelName?: string | undefined;
-    label?: string | undefined;
-    isReadonly?: boolean | undefined;
-    faker?: string | undefined;
-    seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
-}, {
-    type: "String" | "Int";
-    name: "id";
-    description?: string | undefined;
-    databaseName?: string | undefined;
-    excelName?: string | undefined;
-    label?: string | undefined;
-    isReadonly?: boolean | undefined;
-    faker?: string | undefined;
-    seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
-}>;
+    seed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>>]>>;
+}, z.core.$strip>;
 export type FieldIdJSON = z.infer<typeof zFieldIdJSON>;
-export declare const zFieldId: z.ZodEffects<z.ZodObject<{
+export declare const zFieldId: z.ZodPipe<z.ZodObject<{
     name: z.ZodLiteral<"id">;
-    type: z.ZodUnion<[z.ZodLiteral<"String">, z.ZodLiteral<"Int">]>;
+    type: z.ZodUnion<readonly [z.ZodLiteral<"String">, z.ZodLiteral<"Int">]>;
     databaseName: z.ZodOptional<z.ZodString>;
-    excelName: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    excelName: z.ZodOptional<z.ZodString>;
     label: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     isReadonly: z.ZodOptional<z.ZodBoolean>;
     faker: z.ZodOptional<z.ZodString>;
-    seed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, "many">]>>;
-}, "strip", z.ZodTypeAny, {
-    type: "String" | "Int";
-    name: "id";
-    description?: string | undefined;
-    databaseName?: string | undefined;
-    excelName?: string | undefined;
-    label?: string | undefined;
-    isReadonly?: boolean | undefined;
-    faker?: string | undefined;
-    seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
-}, {
-    type: "String" | "Int";
-    name: "id";
-    description?: string | undefined;
-    databaseName?: string | undefined;
-    excelName?: string | undefined;
-    label?: string | undefined;
-    isReadonly?: boolean | undefined;
-    faker?: string | undefined;
-    seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
-}>, {
+    seed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>>]>>;
+}, z.core.$strip>, z.ZodTransform<{
     kind: "id";
-    name: "id" & z.BRAND<"PXL.FieldName"> & z.BRAND<"PXL.FieldName.Id">;
-    unbrandedTypeName: ((("string" | "number") & z.BRAND<"PXL.ScalarIdType">) & z.BRAND<"PXL.ScalarType">) & z.BRAND<"PXL.Type">;
-    databaseType: ("BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes") & z.BRAND<"PXL.DatabaseFieldType">;
-    databaseName: string & z.BRAND<"PXL.DatabaseFieldName">;
-    excelName: string & z.BRAND<"PXL.ExcelColumnName">;
+    name: "id" & z.core.$brand<"PXL.FieldName"> & z.core.$brand<"PXL.FieldName.Id">;
+    unbrandedTypeName: ("string" & z.core.$brand<"PXL.ScalarIdType"> & z.core.$brand<"PXL.ScalarType"> & z.core.$brand<"PXL.Type">) | ("number" & z.core.$brand<"PXL.ScalarIdType"> & z.core.$brand<"PXL.ScalarType"> & z.core.$brand<"PXL.Type">);
+    databaseType: ("BigInt" & z.core.$brand<"PXL.DatabaseFieldType">) | ("String" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Boolean" & z.core.$brand<"PXL.DatabaseFieldType">) | ("DateTime" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Decimal" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Float" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Int" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Json" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Bytes" & z.core.$brand<"PXL.DatabaseFieldType">);
+    databaseName: string & z.core.$brand<"PXL.DatabaseFieldName">;
+    excelName: string & z.core.$brand<"PXL.ExcelColumnName">;
     description: string;
     label: string;
     hasIndex: true;
@@ -121,23 +81,23 @@ export declare const zFieldId: z.ZodEffects<z.ZodObject<{
     isUpdatedAt: false;
     seed: FieldSeedConfig;
 }, {
-    type: "String" | "Int";
     name: "id";
-    description?: string | undefined;
+    type: "String" | "Int";
     databaseName?: string | undefined;
     excelName?: string | undefined;
     label?: string | undefined;
+    description?: string | undefined;
     isReadonly?: boolean | undefined;
     faker?: string | undefined;
     seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
-}>;
+}>>;
 export declare function fieldIdJSONTransformer(fieldInput: FieldIdJSON, ctx: z.RefinementCtx): {
     kind: "id";
-    name: "id" & z.BRAND<"PXL.FieldName"> & z.BRAND<"PXL.FieldName.Id">;
-    unbrandedTypeName: ((("string" | "number") & z.BRAND<"PXL.ScalarIdType">) & z.BRAND<"PXL.ScalarType">) & z.BRAND<"PXL.Type">;
-    databaseType: ("BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes") & z.BRAND<"PXL.DatabaseFieldType">;
-    databaseName: string & z.BRAND<"PXL.DatabaseFieldName">;
-    excelName: string & z.BRAND<"PXL.ExcelColumnName">;
+    name: "id" & z.core.$brand<"PXL.FieldName"> & z.core.$brand<"PXL.FieldName.Id">;
+    unbrandedTypeName: ("string" & z.core.$brand<"PXL.ScalarIdType"> & z.core.$brand<"PXL.ScalarType"> & z.core.$brand<"PXL.Type">) | ("number" & z.core.$brand<"PXL.ScalarIdType"> & z.core.$brand<"PXL.ScalarType"> & z.core.$brand<"PXL.Type">);
+    databaseType: ("BigInt" & z.core.$brand<"PXL.DatabaseFieldType">) | ("String" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Boolean" & z.core.$brand<"PXL.DatabaseFieldType">) | ("DateTime" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Decimal" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Float" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Int" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Json" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Bytes" & z.core.$brand<"PXL.DatabaseFieldType">);
+    databaseName: string & z.core.$brand<"PXL.DatabaseFieldName">;
+    excelName: string & z.core.$brand<"PXL.ExcelColumnName">;
     description: string;
     label: string;
     hasIndex: true;

package/dist/field/relation.d.ts

@@ -33,49 +33,27 @@ export type FieldRelation = FieldCommon<FieldKindRelation> & {
 export declare const createRelationJSONDecoder: ({ modelNames }: {
     modelNames: ModelName[];
 }) => z.ZodObject<{
-    name: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-    type: z.ZodEffects<z.ZodString, string, string>;
+    name: z.ZodString;
+    type: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     databaseName: z.ZodOptional<z.ZodString>;
-    excelName: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    excelName: z.ZodOptional<z.ZodString>;
     prismaRelationFieldName: z.ZodOptional<z.ZodString>;
     deepClone: z.ZodOptional<z.ZodBoolean>;
     label: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     isReadonly: z.ZodOptional<z.ZodBoolean>;
     isUnique: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    type: string;
-    name: string;
-    description?: string | undefined;
-    databaseName?: string | undefined;
-    excelName?: string | undefined;
-    label?: string | undefined;
-    isReadonly?: boolean | undefined;
-    isUnique?: boolean | undefined;
-    prismaRelationFieldName?: string | undefined;
-    deepClone?: boolean | undefined;
-}, {
-    type: string;
-    name: string;
-    description?: string | undefined;
-    databaseName?: string | undefined;
-    excelName?: string | undefined;
-    label?: string | undefined;
-    isReadonly?: boolean | undefined;
-    isUnique?: boolean | undefined;
-    prismaRelationFieldName?: string | undefined;
-    deepClone?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export type FieldRelationJSON = z.infer<ReturnType<typeof createRelationJSONDecoder>>;
 export declare function fieldRelationJSONTransformer(fieldInput: FieldRelationJSON): {
     kind: "relation";
-    type: string & z.BRAND<"PXL.IdType"> & z.BRAND<"PXL.Type">;
-    name: string & z.BRAND<"PXL.FieldName">;
-    referencedModelName: string & z.BRAND<"PXL.ModelName">;
+    type: string & z.core.$brand<"PXL.IdType"> & z.core.$brand<"PXL.Type">;
+    name: string & z.core.$brand<"PXL.FieldName">;
+    referencedModelName: string & z.core.$brand<"PXL.ModelName">;
     label: string;
-    databaseName: string & z.BRAND<"PXL.DatabaseFieldName">;
-    prismaRelationFieldName: (string & z.BRAND<"PXL.DatabaseFieldName">) | undefined;
-    excelName: string & z.BRAND<"PXL.ExcelColumnName">;
+    databaseName: string & z.core.$brand<"PXL.DatabaseFieldName">;
+    prismaRelationFieldName: (string & z.core.$brand<"PXL.DatabaseFieldName">) | undefined;
+    excelName: string & z.core.$brand<"PXL.ExcelColumnName">;
     deepClone: boolean;
     description: string | undefined;
     isReadonly: boolean;

package/dist/field/relation.js

@@ -44,7 +44,9 @@ const utils_2 = require("./shared/utils");
 exports.fieldKindRelation = 'relation';
 const createRelationJSONDecoder = ({ modelNames }) => {
     return zod_1.z.object({
-        name: Decoders.zFieldPropertyName.refine((name) => name.endsWith('Id'), (name) => ({ message: `Relation field name must end with 'Id' - received ${name}` })),
+        name: Decoders.zFieldPropertyName.refine((name) => name.endsWith('Id'), {
+            error: (issue) => `Relation field name must end with 'Id' - received ${issue.input}`,
+        }),
         type: zod_1.z //
             .string()
             .describe('The name of the referenced model. If suffixed with "?", the field is optional.')
@@ -132,7 +134,7 @@ const fieldRelationTransformer = ({ fieldInput, model, projectSchema }, ctx) =>
         modelName: model.name,
         unbrandedType: idField.unbrandedTypeName,
         databaseType: idField.databaseType,
-        prismaRelationFieldName: fieldInput.prismaRelationFieldName ?? Branded.toDatabaseFieldName((0, utils_1.pluralize)(model.name)),
+        prismaRelationFieldName: fieldInput.prismaRelationFieldName ?? Branded.toDatabaseFieldName(`${model.name}.${fieldInput.name}`),
     };
 };
 exports.fieldRelationTransformer = fieldRelationTransformer;

package/dist/field/scalar.d.ts

@@ -56,10 +56,10 @@ type FieldScalarDateNoValidation = {
  * JSON Schema for an scalar field
  */
 export declare const zFieldScalarJSON: z.ZodObject<{
-    name: z.ZodEffects<z.ZodString, string, string>;
-    type: z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"String">, z.ZodLiteral<"String?">]>, z.ZodUnion<[z.ZodLiteral<"Boolean">, z.ZodLiteral<"Boolean?">]>, z.ZodUnion<[z.ZodLiteral<"DateTime">, z.ZodLiteral<"DateTime?">]>, z.ZodUnion<[z.ZodLiteral<"Decimal">, z.ZodLiteral<"Decimal?">]>, z.ZodUnion<[z.ZodLiteral<"Float">, z.ZodLiteral<"Float?">]>, z.ZodUnion<[z.ZodLiteral<"Int">, z.ZodLiteral<"Int?">]>, z.ZodUnion<[z.ZodLiteral<"Json">, z.ZodLiteral<"Json?">]>, z.ZodUnion<[z.ZodLiteral<"Bytes">, z.ZodLiteral<"Bytes?">]>, z.ZodUnion<[z.ZodLiteral<"BigInt">, z.ZodLiteral<"BigInt?">]>]>;
+    name: z.ZodString;
+    type: z.ZodUnion<readonly [z.ZodUnion<[z.ZodLiteral<"String">, z.ZodLiteral<"String?">]>, z.ZodUnion<[z.ZodLiteral<"Boolean">, z.ZodLiteral<"Boolean?">]>, z.ZodUnion<[z.ZodLiteral<"DateTime">, z.ZodLiteral<"DateTime?">]>, z.ZodUnion<[z.ZodLiteral<"Decimal">, z.ZodLiteral<"Decimal?">]>, z.ZodUnion<[z.ZodLiteral<"Float">, z.ZodLiteral<"Float?">]>, z.ZodUnion<[z.ZodLiteral<"Int">, z.ZodLiteral<"Int?">]>, z.ZodUnion<[z.ZodLiteral<"Json">, z.ZodLiteral<"Json?">]>, z.ZodUnion<[z.ZodLiteral<"Bytes">, z.ZodLiteral<"Bytes?">]>, z.ZodUnion<[z.ZodLiteral<"BigInt">, z.ZodLiteral<"BigInt?">]>]>;
     databaseName: z.ZodOptional<z.ZodString>;
-    excelName: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    excelName: z.ZodOptional<z.ZodString>;
     label: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     isReadonly: z.ZodOptional<z.ZodBoolean>;
@@ -69,52 +69,20 @@ export declare const zFieldScalarJSON: z.ZodObject<{
     isUpdatedAt: z.ZodOptional<z.ZodBoolean>;
     maxLength: z.ZodOptional<z.ZodNumber>;
     faker: z.ZodOptional<z.ZodString>;
-    seed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, "many">]>>;
+    seed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>>]>>;
     placeholder: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    type: "BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes" | "String?" | "Boolean?" | "DateTime?" | "Decimal?" | "Float?" | "Int?" | "Json?" | "Bytes?" | "BigInt?";
-    name: string;
-    description?: string | undefined;
-    databaseName?: string | undefined;
-    excelName?: string | undefined;
-    label?: string | undefined;
-    isReadonly?: boolean | undefined;
-    faker?: string | undefined;
-    seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
-    isUnique?: boolean | undefined;
-    hasIndex?: boolean | undefined;
-    isCreatedAt?: boolean | undefined;
-    isUpdatedAt?: boolean | undefined;
-    maxLength?: number | undefined;
-    placeholder?: string | undefined;
-}, {
-    type: "BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes" | "String?" | "Boolean?" | "DateTime?" | "Decimal?" | "Float?" | "Int?" | "Json?" | "Bytes?" | "BigInt?";
-    name: string;
-    description?: string | undefined;
-    databaseName?: string | undefined;
-    excelName?: string | undefined;
-    label?: string | undefined;
-    isReadonly?: boolean | undefined;
-    faker?: string | undefined;
-    seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
-    isUnique?: boolean | undefined;
-    hasIndex?: boolean | undefined;
-    isCreatedAt?: boolean | undefined;
-    isUpdatedAt?: boolean | undefined;
-    maxLength?: number | undefined;
-    placeholder?: string | undefined;
-}>;
+}, z.core.$strict>;
 export type FieldScalarJSON = z.infer<typeof zFieldScalarJSON>;
 export declare function fieldScalarJSONTransformer(fieldInput: FieldScalarJSON, ctx: z.RefinementCtx): FieldScalarEnriched;
 export type FieldScalarEnriched = Omit<FieldCommon<FieldKindScalar>, 'modelName'> & FieldCommonScalar & {
     type: Branded.ScalarType;
     validations: Partial<ValidationString & ValidationNumber>;
 };
-export declare const zFieldScalar: z.ZodEffects<z.ZodObject<{
-    name: z.ZodEffects<z.ZodString, string, string>;
-    type: z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"String">, z.ZodLiteral<"String?">]>, z.ZodUnion<[z.ZodLiteral<"Boolean">, z.ZodLiteral<"Boolean?">]>, z.ZodUnion<[z.ZodLiteral<"DateTime">, z.ZodLiteral<"DateTime?">]>, z.ZodUnion<[z.ZodLiteral<"Decimal">, z.ZodLiteral<"Decimal?">]>, z.ZodUnion<[z.ZodLiteral<"Float">, z.ZodLiteral<"Float?">]>, z.ZodUnion<[z.ZodLiteral<"Int">, z.ZodLiteral<"Int?">]>, z.ZodUnion<[z.ZodLiteral<"Json">, z.ZodLiteral<"Json?">]>, z.ZodUnion<[z.ZodLiteral<"Bytes">, z.ZodLiteral<"Bytes?">]>, z.ZodUnion<[z.ZodLiteral<"BigInt">, z.ZodLiteral<"BigInt?">]>]>;
+export declare const zFieldScalar: z.ZodPipe<z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodUnion<readonly [z.ZodUnion<[z.ZodLiteral<"String">, z.ZodLiteral<"String?">]>, z.ZodUnion<[z.ZodLiteral<"Boolean">, z.ZodLiteral<"Boolean?">]>, z.ZodUnion<[z.ZodLiteral<"DateTime">, z.ZodLiteral<"DateTime?">]>, z.ZodUnion<[z.ZodLiteral<"Decimal">, z.ZodLiteral<"Decimal?">]>, z.ZodUnion<[z.ZodLiteral<"Float">, z.ZodLiteral<"Float?">]>, z.ZodUnion<[z.ZodLiteral<"Int">, z.ZodLiteral<"Int?">]>, z.ZodUnion<[z.ZodLiteral<"Json">, z.ZodLiteral<"Json?">]>, z.ZodUnion<[z.ZodLiteral<"Bytes">, z.ZodLiteral<"Bytes?">]>, z.ZodUnion<[z.ZodLiteral<"BigInt">, z.ZodLiteral<"BigInt?">]>]>;
     databaseName: z.ZodOptional<z.ZodString>;
-    excelName: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    excelName: z.ZodOptional<z.ZodString>;
     label: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     isReadonly: z.ZodOptional<z.ZodBoolean>;
@@ -124,56 +92,24 @@ export declare const zFieldScalar: z.ZodEffects<z.ZodObject<{
     isUpdatedAt: z.ZodOptional<z.ZodBoolean>;
     maxLength: z.ZodOptional<z.ZodNumber>;
     faker: z.ZodOptional<z.ZodString>;
-    seed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, "many">]>>;
+    seed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>>]>>;
     placeholder: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    type: "BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes" | "String?" | "Boolean?" | "DateTime?" | "Decimal?" | "Float?" | "Int?" | "Json?" | "Bytes?" | "BigInt?";
+}, z.core.$strict>, z.ZodTransform<FieldScalarEnriched, {
     name: string;
-    description?: string | undefined;
-    databaseName?: string | undefined;
-    excelName?: string | undefined;
-    label?: string | undefined;
-    isReadonly?: boolean | undefined;
-    faker?: string | undefined;
-    seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
-    isUnique?: boolean | undefined;
-    hasIndex?: boolean | undefined;
-    isCreatedAt?: boolean | undefined;
-    isUpdatedAt?: boolean | undefined;
-    maxLength?: number | undefined;
-    placeholder?: string | undefined;
-}, {
     type: "BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes" | "String?" | "Boolean?" | "DateTime?" | "Decimal?" | "Float?" | "Int?" | "Json?" | "Bytes?" | "BigInt?";
-    name: string;
-    description?: string | undefined;
     databaseName?: string | undefined;
     excelName?: string | undefined;
     label?: string | undefined;
+    description?: string | undefined;
     isReadonly?: boolean | undefined;
-    faker?: string | undefined;
-    seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
     isUnique?: boolean | undefined;
     hasIndex?: boolean | undefined;
     isCreatedAt?: boolean | undefined;
     isUpdatedAt?: boolean | undefined;
     maxLength?: number | undefined;
-    placeholder?: string | undefined;
-}>, FieldScalarEnriched, {
-    type: "BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes" | "String?" | "Boolean?" | "DateTime?" | "Decimal?" | "Float?" | "Int?" | "Json?" | "Bytes?" | "BigInt?";
-    name: string;
-    description?: string | undefined;
-    databaseName?: string | undefined;
-    excelName?: string | undefined;
-    label?: string | undefined;
-    isReadonly?: boolean | undefined;
     faker?: string | undefined;
     seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
-    isUnique?: boolean | undefined;
-    hasIndex?: boolean | undefined;
-    isCreatedAt?: boolean | undefined;
-    isUpdatedAt?: boolean | undefined;
-    maxLength?: number | undefined;
     placeholder?: string | undefined;
-}>;
+}>>;
 export declare const fieldScalarTransformer: FieldTransformer<FieldKindScalar, FieldScalarEnriched, FieldScalar>;
 export {};

package/dist/field/shared/brands.d.ts

@@ -1,38 +1,38 @@
 import { z } from 'zod';
 import { ModelName } from '../../model/model.brands';
-export declare const zFieldName: z.ZodBranded<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, "PXL.FieldName">;
+export declare const zFieldName: z.core.$ZodBranded<z.ZodString, "PXL.FieldName", "out">;
 export type FieldName = z.infer<typeof zFieldName>;
-export declare const toFieldName: (input: string) => string & z.BRAND<"PXL.FieldName">;
-export declare const zFieldIdName: z.ZodBranded<z.ZodBranded<z.ZodLiteral<"id">, "PXL.FieldName">, "PXL.FieldName.Id">;
+export declare const toFieldName: (input: string) => string & z.core.$brand<"PXL.FieldName">;
+export declare const zFieldIdName: z.core.$ZodBranded<z.core.$ZodBranded<z.ZodLiteral<"id">, "PXL.FieldName", "out">, "PXL.FieldName.Id", "out">;
 export type FieldIdName = z.infer<typeof zFieldIdName>;
-export declare const toFieldIdName: (input: string) => "id" & z.BRAND<"PXL.FieldName"> & z.BRAND<"PXL.FieldName.Id">;
-export declare const zDatabaseFieldName: z.ZodBranded<z.ZodString, "PXL.DatabaseFieldName">;
+export declare const toFieldIdName: (input: string) => "id" & z.core.$brand<"PXL.FieldName"> & z.core.$brand<"PXL.FieldName.Id">;
+export declare const zDatabaseFieldName: z.core.$ZodBranded<z.ZodString, "PXL.DatabaseFieldName", "out">;
 export type DatabaseFieldName = z.infer<typeof zDatabaseFieldName>;
-export declare const toDatabaseFieldName: (input: string) => string & z.BRAND<"PXL.DatabaseFieldName">;
-export declare const zExcelColumnName: z.ZodBranded<z.ZodEffects<z.ZodString, string, string>, "PXL.ExcelColumnName">;
+export declare const toDatabaseFieldName: (input: string) => string & z.core.$brand<"PXL.DatabaseFieldName">;
+export declare const zExcelColumnName: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, "PXL.ExcelColumnName", "out">;
 export type ExcelColumnName = z.infer<typeof zExcelColumnName>;
-export declare const toExcelColumnName: (input: string) => string & z.BRAND<"PXL.ExcelColumnName">;
-export declare const zFieldLabel: z.ZodBranded<z.ZodString, "PXL.FieldLabel">;
+export declare const toExcelColumnName: (input: string) => string & z.core.$brand<"PXL.ExcelColumnName">;
+export declare const zFieldLabel: z.core.$ZodBranded<z.ZodString, "PXL.FieldLabel", "out">;
 export type FieldLabel = z.infer<typeof zFieldLabel>;
-export declare const toFieldLabel: (input: string) => string & z.BRAND<"PXL.FieldLabel">;
-export declare const zType: z.ZodBranded<z.ZodEffects<z.ZodString, string, string>, "PXL.Type">;
+export declare const toFieldLabel: (input: string) => string & z.core.$brand<"PXL.FieldLabel">;
+export declare const zType: z.core.$ZodBranded<z.ZodString, "PXL.Type", "out">;
 export type Type = z.infer<typeof zType>;
-export declare const toType: (input: string) => string & z.BRAND<"PXL.Type">;
-export declare const zIdType: z.ZodBranded<z.ZodBranded<z.ZodEffects<z.ZodString, string, string>, "PXL.IdType">, "PXL.Type">;
+export declare const toType: (input: string) => string & z.core.$brand<"PXL.Type">;
+export declare const zIdType: z.core.$ZodBranded<z.core.$ZodBranded<z.ZodString, "PXL.IdType", "out">, "PXL.Type", "out">;
 export type IdType = z.infer<typeof zIdType>;
-export declare const toIdType: (input: ModelName) => string & z.BRAND<"PXL.IdType"> & z.BRAND<"PXL.Type">;
-export declare const zScalarType: z.ZodBranded<z.ZodBranded<z.ZodUnion<[z.ZodLiteral<"string">, z.ZodLiteral<"number">, z.ZodLiteral<"boolean">, z.ZodLiteral<"Date">]>, "PXL.ScalarType">, "PXL.Type">;
+export declare const toIdType: (input: ModelName) => string & z.core.$brand<"PXL.IdType"> & z.core.$brand<"PXL.Type">;
+export declare const zScalarType: z.core.$ZodBranded<z.core.$ZodBranded<z.ZodUnion<readonly [z.ZodLiteral<"string">, z.ZodLiteral<"number">, z.ZodLiteral<"boolean">, z.ZodLiteral<"Date">]>, "PXL.ScalarType", "out">, "PXL.Type", "out">;
 export type ScalarType = z.infer<typeof zScalarType>;
-export declare const toScalarType: (input: string) => (("string" | "number" | "boolean" | "Date") & z.BRAND<"PXL.ScalarType">) & z.BRAND<"PXL.Type">;
-export declare const zScalarIdType: z.ZodBranded<z.ZodBranded<z.ZodBranded<z.ZodUnion<[z.ZodLiteral<"string">, z.ZodLiteral<"number">]>, "PXL.ScalarIdType">, "PXL.ScalarType">, "PXL.Type">;
+export declare const toScalarType: (input: string) => ("string" & z.core.$brand<"PXL.ScalarType"> & z.core.$brand<"PXL.Type">) | ("number" & z.core.$brand<"PXL.ScalarType"> & z.core.$brand<"PXL.Type">) | ("boolean" & z.core.$brand<"PXL.ScalarType"> & z.core.$brand<"PXL.Type">) | ("Date" & z.core.$brand<"PXL.ScalarType"> & z.core.$brand<"PXL.Type">);
+export declare const zScalarIdType: z.core.$ZodBranded<z.core.$ZodBranded<z.core.$ZodBranded<z.ZodUnion<readonly [z.ZodLiteral<"string">, z.ZodLiteral<"number">]>, "PXL.ScalarIdType", "out">, "PXL.ScalarType", "out">, "PXL.Type", "out">;
 export type ScalarIdType = z.infer<typeof zScalarIdType>;
-export declare const toScalarIdType: (input: string) => ((("string" | "number") & z.BRAND<"PXL.ScalarIdType">) & z.BRAND<"PXL.ScalarType">) & z.BRAND<"PXL.Type">;
-export declare const zEnumType: z.ZodBranded<z.ZodBranded<z.ZodEffects<z.ZodString, string, string>, "PXL.EnumType">, "PXL.Type">;
+export declare const toScalarIdType: (input: string) => ("string" & z.core.$brand<"PXL.ScalarIdType"> & z.core.$brand<"PXL.ScalarType"> & z.core.$brand<"PXL.Type">) | ("number" & z.core.$brand<"PXL.ScalarIdType"> & z.core.$brand<"PXL.ScalarType"> & z.core.$brand<"PXL.Type">);
+export declare const zEnumType: z.core.$ZodBranded<z.core.$ZodBranded<z.ZodString, "PXL.EnumType", "out">, "PXL.Type", "out">;
 export type EnumType = z.infer<typeof zEnumType>;
-export declare const toEnumType: (input: string) => string & z.BRAND<"PXL.EnumType"> & z.BRAND<"PXL.Type">;
-export declare const zDiscriminatedUnionType: z.ZodBranded<z.ZodBranded<z.ZodEffects<z.ZodString, string, string>, "PXL.DiscriminatedUnionType">, "PXL.Type">;
+export declare const toEnumType: (input: string) => string & z.core.$brand<"PXL.EnumType"> & z.core.$brand<"PXL.Type">;
+export declare const zDiscriminatedUnionType: z.core.$ZodBranded<z.core.$ZodBranded<z.ZodString, "PXL.DiscriminatedUnionType", "out">, "PXL.Type", "out">;
 export type DiscriminatedUnionType = z.infer<typeof zDiscriminatedUnionType>;
-export declare const toDiscriminatedUnionType: (input: string) => string & z.BRAND<"PXL.DiscriminatedUnionType"> & z.BRAND<"PXL.Type">;
-export declare const zDatabaseFieldType: z.ZodBranded<z.ZodUnion<[z.ZodLiteral<"BigInt">, z.ZodLiteral<"String">, z.ZodLiteral<"Boolean">, z.ZodLiteral<"DateTime">, z.ZodLiteral<"Decimal">, z.ZodLiteral<"Float">, z.ZodLiteral<"Int">, z.ZodLiteral<"Json">, z.ZodLiteral<"Bytes">]>, "PXL.DatabaseFieldType">;
+export declare const toDiscriminatedUnionType: (input: string) => string & z.core.$brand<"PXL.DiscriminatedUnionType"> & z.core.$brand<"PXL.Type">;
+export declare const zDatabaseFieldType: z.core.$ZodBranded<z.ZodUnion<readonly [z.ZodLiteral<"BigInt">, z.ZodLiteral<"String">, z.ZodLiteral<"Boolean">, z.ZodLiteral<"DateTime">, z.ZodLiteral<"Decimal">, z.ZodLiteral<"Float">, z.ZodLiteral<"Int">, z.ZodLiteral<"Json">, z.ZodLiteral<"Bytes">]>, "PXL.DatabaseFieldType", "out">;
 export type DatabaseFieldType = z.infer<typeof zDatabaseFieldType>;
-export declare const toDatabaseFieldType: (input: string) => ("BigInt" | "String" | "Boolean" | "DateTime" | "Decimal" | "Float" | "Int" | "Json" | "Bytes") & z.BRAND<"PXL.DatabaseFieldType">;
+export declare const toDatabaseFieldType: (input: string) => ("BigInt" & z.core.$brand<"PXL.DatabaseFieldType">) | ("String" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Boolean" & z.core.$brand<"PXL.DatabaseFieldType">) | ("DateTime" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Decimal" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Float" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Int" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Json" & z.core.$brand<"PXL.DatabaseFieldType">) | ("Bytes" & z.core.$brand<"PXL.DatabaseFieldType">);

package/dist/field/shared/brands.js

@@ -6,10 +6,15 @@ const utils_1 = require("@postxl/utils");
 // --- Names ---------------------------------------------------------------------------------------
 exports.zFieldName = zod_1.z
     .string()
-    .refine(utils_1.isCamelCase, (s) => ({ message: `Field name must be camelCase - received ${s}, expected ${(0, utils_1.toCamelCase)(s)}` }))
-    .refine((s) => !s.endsWith('?'), (s) => ({
-    message: `Field name "${s}" must not end with '?'! If you want to make a field optional, add "?" to the 'type' property, not to 'name'!`,
-}))
+    .refine(utils_1.isCamelCase, {
+    error: (issue) => {
+        const s = String(issue.input);
+        return `Field name must be camelCase - received ${s}, expected ${(0, utils_1.toCamelCase)(s)}`;
+    },
+})
+    .refine((s) => !s.endsWith('?'), {
+    error: (issue) => `Field name "${issue.input}" must not end with '?'! If you want to make a field optional, add "?" to the 'type' property, not to 'name'!`,
+})
     .brand('PXL.FieldName');
 const toFieldName = (input) => exports.zFieldName.parse(input);
 exports.toFieldName = toFieldName;
@@ -31,14 +36,24 @@ exports.toFieldLabel = toFieldLabel;
 // --- Types ---------------------------------------------------------------------------------------
 exports.zType = zod_1.z
     .string()
-    .refine(utils_1.isPascalCase, (s) => ({ message: `Type must be PascalCase - received ${s}, expected ${(0, utils_1.toPascalCase)(s)}` }))
+    .refine(utils_1.isPascalCase, {
+    error: (issue) => {
+        const s = String(issue.input);
+        return `Type must be PascalCase - received ${s}, expected ${(0, utils_1.toPascalCase)(s)}`;
+    },
+})
     .brand('PXL.Type')
     .describe('The name of the TypeScript type');
 const toType = (input) => exports.zType.parse(input);
 exports.toType = toType;
 exports.zIdType = zod_1.z
     .string()
-    .refine(utils_1.isPascalCase, (s) => ({ message: `Id type must be PascalCase - received ${s}, expected ${(0, utils_1.toPascalCase)(s)}` }))
+    .refine(utils_1.isPascalCase, {
+    error: (issue) => {
+        const s = String(issue.input);
+        return `Id type must be PascalCase - received ${s}, expected ${(0, utils_1.toPascalCase)(s)}`;
+    },
+})
     .brand('PXL.IdType')
     .brand('PXL.Type')
     .describe('The name of the TypeScript type that represents an id field of a model, e.g. `UserId`');
@@ -74,9 +89,12 @@ const toScalarIdType = (input) => exports.zScalarIdType.parse(input);
 exports.toScalarIdType = toScalarIdType;
 exports.zEnumType = zod_1.z
     .string()
-    .refine(utils_1.isPascalCase, (s) => ({
-    message: `Enum name must be PascalCase - received ${s}, expected ${(0, utils_1.toPascalCase)(s)}`,
-}))
+    .refine(utils_1.isPascalCase, {
+    error: (issue) => {
+        const s = String(issue.input);
+        return `Enum name must be PascalCase - received ${s}, expected ${(0, utils_1.toPascalCase)(s)}`;
+    },
+})
     .brand('PXL.EnumType')
     .brand('PXL.Type')
     .describe('The name of the TypeScript type that represents an enum, e.g. `ActionStatus`');
@@ -84,7 +102,7 @@ const toEnumType = (input) => exports.zEnumType.parse(input);
 exports.toEnumType = toEnumType;
 exports.zDiscriminatedUnionType = zod_1.z
     .string()
-    .refine(utils_1.isPascalCase, { message: 'Discriminated union name must be PascalCase' })
+    .refine(utils_1.isPascalCase, { error: 'Discriminated union name must be PascalCase' })
     .brand('PXL.DiscriminatedUnionType')
     .brand('PXL.Type')
     .describe('The name of the TypeScript type that represents a discriminated union, e.g. `ActionStatus`');

package/dist/field/shared/decoders.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-export declare const zFieldPropertyName: z.ZodEffects<z.ZodString, string, string>;
+export declare const zFieldPropertyName: z.ZodString;
 export declare const zFieldPropertyType: z.ZodString;
 export declare const zFieldPropertyDatabaseName: z.ZodOptional<z.ZodString>;
-export declare const zFieldPropertyExcelName: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+export declare const zFieldPropertyExcelName: z.ZodOptional<z.ZodString>;
 export declare const zFieldPropertyLabel: z.ZodOptional<z.ZodString>;
 export declare const zFieldPropertyDescription: z.ZodOptional<z.ZodString>;
 export declare const zFieldPropertyIsReadonly: z.ZodOptional<z.ZodBoolean>;
@@ -12,6 +12,6 @@ export declare const zFieldPropertyIsCreatedAt: z.ZodOptional<z.ZodBoolean>;
 export declare const zFieldPropertyIsUpdatedAt: z.ZodOptional<z.ZodBoolean>;
 export declare const zFieldPropertyMaxLength: z.ZodOptional<z.ZodNumber>;
 export declare const zFieldFaker: z.ZodOptional<z.ZodString>;
-export declare const zScalarValue: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>;
-export declare const zFieldSeed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, "many">]>>;
+export declare const zScalarValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>;
+export declare const zFieldSeed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>>]>>;
 export declare const zFieldPropertyPlaceholder: z.ZodOptional<z.ZodString>;

package/dist/field/shared/decoders.js

@@ -6,12 +6,14 @@ const utils_1 = require("@postxl/utils");
 exports.zFieldPropertyName = zod_1.z
     //
     .string()
-    .min(1, 'Name of the field must not be empty')
-    .refine((name) => (0, utils_1.toCamelCase)(name) === name, (name) => ({ message: `Field name must be camelCased, but is ${(0, utils_1.red)(name)}!` }))
+    .min(1, { error: 'Name of the field must not be empty' })
+    .refine((name) => (0, utils_1.toCamelCase)(name) === name, {
+    error: (issue) => `Field name must be camelCased, but is ${(0, utils_1.red)(String(issue.input))}!`,
+})
     .describe('Name of the field. Must be camelCased.');
 exports.zFieldPropertyType = zod_1.z
     .string()
-    .min(1, 'Type of the field must not be empty')
+    .min(1, { error: 'Type of the field must not be empty' })
     .describe(`The type of the field. This should either be:
 * \`String\` or \`Int\` in case name is \`id\
 * \`String\`, \`Int\`, \`Float\` or \`DateTime\` for scalar fields
@@ -26,9 +28,9 @@ exports.zFieldPropertyDatabaseName = zod_1.z
 exports.zFieldPropertyExcelName = zod_1.z
     .string()
     .optional()
-    .refine((val) => val === undefined || val === (0, utils_1.toExcelColumnName)(val), (val) => ({
-    message: `Excel column name "${(0, utils_1.red)(val ?? '')}" is not a valid Excel table name. It must start with a letter or underscore and can only contain letters, numbers, and underscores.`,
-}))
+    .refine((val) => val === undefined || val === (0, utils_1.toExcelColumnName)(val), {
+    error: (issue) => `Excel column name "${(0, utils_1.red)(String(issue.input ?? ''))}" is not a valid Excel table name. It must start with a letter or underscore and can only contain letters, numbers, and underscores.`,
+})
     .describe('Mapping of the field to an Excel column name. If not provided, we use the `label` field.');
 exports.zFieldPropertyLabel = zod_1.z
     .string()

package/dist/field/shared/seed.d.ts

@@ -1,15 +1,9 @@
 import { z } from 'zod';
 import * as Decoders from './decoders';
 declare const _seedDecoder: z.ZodObject<{
-    seed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, "many">]>>;
+    seed: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodDate]>>]>>;
     faker: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    faker?: string | undefined;
-    seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
-}, {
-    faker?: string | undefined;
-    seed?: string | number | boolean | Date | (string | number | boolean | Date)[] | undefined;
-}>;
+}, z.core.$strip>;
 type Decoded = z.infer<typeof _seedDecoder>;
 export type FieldSeedConfig = FieldSeedConfig_Default | FieldSeedConfig_Const | FieldSeedConfig_Array | FieldSeedConfig_Faker;
 export type FieldSeedConfig_Default = {

package/dist/model/model.brands.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-export declare const zModelName: z.ZodBranded<z.ZodString, "PXL.ModelName">;
+export declare const zModelName: z.core.$ZodBranded<z.ZodString, "PXL.ModelName", "out">;
 export type ModelName = z.infer<typeof zModelName>;
-export declare const toModelName: (input: string) => string & z.BRAND<"PXL.ModelName">;
-export declare const zDatabaseModelName: z.ZodBranded<z.ZodString, "PXL.DatabaseModelName">;
+export declare const toModelName: (input: string) => string & z.core.$brand<"PXL.ModelName">;
+export declare const zDatabaseModelName: z.core.$ZodBranded<z.ZodString, "PXL.DatabaseModelName", "out">;
 export type DatabaseModelName = z.infer<typeof zDatabaseModelName>;
-export declare const toDatabaseModelName: (input: string) => string & z.BRAND<"PXL.DatabaseModelName">;
+export declare const toDatabaseModelName: (input: string) => string & z.core.$brand<"PXL.DatabaseModelName">;

package/dist/model/model.defaults.d.ts

@@ -1,16 +1,16 @@
 import * as Branded from './model.brands';
 import { ModelJSON } from './model.json-decoder';
-export declare const defaultModelName_Config: string & import("zod").BRAND<"PXL.ModelName">;
-export declare const standardModelName_User: string & import("zod").BRAND<"PXL.ModelName">;
-export declare const standardModelName_Action: string & import("zod").BRAND<"PXL.ModelName">;
-export declare const standardModelName_ActionOperation: string & import("zod").BRAND<"PXL.ModelName">;
-export declare const standardModelName_File: string & import("zod").BRAND<"PXL.ModelName">;
+export declare const defaultModelName_Config: string & import("zod").$brand<"PXL.ModelName">;
+export declare const standardModelName_User: string & import("zod").$brand<"PXL.ModelName">;
+export declare const standardModelName_Action: string & import("zod").$brand<"PXL.ModelName">;
+export declare const standardModelName_ActionOperation: string & import("zod").$brand<"PXL.ModelName">;
+export declare const standardModelName_File: string & import("zod").$brand<"PXL.ModelName">;
 export declare const defaultModelNames: {
-    config: string & import("zod").BRAND<"PXL.ModelName">;
-    user: string & import("zod").BRAND<"PXL.ModelName">;
-    action: string & import("zod").BRAND<"PXL.ModelName">;
-    mutation: string & import("zod").BRAND<"PXL.ModelName">;
-    file: string & import("zod").BRAND<"PXL.ModelName">;
+    config: string & import("zod").$brand<"PXL.ModelName">;
+    user: string & import("zod").$brand<"PXL.ModelName">;
+    action: string & import("zod").$brand<"PXL.ModelName">;
+    mutation: string & import("zod").$brand<"PXL.ModelName">;
+    file: string & import("zod").$brand<"PXL.ModelName">;
 };
 export declare const defaultModel_Config: ModelJSON;
 export declare const defaultModelJson_User: ModelJSON;