@hy_ong/zod-kit 0.2.1 → 0.2.3

package/src/i18n/locales/ja-JP.json

@@ -17,6 +17,13 @@
       "businessOnly": "ビジネスメールアドレスのみ使用可能です",
       "noDisposable": "使い捨てメールアドレスは使用できません"
     },
+    "manyOf": {
+      "required": "必須項目です",
+      "invalid": "次のいずれかである必要があります：${values}",
+      "minSelect": "${min}個以上選択してください",
+      "maxSelect": "${max}個以下で選択してください",
+      "duplicate": "重複した値は許可されていません"
+    },
     "url": {
       "required": "必須項目です",
       "invalid": "無効なURL形式です",
@@ -68,6 +75,10 @@
       "finite": "有限の数である必要があります",
       "precision": "小数点以下は ${precision} 桁以内である必要があります"
     },
+    "oneOf": {
+      "required": "必須項目です",
+      "invalid": "次のいずれかである必要があります：${values}"
+    },
     "id": {
       "required": "必須項目です",
       "invalid": "無効なID形式です",
@@ -75,6 +86,14 @@
       "maxLength": "${maxLength}文字以下で入力してください",
       "numeric": "数値IDである必要があります",
       "uuid": "有効なUUIDである必要があります",
+      "uuidv1": "有効なUUID v1である必要があります",
+      "uuidv2": "有効なUUID v2である必要があります",
+      "uuidv3": "有効なUUID v3である必要があります",
+      "uuidv4": "有効なUUID v4である必要があります",
+      "uuidv5": "有効なUUID v5である必要があります",
+      "uuidv6": "有効なUUID v6である必要があります",
+      "uuidv7": "有効なUUID v7である必要があります",
+      "uuidv8": "有効なUUID v8である必要があります",
       "objectId": "有効なMongoDB ObjectIdである必要があります",
       "nanoid": "有効なNano IDである必要があります",
       "snowflake": "有効なSnowflake IDである必要があります",

package/src/i18n/locales/ko-KR.json

@@ -17,6 +17,13 @@
       "businessOnly": "비즈니스 이메일 주소만 허용됩니다",
       "noDisposable": "일회용 이메일 주소는 허용되지 않습니다"
     },
+    "manyOf": {
+      "required": "필수 항목입니다",
+      "invalid": "다음 중 하나여야 합니다: ${values}",
+      "minSelect": "최소 ${min}개를 선택해야 합니다",
+      "maxSelect": "최대 ${max}개까지 선택할 수 있습니다",
+      "duplicate": "중복된 값은 허용되지 않습니다"
+    },
     "url": {
       "required": "필수 항목입니다",
       "invalid": "유효하지 않은 URL 형식입니다",
@@ -68,6 +75,10 @@
       "finite": "유한한 수여야 합니다",
       "precision": "소수점 이하 ${precision}자리 이내여야 합니다"
     },
+    "oneOf": {
+      "required": "필수 항목입니다",
+      "invalid": "다음 중 하나여야 합니다: ${values}"
+    },
     "id": {
       "required": "필수 항목입니다",
       "invalid": "유효하지 않은 ID 형식입니다",
@@ -75,6 +86,14 @@
       "maxLength": "최대 ${maxLength}자 이하여야 합니다",
       "numeric": "숫자 ID여야 합니다",
       "uuid": "유효한 UUID여야 합니다",
+      "uuidv1": "유효한 UUID v1이어야 합니다",
+      "uuidv2": "유효한 UUID v2이어야 합니다",
+      "uuidv3": "유효한 UUID v3이어야 합니다",
+      "uuidv4": "유효한 UUID v4이어야 합니다",
+      "uuidv5": "유효한 UUID v5이어야 합니다",
+      "uuidv6": "유효한 UUID v6이어야 합니다",
+      "uuidv7": "유효한 UUID v7이어야 합니다",
+      "uuidv8": "유효한 UUID v8이어야 합니다",
       "objectId": "유효한 MongoDB ObjectId여야 합니다",
       "nanoid": "유효한 Nano ID여야 합니다",
       "snowflake": "유효한 Snowflake ID여야 합니다",

package/src/i18n/locales/ms-MY.json

@@ -17,6 +17,13 @@
       "businessOnly": "Hanya alamat e-mel perniagaan dibenarkan",
       "noDisposable": "Alamat e-mel pakai buang tidak dibenarkan"
     },
+    "manyOf": {
+      "required": "Diperlukan",
+      "invalid": "Mesti daripada: ${values}",
+      "minSelect": "Mesti pilih sekurang-kurangnya ${min} item",
+      "maxSelect": "Mesti pilih paling banyak ${max} item",
+      "duplicate": "Nilai pendua tidak dibenarkan"
+    },
     "url": {
       "required": "Wajib diisi",
       "invalid": "Format URL tidak sah",
@@ -68,6 +75,10 @@
       "finite": "Mesti nombor terhingga",
       "precision": "Mesti tidak melebihi ${precision} tempat perpuluhan"
     },
+    "oneOf": {
+      "required": "Diperlukan",
+      "invalid": "Mesti salah satu daripada: ${values}"
+    },
     "id": {
       "required": "Wajib diisi",
       "invalid": "Format ID tidak sah",
@@ -75,6 +86,14 @@
       "maxLength": "Mesti tidak melebihi ${maxLength} aksara",
       "numeric": "Mesti ID numerik",
       "uuid": "Mesti UUID yang sah",
+      "uuidv1": "Mesti UUID v1 yang sah",
+      "uuidv2": "Mesti UUID v2 yang sah",
+      "uuidv3": "Mesti UUID v3 yang sah",
+      "uuidv4": "Mesti UUID v4 yang sah",
+      "uuidv5": "Mesti UUID v5 yang sah",
+      "uuidv6": "Mesti UUID v6 yang sah",
+      "uuidv7": "Mesti UUID v7 yang sah",
+      "uuidv8": "Mesti UUID v8 yang sah",
       "objectId": "Mesti MongoDB ObjectId yang sah",
       "nanoid": "Mesti Nano ID yang sah",
       "snowflake": "Mesti Snowflake ID yang sah",

package/src/i18n/locales/th-TH.json

@@ -17,6 +17,13 @@
       "businessOnly": "อนุญาตเฉพาะอีเมลธุรกิจเท่านั้น",
       "noDisposable": "ไม่อนุญาตอีเมลแบบใช้แล้วทิ้ง"
     },
+    "manyOf": {
+      "required": "จำเป็น",
+      "invalid": "ต้องเป็นหนึ่งใน: ${values}",
+      "minSelect": "ต้องเลือกอย่างน้อย ${min} รายการ",
+      "maxSelect": "เลือกได้มากสุด ${max} รายการ",
+      "duplicate": "ไม่อนุญาตให้มีค่าซ้ำ"
+    },
     "url": {
       "required": "จำเป็นต้องกรอก",
       "invalid": "รูปแบบ URL ไม่ถูกต้อง",
@@ -68,6 +75,10 @@
       "finite": "ต้องเป็นจำนวนจำกัด",
       "precision": "ต้องมีทศนิยมไม่เกิน ${precision} ตำแหน่ง"
     },
+    "oneOf": {
+      "required": "จำเป็น",
+      "invalid": "ต้องเป็นหนึ่งใน: ${values}"
+    },
     "id": {
       "required": "จำเป็นต้องกรอก",
       "invalid": "รูปแบบ ID ไม่ถูกต้อง",
@@ -75,6 +86,14 @@
       "maxLength": "ต้องไม่เกิน ${maxLength} ตัวอักษร",
       "numeric": "ต้องเป็น ID ตัวเลข",
       "uuid": "ต้องเป็น UUID ที่ถูกต้อง",
+      "uuidv1": "ต้องเป็น UUID v1 ที่ถูกต้อง",
+      "uuidv2": "ต้องเป็น UUID v2 ที่ถูกต้อง",
+      "uuidv3": "ต้องเป็น UUID v3 ที่ถูกต้อง",
+      "uuidv4": "ต้องเป็น UUID v4 ที่ถูกต้อง",
+      "uuidv5": "ต้องเป็น UUID v5 ที่ถูกต้อง",
+      "uuidv6": "ต้องเป็น UUID v6 ที่ถูกต้อง",
+      "uuidv7": "ต้องเป็น UUID v7 ที่ถูกต้อง",
+      "uuidv8": "ต้องเป็น UUID v8 ที่ถูกต้อง",
       "objectId": "ต้องเป็น MongoDB ObjectId ที่ถูกต้อง",
       "nanoid": "ต้องเป็น Nano ID ที่ถูกต้อง",
       "snowflake": "ต้องเป็น Snowflake ID ที่ถูกต้อง",

package/src/i18n/locales/vi-VN.json

@@ -17,6 +17,13 @@
       "businessOnly": "Chỉ cho phép địa chỉ email doanh nghiệp",
       "noDisposable": "Không cho phép địa chỉ email dùng một lần"
     },
+    "manyOf": {
+      "required": "Bắt buộc",
+      "invalid": "Phải thuộc: ${values}",
+      "minSelect": "Phải chọn ít nhất ${min} mục",
+      "maxSelect": "Chỉ được chọn tối đa ${max} mục",
+      "duplicate": "Không được phép có giá trị trùng lặp"
+    },
     "url": {
       "required": "Bắt buộc",
       "invalid": "Định dạng URL không hợp lệ",
@@ -68,6 +75,10 @@
       "finite": "Phải là số hữu hạn",
       "precision": "Phải có tối đa ${precision} chữ số thập phân"
     },
+    "oneOf": {
+      "required": "Bắt buộc",
+      "invalid": "Phải là một trong: ${values}"
+    },
     "id": {
       "required": "Bắt buộc",
       "invalid": "Định dạng ID không hợp lệ",
@@ -75,6 +86,14 @@
       "maxLength": "Phải có tối đa ${maxLength} ký tự",
       "numeric": "Phải là ID dạng số",
       "uuid": "Phải là UUID hợp lệ",
+      "uuidv1": "Phải là UUID v1 hợp lệ",
+      "uuidv2": "Phải là UUID v2 hợp lệ",
+      "uuidv3": "Phải là UUID v3 hợp lệ",
+      "uuidv4": "Phải là UUID v4 hợp lệ",
+      "uuidv5": "Phải là UUID v5 hợp lệ",
+      "uuidv6": "Phải là UUID v6 hợp lệ",
+      "uuidv7": "Phải là UUID v7 hợp lệ",
+      "uuidv8": "Phải là UUID v8 hợp lệ",
       "objectId": "Phải là MongoDB ObjectId hợp lệ",
       "nanoid": "Phải là Nano ID hợp lệ",
       "snowflake": "Phải là Snowflake ID hợp lệ",

package/src/i18n/locales/zh-CN.json

@@ -17,6 +17,13 @@
       "businessOnly": "仅允许企业邮箱地址",
       "noDisposable": "不允许使用临时邮箱地址"
     },
+    "manyOf": {
+      "required": "必填",
+      "invalid": "必须为以下值之一：${values}",
+      "minSelect": "至少需选择 ${min} 项",
+      "maxSelect": "最多只能选择 ${max} 项",
+      "duplicate": "不允许重复的值"
+    },
     "url": {
       "required": "必填",
       "invalid": "无效的 URL 格式",
@@ -68,6 +75,10 @@
       "finite": "必须为有限数字",
       "precision": "小数位数不可超过 ${precision} 位"
     },
+    "oneOf": {
+      "required": "必填",
+      "invalid": "必须为以下其中一个值：${values}"
+    },
     "id": {
       "required": "必填",
       "invalid": "无效的 ID 格式",
@@ -75,6 +86,14 @@
       "maxLength": "长度最多 ${maxLength} 个字符",
       "numeric": "必须为数字 ID",
       "uuid": "必须为有效的 UUID",
+      "uuidv1": "必须为有效的 UUID v1",
+      "uuidv2": "必须为有效的 UUID v2",
+      "uuidv3": "必须为有效的 UUID v3",
+      "uuidv4": "必须为有效的 UUID v4",
+      "uuidv5": "必须为有效的 UUID v5",
+      "uuidv6": "必须为有效的 UUID v6",
+      "uuidv7": "必须为有效的 UUID v7",
+      "uuidv8": "必须为有效的 UUID v8",
       "objectId": "必须为有效的 MongoDB ObjectId",
       "nanoid": "必须为有效的 Nano ID",
       "snowflake": "必须为有效的 Snowflake ID",

package/src/i18n/locales/zh-TW.json

@@ -17,6 +17,13 @@
       "businessOnly": "僅允許企業郵箱地址",
       "noDisposable": "不允許使用臨時郵箱地址"
     },
+    "manyOf": {
+      "required": "必填",
+      "invalid": "必須為以下值之一：${values}",
+      "minSelect": "至少需選擇 ${min} 項",
+      "maxSelect": "最多只能選擇 ${max} 項",
+      "duplicate": "不允許重複的值"
+    },
     "url": {
       "required": "必填",
       "invalid": "無效的 URL 格式",
@@ -68,6 +75,10 @@
       "finite": "必須為有限數字",
       "precision": "小數位數不可超過 ${precision} 位"
     },
+    "oneOf": {
+      "required": "必填",
+      "invalid": "必須為以下其中一個值：${values}"
+    },
     "id": {
       "required": "必填",
       "invalid": "無效的 ID 格式",
@@ -75,6 +86,14 @@
       "maxLength": "長度最多 ${maxLength} 字元",
       "numeric": "必須為數字 ID",
       "uuid": "必須為有效的 UUID",
+      "uuidv1": "必須為有效的 UUID v1",
+      "uuidv2": "必須為有效的 UUID v2",
+      "uuidv3": "必須為有效的 UUID v3",
+      "uuidv4": "必須為有效的 UUID v4",
+      "uuidv5": "必須為有效的 UUID v5",
+      "uuidv6": "必須為有效的 UUID v6",
+      "uuidv7": "必須為有效的 UUID v7",
+      "uuidv8": "必須為有效的 UUID v8",
       "objectId": "必須為有效的 MongoDB ObjectId",
       "nanoid": "必須為有效的 Nano ID",
       "snowflake": "必須為有效的 Snowflake ID",

package/src/index.ts

@@ -7,8 +7,10 @@ export * from "./validators/common/datetime"
 export * from "./validators/common/email"
 export * from "./validators/common/file"
 export * from "./validators/common/id"
+export * from "./validators/common/many-of"
 export * from "./validators/common/ip"
 export * from "./validators/common/number"
+export * from "./validators/common/one-of"
 export * from "./validators/common/password"
 export * from "./validators/common/text"
 export * from "./validators/common/time"

package/src/validators/common/id.ts

@@ -22,6 +22,14 @@ import { getLocale, type Locale } from "../../config"
  * @property {string} [maxLength] - Message when ID is too long
  * @property {string} [numeric] - Message when numeric ID format is invalid
  * @property {string} [uuid] - Message when UUID format is invalid
+ * @property {string} [uuidv1] - Message when UUID v1 format is invalid
+ * @property {string} [uuidv2] - Message when UUID v2 format is invalid
+ * @property {string} [uuidv3] - Message when UUID v3 format is invalid
+ * @property {string} [uuidv4] - Message when UUID v4 format is invalid
+ * @property {string} [uuidv5] - Message when UUID v5 format is invalid
+ * @property {string} [uuidv6] - Message when UUID v6 format is invalid
+ * @property {string} [uuidv7] - Message when UUID v7 format is invalid
+ * @property {string} [uuidv8] - Message when UUID v8 format is invalid
  * @property {string} [objectId] - Message when MongoDB ObjectId format is invalid
  * @property {string} [nanoid] - Message when Nano ID format is invalid
  * @property {string} [snowflake] - Message when Snowflake ID format is invalid
@@ -41,6 +49,14 @@ export type IdMessages = {
   maxLength?: string
   numeric?: string
   uuid?: string
+  uuidv1?: string
+  uuidv2?: string
+  uuidv3?: string
+  uuidv4?: string
+  uuidv5?: string
+  uuidv6?: string
+  uuidv7?: string
+  uuidv8?: string
   objectId?: string
   nanoid?: string
   snowflake?: string
@@ -61,7 +77,15 @@ export type IdMessages = {
  *
  * Available types:
  * - numeric: Pure numeric IDs (1, 123, 999999)
- * - uuid: UUID v4 format (xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx)
+ * - uuid: UUID any version (v1–v8)
+ * - uuidv1: UUID v1 (timestamp-based)
+ * - uuidv2: UUID v2 (DCE security)
+ * - uuidv3: UUID v3 (MD5 name-based)
+ * - uuidv4: UUID v4 (random)
+ * - uuidv5: UUID v5 (SHA-1 name-based)
+ * - uuidv6: UUID v6 (reordered timestamp, RFC 9562)
+ * - uuidv7: UUID v7 (Unix timestamp, sortable, RFC 9562)
+ * - uuidv8: UUID v8 (custom, RFC 9562)
  * - objectId: MongoDB ObjectId (24-character hexadecimal)
  * - nanoid: Nano ID format (21-character URL-safe)
  * - snowflake: Twitter Snowflake (19-digit number)
@@ -72,7 +96,15 @@ export type IdMessages = {
  */
 export type IdType =
   | "numeric" // Pure numeric IDs (1, 123, 999999)
-  | "uuid" // UUID v4 format
+  | "uuid" // UUID any version (v1–v8)
+  | "uuidv1" // UUID v1 (timestamp-based)
+  | "uuidv2" // UUID v2 (DCE security)
+  | "uuidv3" // UUID v3 (MD5 name-based)
+  | "uuidv4" // UUID v4 (random)
+  | "uuidv5" // UUID v5 (SHA-1 name-based)
+  | "uuidv6" // UUID v6 (reordered timestamp, RFC 9562)
+  | "uuidv7" // UUID v7 (Unix timestamp, sortable, RFC 9562)
+  | "uuidv8" // UUID v8 (custom, RFC 9562)
   | "objectId" // MongoDB ObjectId (24-character hexadecimal)
   | "nanoid" // Nano ID
   | "snowflake" // Twitter Snowflake (19-digit number)
@@ -143,9 +175,19 @@ export type IdSchema<IsRequired extends boolean, Type extends IdType | undefined
  * @constant {Record<string, RegExp>} ID_PATTERNS
  * @description Maps each ID type to its corresponding regex pattern
  */
+const UUID_BASE = (version: string) => new RegExp(`^[0-9a-f]{8}-[0-9a-f]{4}-${version}[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$`, "i")
+
 const ID_PATTERNS = {
   numeric: /^\d+$/,
-  uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+  uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+  uuidv1: UUID_BASE("1"),
+  uuidv2: UUID_BASE("2"),
+  uuidv3: UUID_BASE("3"),
+  uuidv4: UUID_BASE("4"),
+  uuidv5: UUID_BASE("5"),
+  uuidv6: UUID_BASE("6"),
+  uuidv7: UUID_BASE("7"),
+  uuidv8: UUID_BASE("8"),
   objectId: /^[0-9a-f]{24}$/i,
   nanoid: /^[A-Za-z0-9_-]{21}$/,
   snowflake: /^\d{19}$/,

package/src/validators/common/many-of.ts

@@ -0,0 +1,219 @@
+/**
+ * @fileoverview ManyOf validator for Zod Kit
+ *
+ * Provides multi-select validation that restricts input to an array of values
+ * from a predefined set, with min/max selection, duplicate control, and transformation.
+ *
+ * @author Ong Hoe Yuan
+ * @version 0.2.2
+ */
+
+import { z, ZodType } from "zod"
+import { t } from "../../i18n"
+import { getLocale, type Locale } from "../../config"
+
+/**
+ * Type definition for manyOf validation error messages
+ *
+ * @interface ManyOfMessages
+ * @property {string} [required] - Message when field is required but empty
+ * @property {string} [invalid] - Message when a value is not in the allowed list
+ * @property {string} [minSelect] - Message when fewer than minimum items are selected
+ * @property {string} [maxSelect] - Message when more than maximum items are selected
+ * @property {string} [duplicate] - Message when duplicate values are found
+ */
+export type ManyOfMessages = {
+  required?: string
+  invalid?: string
+  minSelect?: string
+  maxSelect?: string
+  duplicate?: string
+}
+
+/**
+ * Configuration options for manyOf validation
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ * @template T - The type of allowed values
+ *
+ * @interface ManyOfOptions
+ * @property {T[]} values - Array of allowed values
+ * @property {T[] | null} [defaultValue] - Default value when input is empty
+ * @property {number} [min] - Minimum number of selections
+ * @property {number} [max] - Maximum number of selections
+ * @property {boolean} [allowDuplicates=false] - Whether to allow duplicate selections
+ * @property {boolean} [caseSensitive=true] - Whether string matching is case-sensitive
+ * @property {Function} [transform] - Custom transformation function applied to each value
+ * @property {Record<Locale, ManyOfMessages>} [i18n] - Custom error messages for different locales
+ */
+export type ManyOfOptions<IsRequired extends boolean = true, T extends string | number = string | number> = {
+  values: T[]
+  defaultValue?: IsRequired extends true ? T[] : T[] | null
+  min?: number
+  max?: number
+  allowDuplicates?: boolean
+  caseSensitive?: boolean
+  transform?: (value: T[]) => T[]
+  i18n?: Partial<Record<Locale, Partial<ManyOfMessages>>>
+}
+
+/**
+ * Type alias for manyOf validation schema based on required flag
+ *
+ * @template IsRequired - Whether the field is required
+ * @template T - The type of allowed values
+ */
+export type ManyOfSchema<IsRequired extends boolean, T> = IsRequired extends true ? ZodType<T[]> : ZodType<T[] | null>
+
+/**
+ * Creates a Zod schema for multi-select validation that restricts values to a predefined set
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ * @template T - The type of allowed values (string | number)
+ * @param {IsRequired} [required=false] - Whether the field is required
+ * @param {ManyOfOptions<IsRequired, T>} options - Configuration options (values is required)
+ * @returns {ManyOfSchema<IsRequired, T>} Zod schema for manyOf validation
+ *
+ * @example
+ * ```typescript
+ * // Basic multi-select (optional by default)
+ * const tagsSchema = manyOf(false, { values: ["js", "ts", "rust", "go"] })
+ * tagsSchema.parse(["js", "ts"]) // ✓ ["js", "ts"]
+ * tagsSchema.parse(null)          // ✓ null
+ *
+ * // Required with min/max
+ * const skillsSchema = manyOf(true, {
+ *   values: ["react", "vue", "angular", "svelte"],
+ *   min: 1,
+ *   max: 3,
+ * })
+ * skillsSchema.parse(["react"])                        // ✓
+ * skillsSchema.parse([])                               // ✗ minSelect
+ * skillsSchema.parse(["react", "vue", "angular", "svelte"]) // ✗ maxSelect
+ *
+ * // Case-insensitive matching
+ * const colorsSchema = manyOf(true, {
+ *   values: ["red", "green", "blue"],
+ *   caseSensitive: false,
+ * })
+ * colorsSchema.parse(["RED", "Green"]) // ✓ ["red", "green"]
+ *
+ * // No duplicates (default)
+ * const rolesSchema = manyOf(true, { values: ["admin", "editor", "viewer"] })
+ * rolesSchema.parse(["admin", "admin"]) // ✗ duplicate
+ *
+ * // Allow duplicates
+ * const itemsSchema = manyOf(true, {
+ *   values: [1, 2, 3],
+ *   allowDuplicates: true,
+ * })
+ * itemsSchema.parse([1, 1, 2]) // ✓ [1, 1, 2]
+ * ```
+ */
+export function manyOf<IsRequired extends boolean = false, T extends string | number = string | number>(
+  required?: IsRequired,
+  options?: Omit<ManyOfOptions<IsRequired, T>, "required">,
+): ManyOfSchema<IsRequired, T> {
+  const { values = [] as unknown as T[], defaultValue = null, min, max, allowDuplicates = false, caseSensitive = true, transform, i18n } = options ?? {}
+
+  const isRequired = required ?? (false as IsRequired)
+
+  const getMessage = (key: keyof ManyOfMessages, params?: Record<string, any>) => {
+    if (i18n) {
+      const currentLocale = getLocale()
+      const customMessages = i18n[currentLocale]
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key]!
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "")
+      }
+    }
+    return t(`common.manyOf.${key}`, params)
+  }
+
+  const normalizeItem = (item: unknown): unknown => {
+    // Coerce number strings to numbers when values contains numbers
+    const hasNumbers = values.some((v) => typeof v === "number")
+    if (hasNumbers && typeof item === "string" && !isNaN(Number(item)) && item.trim() !== "") {
+      const numVal = Number(item)
+      if ((values as number[]).includes(numVal)) return numVal
+    }
+
+    // Case-insensitive normalization
+    if (!caseSensitive && typeof item === "string") {
+      const match = values.find((v) => typeof v === "string" && v.toLowerCase() === item.toLowerCase())
+      if (match !== undefined) return match
+      return item
+    }
+
+    return item
+  }
+
+  const preprocessFn = (val: unknown) => {
+    if (val === null || val === undefined || val === "") {
+      return defaultValue
+    }
+
+    if (!Array.isArray(val)) {
+      // Accept single value and wrap in array
+      return [normalizeItem(val)]
+    }
+
+    return val.map(normalizeItem)
+  }
+
+  const baseSchema = z.preprocess(preprocessFn, z.any())
+
+  const schema = baseSchema.superRefine((val, ctx) => {
+    if (val === null) {
+      if (isRequired) {
+        ctx.addIssue({ code: "custom", message: getMessage("required") })
+      }
+      return
+    }
+
+    if (!Array.isArray(val)) {
+      ctx.addIssue({ code: "custom", message: getMessage("invalid", { values: values.join(", ") }) })
+      return
+    }
+
+    // Check each item is in the allowed values
+    for (const item of val) {
+      if (!values.includes(item as T)) {
+        ctx.addIssue({
+          code: "custom",
+          message: getMessage("invalid", { values: values.join(", ") }),
+        })
+        return
+      }
+    }
+
+    // Duplicate check
+    if (!allowDuplicates) {
+      const seen = new Set()
+      for (const item of val) {
+        if (seen.has(item)) {
+          ctx.addIssue({ code: "custom", message: getMessage("duplicate") })
+          return
+        }
+        seen.add(item)
+      }
+    }
+
+    // Min/max selection count
+    if (min !== undefined && val.length < min) {
+      ctx.addIssue({ code: "custom", message: getMessage("minSelect", { min }) })
+      return
+    }
+
+    if (max !== undefined && val.length > max) {
+      ctx.addIssue({ code: "custom", message: getMessage("maxSelect", { max }) })
+      return
+    }
+  })
+  .transform((val) => {
+    if (val === null || !Array.isArray(val) || !transform) return val
+    return transform(val as T[])
+  })
+
+  return schema as unknown as ManyOfSchema<IsRequired, T>
+}