@postxl/schema 1.1.0 → 1.2.0

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

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

package/dist/enum/enum.brands.js

@@ -5,9 +5,12 @@ 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}.`,
-}))
+    .refine((v) => (0, utils_1.isCamelCase)(v) || (0, utils_1.isPascalCase)(v), {
+    error: (issue) => {
+        const v = String(issue.input);
+        return `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;

package/dist/enum/enum.d.ts

@@ -1,49 +1,25 @@
-export declare const zEnum: import("zod").ZodEffects<import("zod").ZodObject<{
-    name: import("zod").ZodEffects<import("zod").ZodString, string, string>;
+export declare const zEnum: import("zod").ZodPipe<import("zod").ZodObject<{
+    name: import("zod").ZodString;
     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<{
+    members: import("zod").ZodArray<import("zod").ZodUnion<readonly [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, {
+    }, import("zod/v4/core").$strip>, import("zod").ZodString]>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
+    name: string & import("zod").$brand<"PXL.EnumName">;
     description: string;
-    name: string;
-    members: (string | {
-        value: string;
-        description?: string | undefined;
-    })[];
-    schema?: string | undefined;
-    databaseName?: string | undefined;
+    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;
-}>, {
-    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

@@ -1,16 +1,16 @@
 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 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">;
+    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;
+    description: string;
     members: (string | {
         value: string;
         description?: string | undefined;
@@ -19,8 +19,8 @@ export declare const defaultEnumJson_ActionStatus: {
     databaseName?: string | undefined;
 };
 export declare const defaultEnumJson_MutationStatus: {
-    description: string;
     name: string;
+    description: string;
     members: (string | {
         value: string;
         description?: string | undefined;
@@ -29,8 +29,8 @@ export declare const defaultEnumJson_MutationStatus: {
     databaseName?: string | undefined;
 };
 export declare const defaultEnumJson_MutationKind: {
-    description: string;
     name: string;
+    description: string;
     members: (string | {
         value: string;
         description?: string | undefined;

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

@@ -4,58 +4,22 @@ 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;
-}>;
+}, z.core.$strip>;
 export declare const zEnumMemberCompact: z.ZodString;
-export declare const zEnumMemberJSON: z.ZodUnion<[z.ZodObject<{
+export declare const zEnumMemberJSON: z.ZodUnion<readonly [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]>;
+}, z.core.$strip>, z.ZodString]>;
 export type EnumMemberJSON = z.infer<typeof zEnumMemberJSON>;
-export declare const zEnumNameJSON: z.ZodEffects<z.ZodString, string, string>;
+export declare const zEnumNameJSON: z.ZodString;
 export declare const zEnumJSON: z.ZodObject<{
-    name: z.ZodEffects<z.ZodString, string, string>;
+    name: z.ZodString;
     description: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     schema: z.ZodOptional<z.ZodString>;
     databaseName: z.ZodOptional<z.ZodString>;
-    members: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+    members: z.ZodArray<z.ZodUnion<readonly [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;
-}>;
+    }, z.core.$strip>, z.ZodString]>>;
+}, z.core.$strip>;
 export type EnumJSON = z.infer<typeof zEnumJSON>;

package/dist/enum/enum.json-decoder.js

@@ -6,7 +6,7 @@ const utils_1 = require("@postxl/utils");
 exports.zEnumMemberNameJSON = zod_1.z
     //
     .string()
-    .min(1, 'Value of the enum member must not be empty')
+    .min(1, { error: 'Value of the enum member must not be empty' })
     .describe('The value of the enum member.');
 exports.zEnumMemberDescriptionJSON = zod_1.z
     //
@@ -22,10 +22,13 @@ exports.zEnumMemberJSON = zod_1.z.union([exports.zEnumMemberJSONDetailed, export
 exports.zEnumNameJSON = zod_1.z
     //
     .string()
-    .min(1, 'Name of the enum must not be empty')
-    .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}.`,
-}))
+    .min(1, { error: 'Name of the enum must not be empty' })
+    .refine((v) => (0, utils_1.isCamelCase)(v) || (0, utils_1.isPascalCase)(v), {
+    error: (issue) => {
+        const v = String(issue.input);
+        return `Enum name must be camelCase (${(0, utils_1.toCamelCase)(v)} or PascalCase ${(0, utils_1.toPascalCase)(v)})! Received ${v}.`;
+    },
+})
     .describe('Name of the enum.');
 exports.zEnumJSON = zod_1.z.object({
     name: exports.zEnumNameJSON,
@@ -47,5 +50,5 @@ exports.zEnumJSON = zod_1.z.object({
     members: zod_1.z
         //
         .array(exports.zEnumMemberJSON)
-        .min(1, 'Enum must have at least one member.'),
+        .min(1, { error: 'Enum must have at least one member.' }),
 });

package/dist/enum/enum.transformer.d.ts

@@ -4,9 +4,9 @@ import type { EnumMember } from './enum.types';
 export declare function enumMemberTransformer(input: EnumMemberJSON): EnumMember;
 export type EnumEnriched = ReturnType<typeof enumTransformer>;
 export declare function enumTransformer(input: EnumJSON, ctx: z.RefinementCtx): {
-    name: string & z.BRAND<"PXL.EnumName">;
+    name: string & z.core.$brand<"PXL.EnumName">;
     description: string;
-    members: Map<string & z.BRAND<"PXL.EnumValue">, EnumMember>;
-    databaseSchema: (string & z.BRAND<"PXL.DatabaseSchemaName">) | undefined;
-    databaseName: string & z.BRAND<"PXL.DatabaseEnumName">;
+    members: Map<string & z.core.$brand<"PXL.EnumValue">, EnumMember>;
+    databaseSchema: (string & z.core.$brand<"PXL.DatabaseSchemaName">) | undefined;
+    databaseName: string & z.core.$brand<"PXL.DatabaseEnumName">;
 };

package/dist/field/defaults.d.ts

@@ -1,10 +1,10 @@
 import * as Branded from './shared/brands';
 import { FieldJSONInput } from './field';
-export declare const standardFieldName_id: "id" & import("zod").BRAND<"PXL.FieldName"> & import("zod").BRAND<"PXL.FieldName.Id">;
-export declare const standardFieldName_createdAt: string & import("zod").BRAND<"PXL.FieldName">;
-export declare const standardFieldName_updatedAt: string & import("zod").BRAND<"PXL.FieldName">;
-export declare const standardFieldName_name: string & import("zod").BRAND<"PXL.FieldName">;
-export declare const standardFieldNames: (string & import("zod").BRAND<"PXL.FieldName">)[];
+export declare const standardFieldName_id: "id" & import("zod").$brand<"PXL.FieldName"> & import("zod").$brand<"PXL.FieldName.Id">;
+export declare const standardFieldName_createdAt: string & import("zod").$brand<"PXL.FieldName">;
+export declare const standardFieldName_updatedAt: string & import("zod").$brand<"PXL.FieldName">;
+export declare const standardFieldName_name: string & import("zod").$brand<"PXL.FieldName">;
+export declare const standardFieldNames: (string & import("zod").$brand<"PXL.FieldName">)[];
 export declare const standardField_id: FieldJSONInput;
 export declare const standardField_createdAt: FieldJSONInput;
 export declare const standardField_updatedAt: FieldJSONInput;

package/dist/field/discriminated-union.d.ts

@@ -44,73 +44,37 @@ export type FieldDiscriminatedUnion = FieldCommon<FieldKindDiscriminatedUnion> &
     members: Map<Discriminator, DiscriminatedUnionMember>;
 };
 export type FieldDiscriminatedUnionEnriched = ReturnType<typeof fieldDiscriminatedUnionJSONTransformer>;
-declare const zDiscriminator: z.ZodBranded<z.ZodString, "PXL.Discriminator">;
+declare const zDiscriminator: z.core.$ZodBranded<z.ZodString, "PXL.Discriminator", "out">;
 export type Discriminator = z.infer<typeof zDiscriminator>;
-declare const zDiscriminatorLabel: z.ZodBranded<z.ZodString, "PXL.DiscriminatorLabel">;
+declare const zDiscriminatorLabel: z.core.$ZodBranded<z.ZodString, "PXL.DiscriminatorLabel", "out">;
 type DiscriminatorLabel = z.infer<typeof zDiscriminatorLabel>;
 export declare const zField: z.ZodRecord<z.ZodString, z.ZodAny>;
 /**
  * JSON Schema for an Discriminated Union field
  */
 export declare const zFieldDiscriminatedUnionJSON: z.ZodObject<{
-    name: z.ZodEffects<z.ZodString, string, string>;
+    name: z.ZodString;
     type: z.ZodUnion<[z.ZodLiteral<"DiscriminatedUnion">, z.ZodLiteral<"DiscriminatedUnion?">]>;
     label: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     databaseName: z.ZodOptional<z.ZodString>;
-    excelName: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    excelName: z.ZodOptional<z.ZodString>;
     members: z.ZodArray<z.ZodObject<{
-        type: z.ZodEffects<z.ZodString, string, string>;
+        type: z.ZodString;
         label: z.ZodOptional<z.ZodString>;
-        fields: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        type: string;
-        label?: string | undefined;
-        fields?: Record<string, any>[] | undefined;
-    }, {
-        type: string;
-        label?: string | undefined;
-        fields?: Record<string, any>[] | undefined;
-    }>, "many">;
-    commonFields: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    }, z.core.$strip>>;
+    commonFields: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>>;
     isReadonly: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    type: "DiscriminatedUnion" | "DiscriminatedUnion?";
-    name: string;
-    members: {
-        type: string;
-        label?: string | undefined;
-        fields?: Record<string, any>[] | undefined;
-    }[];
-    description?: string | undefined;
-    databaseName?: string | undefined;
-    excelName?: string | undefined;
-    label?: string | undefined;
-    isReadonly?: boolean | undefined;
-    commonFields?: Record<string, any>[] | undefined;
-}, {
-    type: "DiscriminatedUnion" | "DiscriminatedUnion?";
-    name: string;
-    members: {
-        type: string;
-        label?: string | undefined;
-        fields?: Record<string, any>[] | undefined;
-    }[];
-    description?: string | undefined;
-    databaseName?: string | undefined;
-    excelName?: string | undefined;
-    label?: string | undefined;
-    isReadonly?: boolean | undefined;
-    commonFields?: Record<string, any>[] | undefined;
-}>;
+}, z.core.$strip>;
 export type FieldDiscriminatedUnionJSON = z.infer<typeof zFieldDiscriminatedUnionJSON>;
 export declare function fieldDiscriminatedUnionJSONTransformer(fieldInput: FieldDiscriminatedUnionJSON): {
     kind: "discriminatedUnion";
-    name: string & z.BRAND<"PXL.FieldName">;
-    discriminatorFieldName: string & z.BRAND<"PXL.FieldName">;
+    name: string & z.core.$brand<"PXL.FieldName">;
+    discriminatorFieldName: string & z.core.$brand<"PXL.FieldName">;
     label: string;
-    databaseName: string & z.BRAND<"PXL.DatabaseFieldName">;
-    excelName: string & z.BRAND<"PXL.ExcelColumnName">;
+    databaseName: string & z.core.$brand<"PXL.DatabaseFieldName">;
+    excelName: string & z.core.$brand<"PXL.ExcelColumnName">;
     description: string | undefined;
     members: {
         type: string;

package/dist/field/enum.d.ts

@@ -20,42 +20,24 @@ export type FieldEnum = Omit<FieldCommon<FieldKindEnum>, 'databaseType'> & {
 export declare const createEnumJSONDecoder: ({ enumNames }: {
     enumNames: Enum.EnumName[];
 }) => z.ZodObject<{
-    name: z.ZodEffects<z.ZodString, 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>;
     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;
-}, {
-    type: string;
-    name: string;
-    description?: string | undefined;
-    databaseName?: string | undefined;
-    excelName?: string | undefined;
-    label?: string | undefined;
-    isReadonly?: boolean | undefined;
-    isUnique?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export type FieldEnumJSON = z.infer<ReturnType<typeof createEnumJSONDecoder>>;
 export declare function fieldEnumJSONTransformer(fieldInput: FieldEnumJSON): {
     kind: "enum";
-    type: string & z.BRAND<"PXL.EnumType"> & z.BRAND<"PXL.Type">;
-    name: string & z.BRAND<"PXL.FieldName">;
-    referencedEnumName: string & z.BRAND<"PXL.EnumName">;
+    type: string & z.core.$brand<"PXL.EnumType"> & z.core.$brand<"PXL.Type">;
+    name: string & z.core.$brand<"PXL.FieldName">;
+    referencedEnumName: string & z.core.$brand<"PXL.EnumName">;
     label: string;
-    databaseName: string & z.BRAND<"PXL.DatabaseFieldName">;
-    excelName: string & z.BRAND<"PXL.ExcelColumnName">;
+    databaseName: string & z.core.$brand<"PXL.DatabaseFieldName">;
+    excelName: string & z.core.$brand<"PXL.ExcelColumnName">;
     description: string | undefined;
     isRequired: boolean;
     isReadonly: boolean;