@hy_ong/zod-kit 0.0.4 → 0.0.6

package/dist/index.js

@@ -1,4 +1,4 @@
-// src/common/boolean.ts
+// src/validators/common/boolean.ts
 import { z } from "zod";
 
 // src/i18n/locales/zh-TW.json
@@ -6,25 +6,40 @@ var zh_TW_default = {
   common: {
     boolean: {
       required: "\u5FC5\u586B",
-      shouldBe: {
-        true: "\u5FC5\u9808\u70BA\u662F",
-        false: "\u5FC5\u9808\u70BA\u5426"
-      }
+      shouldBeTrue: "\u5FC5\u9808\u70BA\u662F",
+      shouldBeFalse: "\u5FC5\u9808\u70BA\u5426",
+      invalid: "\u5FC5\u9808\u70BA\u5E03\u6797\u503C"
     },
     email: {
       required: "\u5FC5\u586B",
-      min: "\u9577\u5EA6\u81F3\u5C11 ${min} \u5B57\u5143",
-      max: "\u9577\u5EA6\u6700\u591A ${max} \u5B57\u5143",
+      invalid: "\u96FB\u5B50\u90F5\u4EF6\u683C\u5F0F\u932F\u8AA4",
+      minLength: "\u9577\u5EA6\u81F3\u5C11 ${minLength} \u5B57\u5143",
+      maxLength: "\u9577\u5EA6\u6700\u591A ${maxLength} \u5B57\u5143",
       includes: "\u5FC5\u9808\u5305\u542B\u300C${includes}\u300D",
-      invalid: "\u683C\u5F0F\u932F\u8AA4",
-      domain: "\u5FC5\u9808\u70BA @${domain} \u7DB2\u57DF"
+      domain: "\u5FC5\u9808\u70BA ${domain} \u7DB2\u57DF",
+      domainBlacklist: "\u4E0D\u5141\u8A31\u4F7F\u7528 ${domain} \u7DB2\u57DF",
+      businessOnly: "\u50C5\u5141\u8A31\u4F01\u696D\u90F5\u7BB1\u5730\u5740",
+      noDisposable: "\u4E0D\u5141\u8A31\u4F7F\u7528\u81E8\u6642\u90F5\u7BB1\u5730\u5740"
     },
     url: {
       required: "\u5FC5\u586B",
+      invalid: "\u7121\u6548\u7684 URL \u683C\u5F0F",
       min: "\u9577\u5EA6\u81F3\u5C11 ${min} \u5B57\u5143",
       max: "\u9577\u5EA6\u6700\u591A ${max} \u5B57\u5143",
       includes: "\u5FC5\u9808\u5305\u542B\u300C${includes}\u300D",
-      invalid: "\u683C\u5F0F\u932F\u8AA4"
+      excludes: "\u4E0D\u5F97\u5305\u542B\u300C${excludes}\u300D",
+      protocol: "\u5354\u8B70\u5FC5\u9808\u70BA\uFF1A${protocols}",
+      domain: "\u7DB2\u57DF\u5FC5\u9808\u70BA\uFF1A${domains}",
+      domainBlacklist: "\u4E0D\u5141\u8A31\u4F7F\u7528\u7DB2\u57DF ${domain}",
+      port: "\u9023\u63A5\u57E0\u5FC5\u9808\u70BA\uFF1A${ports}",
+      pathStartsWith: "\u8DEF\u5F91\u5FC5\u9808\u4EE5\u300C${path}\u300D\u958B\u982D",
+      pathEndsWith: "\u8DEF\u5F91\u5FC5\u9808\u4EE5\u300C${path}\u300D\u7D50\u5C3E",
+      hasQuery: "URL \u5FC5\u9808\u5305\u542B\u67E5\u8A62\u53C3\u6578",
+      noQuery: "URL \u4E0D\u5F97\u5305\u542B\u67E5\u8A62\u53C3\u6578",
+      hasFragment: "URL \u5FC5\u9808\u5305\u542B\u9328\u9EDE",
+      noFragment: "URL \u4E0D\u5F97\u5305\u542B\u9328\u9EDE",
+      localhost: "\u4E0D\u5141\u8A31\u4F7F\u7528\u672C\u6A5F URL",
+      noLocalhost: "\u4E0D\u5141\u8A31\u4F7F\u7528\u672C\u6A5F URL"
     },
     password: {
       required: "\u5FC5\u586B",
@@ -33,37 +48,161 @@ var zh_TW_default = {
       uppercase: "\u5FC5\u9808\u5305\u542B\u81F3\u5C11\u4E00\u500B\u5927\u5BEB\u5B57\u6BCD",
       lowercase: "\u5FC5\u9808\u5305\u542B\u81F3\u5C11\u4E00\u500B\u5C0F\u5BEB\u5B57\u6BCD",
       digits: "\u5FC5\u9808\u5305\u542B\u81F3\u5C11\u4E00\u500B\u6578\u5B57",
-      special: "\u5FC5\u9808\u5305\u542B\u81F3\u5C11\u4E00\u500B\u7279\u6B8A\u7B26\u865F"
+      special: "\u5FC5\u9808\u5305\u542B\u81F3\u5C11\u4E00\u500B\u7279\u6B8A\u7B26\u865F",
+      noRepeating: "\u4E0D\u53EF\u5305\u542B\u91CD\u8907\u5B57\u5143",
+      noSequential: "\u4E0D\u53EF\u5305\u542B\u9023\u7E8C\u5B57\u5143",
+      noCommonWords: "\u4E0D\u53EF\u5305\u542B\u5E38\u898B\u5BC6\u78BC\u6216\u6A21\u5F0F",
+      minStrength: "\u5BC6\u78BC\u5F37\u5EA6\u5FC5\u9808\u81F3\u5C11\u70BA ${minStrength}",
+      excludes: "\u4E0D\u5F97\u5305\u542B\u300C${excludes}\u300D",
+      includes: "\u5FC5\u9808\u5305\u542B\u300C${includes}\u300D",
+      invalid: "\u5BC6\u78BC\u683C\u5F0F\u932F\u8AA4"
     },
     number: {
       required: "\u5FC5\u586B",
-      min: "\u6700\u5C0F\u503C ${min}",
-      max: "\u6700\u5927\u503C ${max}"
-    },
-    id: {
-      required: "\u8ACB\u9078\u64C7",
-      invalid: "\u7121\u6548"
-    },
-    integer: {
-      required: "\u5FC5\u586B",
+      invalid: "\u5FC5\u9808\u70BA\u6709\u6548\u6578\u5B57",
+      integer: "\u5FC5\u9808\u70BA\u6574\u6578",
+      float: "\u5FC5\u9808\u70BA\u5C0F\u6578",
       min: "\u6700\u5C0F\u503C ${min}",
       max: "\u6700\u5927\u503C ${max}",
-      integer: "\u5FC5\u9808\u70BA\u6574\u6578"
+      positive: "\u5FC5\u9808\u70BA\u6B63\u6578",
+      negative: "\u5FC5\u9808\u70BA\u8CA0\u6578",
+      nonNegative: "\u4E0D\u53EF\u70BA\u8CA0\u6578",
+      nonPositive: "\u4E0D\u53EF\u70BA\u6B63\u6578",
+      multipleOf: "\u5FC5\u9808\u70BA ${multipleOf} \u7684\u500D\u6578",
+      finite: "\u5FC5\u9808\u70BA\u6709\u9650\u6578\u5B57",
+      precision: "\u5C0F\u6578\u4F4D\u6578\u4E0D\u53EF\u8D85\u904E ${precision} \u4F4D"
     },
-    float: {
+    id: {
       required: "\u5FC5\u586B",
-      float: "\u5FC5\u9808\u70BA\u6D6E\u9EDE\u6578",
-      min: "\u6700\u5C0F\u503C ${min}",
-      max: "\u6700\u5927\u503C ${max}"
+      invalid: "\u7121\u6548\u7684 ID \u683C\u5F0F",
+      minLength: "\u9577\u5EA6\u81F3\u5C11 ${minLength} \u5B57\u5143",
+      maxLength: "\u9577\u5EA6\u6700\u591A ${maxLength} \u5B57\u5143",
+      numeric: "\u5FC5\u9808\u70BA\u6578\u5B57 ID",
+      uuid: "\u5FC5\u9808\u70BA\u6709\u6548\u7684 UUID",
+      objectId: "\u5FC5\u9808\u70BA\u6709\u6548\u7684 MongoDB ObjectId",
+      nanoid: "\u5FC5\u9808\u70BA\u6709\u6548\u7684 Nano ID",
+      snowflake: "\u5FC5\u9808\u70BA\u6709\u6548\u7684 Snowflake ID",
+      cuid: "\u5FC5\u9808\u70BA\u6709\u6548\u7684 CUID",
+      ulid: "\u5FC5\u9808\u70BA\u6709\u6548\u7684 ULID",
+      shortid: "\u5FC5\u9808\u70BA\u6709\u6548\u7684 Short ID",
+      customFormat: "\u7121\u6548\u7684 ID \u683C\u5F0F",
+      includes: "\u5FC5\u9808\u5305\u542B\u300C${includes}\u300D",
+      excludes: "\u4E0D\u5F97\u5305\u542B\u300C${excludes}\u300D",
+      startsWith: "\u5FC5\u9808\u4EE5\u300C${startsWith}\u300D\u958B\u982D",
+      endsWith: "\u5FC5\u9808\u4EE5\u300C${endsWith}\u300D\u7D50\u5C3E"
     },
     text: {
       required: "\u5FC5\u586B",
-      min: "\u9577\u5EA6\u81F3\u5C11 ${min} \u5B57\u5143",
-      max: "\u9577\u5EA6\u6700\u591A ${max} \u5B57\u5143",
+      notEmpty: "\u4E0D\u53EF\u70BA\u7A7A\u767D\u6216\u50C5\u542B\u7A7A\u683C",
+      minLength: "\u9577\u5EA6\u81F3\u5C11 ${minLength} \u5B57\u5143",
+      maxLength: "\u9577\u5EA6\u6700\u591A ${maxLength} \u5B57\u5143",
       startsWith: "\u5FC5\u9808\u4EE5\u300C${startsWith}\u300D\u958B\u982D",
       endsWith: "\u5FC5\u9808\u4EE5\u300C${endsWith}\u300D\u7D50\u5C3E",
       includes: "\u5FC5\u9808\u5305\u542B\u300C${includes}\u300D",
+      excludes: "\u4E0D\u5F97\u5305\u542B\u300C${excludes}\u300D",
       invalid: "\u683C\u5F0F\u932F\u8AA4"
+    },
+    date: {
+      required: "\u5FC5\u586B",
+      invalid: "\u7121\u6548\u65E5\u671F",
+      format: "\u5FC5\u9808\u70BA ${format} \u683C\u5F0F",
+      min: "\u65E5\u671F\u4E0D\u5F97\u65E9\u65BC ${min}",
+      max: "\u65E5\u671F\u4E0D\u5F97\u665A\u65BC ${max}",
+      includes: "\u5FC5\u9808\u5305\u542B\u300C${includes}\u300D",
+      excludes: "\u4E0D\u5F97\u5305\u542B\u300C${excludes}\u300D",
+      past: "\u5FC5\u9808\u70BA\u904E\u53BB\u7684\u65E5\u671F",
+      future: "\u5FC5\u9808\u70BA\u672A\u4F86\u7684\u65E5\u671F",
+      today: "\u5FC5\u9808\u70BA\u4ECA\u5929",
+      notToday: "\u4E0D\u5F97\u70BA\u4ECA\u5929",
+      weekday: "\u5FC5\u9808\u70BA\u5DE5\u4F5C\u65E5\uFF08\u9031\u4E00\u81F3\u9031\u4E94\uFF09",
+      weekend: "\u5FC5\u9808\u70BA\u9031\u672B\uFF08\u9031\u516D\u81F3\u9031\u65E5\uFF09"
+    },
+    time: {
+      required: "\u5FC5\u586B",
+      invalid: "\u7121\u6548\u7684\u6642\u9593\u683C\u5F0F",
+      format: "\u5FC5\u9808\u70BA ${format} \u683C\u5F0F",
+      min: "\u6642\u9593\u4E0D\u5F97\u65E9\u65BC ${min}",
+      max: "\u6642\u9593\u4E0D\u5F97\u665A\u65BC ${max}",
+      hour: "\u5C0F\u6642\u5FC5\u9808\u4ECB\u65BC ${minHour} \u8207 ${maxHour} \u4E4B\u9593",
+      minute: "\u5206\u9418\u5FC5\u9808\u70BA ${minuteStep} \u5206\u9418\u9593\u9694",
+      second: "\u79D2\u6578\u5FC5\u9808\u70BA ${secondStep} \u79D2\u9593\u9694",
+      includes: "\u5FC5\u9808\u5305\u542B\u300C${includes}\u300D",
+      excludes: "\u4E0D\u5F97\u5305\u542B\u300C${excludes}\u300D",
+      customRegex: "\u7121\u6548\u7684\u6642\u9593\u683C\u5F0F",
+      notInWhitelist: "\u6642\u9593\u4E0D\u5728\u5141\u8A31\u6E05\u55AE\u4E2D"
+    },
+    datetime: {
+      required: "\u5FC5\u586B",
+      invalid: "\u7121\u6548\u7684\u65E5\u671F\u6642\u9593\u683C\u5F0F",
+      format: "\u5FC5\u9808\u70BA ${format} \u683C\u5F0F",
+      min: "\u65E5\u671F\u6642\u9593\u4E0D\u5F97\u65E9\u65BC ${min}",
+      max: "\u65E5\u671F\u6642\u9593\u4E0D\u5F97\u665A\u65BC ${max}",
+      hour: "\u5C0F\u6642\u5FC5\u9808\u4ECB\u65BC ${minHour} \u8207 ${maxHour} \u4E4B\u9593",
+      minute: "\u5206\u9418\u5FC5\u9808\u70BA ${minuteStep} \u5206\u9418\u9593\u9694",
+      includes: "\u5FC5\u9808\u5305\u542B\u300C${includes}\u300D",
+      excludes: "\u4E0D\u5F97\u5305\u542B\u300C${excludes}\u300D",
+      past: "\u5FC5\u9808\u70BA\u904E\u53BB\u7684\u65E5\u671F\u6642\u9593",
+      future: "\u5FC5\u9808\u70BA\u672A\u4F86\u7684\u65E5\u671F\u6642\u9593",
+      today: "\u5FC5\u9808\u70BA\u4ECA\u5929",
+      notToday: "\u4E0D\u5F97\u70BA\u4ECA\u5929",
+      weekday: "\u5FC5\u9808\u70BA\u5DE5\u4F5C\u65E5\uFF08\u9031\u4E00\u81F3\u9031\u4E94\uFF09",
+      weekend: "\u5FC5\u9808\u70BA\u9031\u672B\uFF08\u9031\u516D\u81F3\u9031\u65E5\uFF09",
+      customRegex: "\u7121\u6548\u7684\u65E5\u671F\u6642\u9593\u683C\u5F0F",
+      notInWhitelist: "\u65E5\u671F\u6642\u9593\u4E0D\u5728\u5141\u8A31\u6E05\u55AE\u4E2D"
+    },
+    file: {
+      required: "\u5FC5\u586B",
+      invalid: "\u7121\u6548\u7684\u6A94\u6848\u683C\u5F0F",
+      size: "\u6A94\u6848\u5927\u5C0F\u4E0D\u5F97\u8D85\u904E ${size}",
+      minSize: "\u6A94\u6848\u5927\u5C0F\u81F3\u5C11 ${minSize}",
+      maxSize: "\u6A94\u6848\u5927\u5C0F\u4E0D\u5F97\u8D85\u904E ${maxSize}",
+      type: "\u6A94\u6848\u985E\u578B\u5FC5\u9808\u70BA\uFF1A${type}",
+      extension: "\u526F\u6A94\u540D\u5FC5\u9808\u70BA\uFF1A${extension}",
+      extensionBlacklist: "\u4E0D\u5141\u8A31\u4F7F\u7528\u526F\u6A94\u540D ${extension}",
+      name: "\u6A94\u6848\u540D\u7A31\u5FC5\u9808\u7B26\u5408\u683C\u5F0F ${pattern}",
+      nameBlacklist: "\u6A94\u6848\u540D\u7A31\u4E0D\u5F97\u7B26\u5408\u683C\u5F0F ${pattern}",
+      imageOnly: "\u50C5\u5141\u8A31\u5716\u7247\u6A94\u6848",
+      documentOnly: "\u50C5\u5141\u8A31\u6587\u4EF6\u6A94\u6848",
+      videoOnly: "\u50C5\u5141\u8A31\u5F71\u7247\u6A94\u6848",
+      audioOnly: "\u50C5\u5141\u8A31\u97F3\u8A0A\u6A94\u6848",
+      archiveOnly: "\u50C5\u5141\u8A31\u58D3\u7E2E\u6A94\u6848"
+    }
+  },
+  taiwan: {
+    businessId: {
+      required: "\u5FC5\u586B",
+      invalid: "\u7121\u6548\u7684\u7D71\u4E00\u7DE8\u865F"
+    },
+    nationalId: {
+      required: "\u5FC5\u586B",
+      invalid: "\u7121\u6548\u7684\u8EAB\u5206\u8B49\u5B57\u865F"
+    },
+    mobile: {
+      required: "\u5FC5\u586B",
+      invalid: "\u7121\u6548\u7684\u624B\u6A5F\u865F\u78BC\u683C\u5F0F",
+      notInWhitelist: "\u4E0D\u5728\u5141\u8A31\u7684\u624B\u6A5F\u865F\u78BC\u6E05\u55AE\u4E2D"
+    },
+    tel: {
+      required: "\u5FC5\u586B",
+      invalid: "\u7121\u6548\u7684\u5E02\u8A71\u865F\u78BC\u683C\u5F0F",
+      notInWhitelist: "\u4E0D\u5728\u5141\u8A31\u7684\u5E02\u8A71\u865F\u78BC\u6E05\u55AE\u4E2D"
+    },
+    fax: {
+      required: "\u5FC5\u586B",
+      invalid: "\u7121\u6548\u7684\u50B3\u771F\u865F\u78BC\u683C\u5F0F",
+      notInWhitelist: "\u4E0D\u5728\u5141\u8A31\u7684\u50B3\u771F\u865F\u78BC\u6E05\u55AE\u4E2D"
+    },
+    postalCode: {
+      required: "\u5FC5\u586B",
+      invalid: "\u7121\u6548\u7684\u90F5\u905E\u5340\u865F",
+      invalidFormat: "\u90F5\u905E\u5340\u865F\u683C\u5F0F\u932F\u8AA4",
+      invalidRange: "\u90F5\u905E\u5340\u865F\u8D85\u51FA\u6709\u6548\u7BC4\u570D",
+      legacy5DigitWarning: "5 \u78BC\u90F5\u905E\u5340\u865F\u70BA\u820A\u5F0F\u683C\u5F0F\uFF0C\u5EFA\u8B70\u4F7F\u7528 6 \u78BC\u683C\u5F0F",
+      format3Only: "\u50C5\u5141\u8A31 3 \u78BC\u90F5\u905E\u5340\u865F",
+      format5Only: "\u50C5\u5141\u8A31 5 \u78BC\u90F5\u905E\u5340\u865F",
+      format6Only: "\u50C5\u5141\u8A31 6 \u78BC\u90F5\u905E\u5340\u865F",
+      invalidSuffix: "\u7121\u6548\u7684\u90F5\u905E\u5340\u865F\u5F8C\u78BC - 5 \u78BC\u683C\u5F0F\u9808\u70BA 01-99\uFF0C6 \u78BC\u683C\u5F0F\u9808\u70BA 001-999",
+      deprecated5Digit: "5 \u78BC\u90F5\u905E\u5340\u865F\u5DF2\u68C4\u7528\u4E14\u4E0D\u518D\u652F\u63F4"
     }
   }
 };
@@ -73,25 +212,40 @@ var en_default = {
   common: {
     boolean: {
       required: "Required",
-      shouldBe: {
-        true: "Must be True",
-        false: "Must be False"
-      }
+      shouldBeTrue: "Must be True",
+      shouldBeFalse: "Must be False",
+      invalid: "Must be a boolean value"
     },
     email: {
       required: "Required",
-      min: "Must be at least ${min} characters",
-      max: "Must be at most ${max} characters",
+      invalid: "Invalid email format",
+      minLength: "Must be at least ${minLength} characters",
+      maxLength: "Must be at most ${maxLength} characters",
       includes: "Must include ${includes}",
-      invalid: "Invalid format",
-      domain: "Must be under the domain @${domain}"
+      domain: "Must be from domain: ${domain}",
+      domainBlacklist: "Domain ${domain} is not allowed",
+      businessOnly: "Only business email addresses are allowed",
+      noDisposable: "Disposable email addresses are not allowed"
     },
     url: {
       required: "Required",
+      invalid: "Invalid URL format",
       min: "Must be at least ${min} characters",
       max: "Must be at most ${max} characters",
       includes: "Must include ${includes}",
-      invalid: "Invalid format"
+      excludes: "Must not contain ${excludes}",
+      protocol: "Protocol must be one of: ${protocols}",
+      domain: "Domain must be one of: ${domains}",
+      domainBlacklist: "Domain ${domain} is not allowed",
+      port: "Port must be one of: ${ports}",
+      pathStartsWith: "Path must start with ${path}",
+      pathEndsWith: "Path must end with ${path}",
+      hasQuery: "URL must have query parameters",
+      noQuery: "URL must not have query parameters",
+      hasFragment: "URL must have a fragment",
+      noFragment: "URL must not have a fragment",
+      localhost: "Localhost URLs are not allowed",
+      noLocalhost: "Localhost URLs are not allowed"
     },
     password: {
       required: "Required",
@@ -100,46 +254,167 @@ var en_default = {
       uppercase: "Must include at least one uppercase letter",
       lowercase: "Must include at least one lowercase letter",
       digits: "Must include at least one digit",
-      special: "Must include at least one special character"
+      special: "Must include at least one special character",
+      noRepeating: "Must not contain repeating characters",
+      noSequential: "Must not contain sequential characters",
+      noCommonWords: "Must not contain common words or patterns",
+      minStrength: "Password strength must be at least ${minStrength}",
+      excludes: "Must not contain ${excludes}",
+      includes: "Must include ${includes}",
+      invalid: "Invalid password format"
     },
     number: {
       required: "Required",
-      min: "Must be at least ${min}",
-      max: "Must be at most ${max}"
-    },
-    integer: {
-      required: "Required",
+      invalid: "Must be a valid number",
+      integer: "Must be an integer",
+      float: "Must be a decimal number",
       min: "Must be at least ${min}",
       max: "Must be at most ${max}",
-      integer: "Must be an integer"
+      positive: "Must be positive",
+      negative: "Must be negative",
+      nonNegative: "Must be non-negative",
+      nonPositive: "Must be non-positive",
+      multipleOf: "Must be a multiple of ${multipleOf}",
+      finite: "Must be a finite number",
+      precision: "Must have at most ${precision} decimal places"
     },
-    float: {
+    id: {
       required: "Required",
-      min: "Must be at least ${min}",
-      max: "Must be at most ${max}",
-      float: "Must be an float"
+      invalid: "Invalid ID format",
+      minLength: "Must be at least ${minLength} characters",
+      maxLength: "Must be at most ${maxLength} characters",
+      numeric: "Must be a numeric ID",
+      uuid: "Must be a valid UUID",
+      objectId: "Must be a valid MongoDB ObjectId",
+      nanoid: "Must be a valid Nano ID",
+      snowflake: "Must be a valid Snowflake ID",
+      cuid: "Must be a valid CUID",
+      ulid: "Must be a valid ULID",
+      shortid: "Must be a valid Short ID",
+      customFormat: "Invalid ID format",
+      includes: "Must include ${includes}",
+      excludes: "Must not contain ${excludes}",
+      startsWith: "Must start with ${startsWith}",
+      endsWith: "Must end with ${endsWith}"
     },
     text: {
       required: "Required",
-      min: "Must be at least ${min} characters",
-      max: "Must be at most ${max} characters",
+      notEmpty: "Cannot be empty or whitespace only",
+      minLength: "Must be at least ${minLength} characters",
+      maxLength: "Must be at most ${maxLength} characters",
       startsWith: "Must start with ${startsWith}",
       endsWith: "Must end with ${endsWith}",
       includes: "Must include ${includes}",
+      excludes: "Must not contain ${excludes}",
       invalid: "Invalid format"
     },
     date: {
       required: "Required",
-      min: "Must be at least ${min} characters",
-      max: "Must be at most ${max} characters",
+      invalid: "Invalid date",
+      format: "Must be in ${format} format",
+      min: "Date must be on or after ${min}",
+      max: "Date must be on or before ${max}",
+      includes: "Must include ${includes}",
+      excludes: "Must not contain ${excludes}",
+      past: "Date must be in the past",
+      future: "Date must be in the future",
+      today: "Date must be today",
+      notToday: "Date must not be today",
+      weekday: "Date must be a weekday (Monday-Friday)",
+      weekend: "Date must be a weekend (Saturday-Sunday)"
+    },
+    time: {
+      required: "Required",
+      invalid: "Invalid time format",
+      format: "Must be in ${format} format",
+      min: "Time must be after ${min}",
+      max: "Time must be before ${max}",
+      hour: "Hour must be between ${minHour} and ${maxHour}",
+      minute: "Minutes must be in ${minuteStep}-minute intervals",
+      second: "Seconds must be in ${secondStep}-second intervals",
       includes: "Must include ${includes}",
-      format: "Must be in ${format} format"
+      excludes: "Must not contain ${excludes}",
+      customRegex: "Invalid time format",
+      notInWhitelist: "Time is not in the allowed list"
+    },
+    datetime: {
+      required: "Required",
+      invalid: "Invalid datetime format",
+      format: "Must be in ${format} format",
+      min: "DateTime must be after ${min}",
+      max: "DateTime must be before ${max}",
+      hour: "Hour must be between ${minHour} and ${maxHour}",
+      minute: "Minutes must be in ${minuteStep}-minute intervals",
+      includes: "Must include ${includes}",
+      excludes: "Must not contain ${excludes}",
+      past: "DateTime must be in the past",
+      future: "DateTime must be in the future",
+      today: "DateTime must be today",
+      notToday: "DateTime must not be today",
+      weekday: "DateTime must be a weekday (Monday-Friday)",
+      weekend: "DateTime must be a weekend (Saturday-Sunday)",
+      customRegex: "Invalid datetime format",
+      notInWhitelist: "DateTime is not in the allowed list"
+    },
+    file: {
+      required: "Required",
+      invalid: "Invalid file format",
+      size: "File size must not exceed ${size}",
+      minSize: "File size must be at least ${minSize}",
+      maxSize: "File size must not exceed ${maxSize}",
+      type: "File type must be one of: ${type}",
+      extension: "File extension must be one of: ${extension}",
+      extensionBlacklist: "File extension ${extension} is not allowed",
+      name: "File name must match pattern ${pattern}",
+      nameBlacklist: "File name must not match pattern ${pattern}",
+      imageOnly: "Only image files are allowed",
+      documentOnly: "Only document files are allowed",
+      videoOnly: "Only video files are allowed",
+      audioOnly: "Only audio files are allowed",
+      archiveOnly: "Only archive files are allowed"
+    }
+  },
+  taiwan: {
+    businessId: {
+      required: "Required",
+      invalid: "Invalid Taiwan Business ID"
+    },
+    nationalId: {
+      required: "Required",
+      invalid: "Invalid Taiwan National ID"
+    },
+    mobile: {
+      required: "Required",
+      invalid: "Invalid Taiwan mobile phone format",
+      notInWhitelist: "Not in allowed mobile phone list"
+    },
+    tel: {
+      required: "Required",
+      invalid: "Invalid Taiwan telephone format",
+      notInWhitelist: "Not in allowed telephone list"
+    },
+    fax: {
+      required: "Required",
+      invalid: "Invalid Taiwan fax format",
+      notInWhitelist: "Not in allowed fax list"
+    },
+    postalCode: {
+      required: "Required",
+      invalid: "Invalid Taiwan postal code",
+      invalidFormat: "Invalid postal code format",
+      invalidRange: "Postal code is outside valid range",
+      legacy5DigitWarning: "5-digit postal codes are legacy format, consider using 6-digit format",
+      format3Only: "Only 3-digit postal codes are allowed",
+      format5Only: "Only 5-digit postal codes are allowed",
+      format6Only: "Only 6-digit postal codes are allowed",
+      invalidSuffix: "Invalid postal code suffix - must be 01-99 for 5-digit or 001-999 for 6-digit codes",
+      deprecated5Digit: "5-digit postal codes are deprecated and no longer supported"
     }
   }
 };
 
 // src/config.ts
-var currentLocale = "zh-TW";
+var currentLocale = "en";
 var setLocale = (locale) => {
   currentLocale = locale;
 };
@@ -161,148 +436,2810 @@ function getNestedValue(obj, path) {
   return typeof result === "string" ? result : void 0;
 }
 
-// src/common/boolean.ts
+// src/validators/common/boolean.ts
 function boolean(options) {
-  const { required = true, defaultValue = null, shouldBe } = options ?? {};
+  const {
+    required = true,
+    defaultValue = null,
+    shouldBe,
+    truthyValues = [true, "true", 1, "1", "yes", "on"],
+    falsyValues = [false, "false", 0, "0", "no", "off"],
+    strict = false,
+    transform,
+    i18n
+  } = options ?? {};
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale2 = getLocale();
+      const customMessages = i18n[currentLocale2];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`common.boolean.${key}`, params);
+  };
   let result = z.preprocess(
     (val) => {
       if (val === "" || val === void 0 || val === null) return defaultValue;
-      if (val === "true" || val === 1 || val === "1") return true;
-      if (val === "false" || val === 0 || val === "0") return false;
+      if (strict && typeof val !== "boolean" && val !== null) {
+        return val;
+      }
+      if (truthyValues.includes(val)) {
+        let processed = true;
+        if (transform) processed = transform(processed);
+        return processed;
+      }
+      if (falsyValues.includes(val)) {
+        let processed = false;
+        if (transform) processed = transform(processed);
+        return processed;
+      }
       return val;
     },
     z.union([z.literal(true), z.literal(false), z.literal(null)])
   );
   if (required && defaultValue === null) {
-    result = result.refine((val) => val !== null, { message: t("common.boolean.required") });
+    result = result.refine((val) => val !== null, { message: getMessage("required") });
   }
   if (shouldBe === true) {
-    result = result.refine((val) => val === true, { message: t("common.boolean.shouldBe.true") });
+    result = result.refine((val) => val === true, { message: getMessage("shouldBeTrue") });
   } else if (shouldBe === false) {
-    result = result.refine((val) => val === false, { message: t("common.boolean.shouldBe.false") });
+    result = result.refine((val) => val === false, { message: getMessage("shouldBeFalse") });
+  }
+  if (strict) {
+    result = result.refine(
+      (val) => {
+        return val === null || typeof val === "boolean";
+      },
+      { message: getMessage("invalid") }
+    );
   }
   return result;
 }
 
-// src/common/email.ts
+// src/validators/common/date.ts
 import { z as z2 } from "zod";
-function email(options) {
-  const { required = true, domain, min, max, includes } = options ?? {};
-  const baseSchema = required ? z2.preprocess(
-    (val) => val === "" || val === null || val === void 0 ? null : val,
-    z2.email({
-      error: (issue) => {
-        if (issue.code === "invalid_type") return t("common.email.required");
-        else if (issue.code === "invalid_format") return t("common.email.invalid");
-        return t("common.email.invalid");
-      }
-    })
-  ) : z2.preprocess((val) => val === "" || val === null || val === void 0 ? null : val, z2.email({ message: t("common.email.invalid") }).nullable());
-  const schema = baseSchema.refine((val) => required ? val !== "" && val !== "null" && val !== "undefined" : true, { message: t("common.text.required") }).refine((val) => val === null || min === void 0 || val.length >= min, { message: t("common.text.min", { min }) }).refine((val) => val === null || max === void 0 || val.length <= max, { message: t("common.text.max", { max }) }).refine((val) => val === null || includes === void 0 || val.includes(includes), { message: t("common.text.includes", { includes }) }).refine(
-    (val) => {
-      if (val === null || domain === void 0) return true;
-      return val.split("@")[1]?.toLowerCase() === domain.toLowerCase();
-    },
-    { message: t("common.email.domain", { domain }) }
-  );
+import dayjs from "dayjs";
+import customParseFormat from "dayjs/plugin/customParseFormat";
+import isSameOrAfter from "dayjs/plugin/isSameOrAfter";
+import isSameOrBefore from "dayjs/plugin/isSameOrBefore";
+import isToday from "dayjs/plugin/isToday";
+import weekday from "dayjs/plugin/weekday";
+dayjs.extend(isSameOrAfter);
+dayjs.extend(isSameOrBefore);
+dayjs.extend(customParseFormat);
+dayjs.extend(isToday);
+dayjs.extend(weekday);
+function date(options) {
+  const {
+    required = true,
+    min,
+    max,
+    format = "YYYY-MM-DD",
+    includes,
+    excludes,
+    mustBePast,
+    mustBeFuture,
+    mustBeToday,
+    mustNotBeToday,
+    weekdaysOnly,
+    weekendsOnly,
+    transform,
+    defaultValue = null,
+    i18n
+  } = options ?? {};
+  const actualDefaultValue = defaultValue ?? (required ? "" : null);
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale2 = getLocale();
+      const customMessages = i18n[currentLocale2];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`common.date.${key}`, params);
+  };
+  const preprocessFn = (val) => {
+    if (val === "" || val === null || val === void 0) {
+      return actualDefaultValue;
+    }
+    let processed = String(val).trim();
+    if (transform) {
+      processed = transform(processed);
+    }
+    return processed;
+  };
+  const baseSchema = required ? z2.preprocess(preprocessFn, z2.string()) : z2.preprocess(preprocessFn, z2.string().nullable());
+  const schema = baseSchema.refine((val) => {
+    if (val === null) return true;
+    if (required && (val === "" || val === "null" || val === "undefined")) {
+      throw new z2.ZodError([{ code: "custom", message: getMessage("required"), path: [] }]);
+    }
+    if (val !== null && !dayjs(val, format, true).isValid()) {
+      throw new z2.ZodError([{ code: "custom", message: getMessage("format", { format }), path: [] }]);
+    }
+    const dateObj = dayjs(val, format);
+    if (val !== null && min !== void 0 && !dateObj.isSameOrAfter(dayjs(min, format))) {
+      throw new z2.ZodError([{ code: "custom", message: getMessage("min", { min }), path: [] }]);
+    }
+    if (val !== null && max !== void 0 && !dateObj.isSameOrBefore(dayjs(max, format))) {
+      throw new z2.ZodError([{ code: "custom", message: getMessage("max", { max }), path: [] }]);
+    }
+    if (val !== null && includes !== void 0 && !val.includes(includes)) {
+      throw new z2.ZodError([{ code: "custom", message: getMessage("includes", { includes }), path: [] }]);
+    }
+    if (val !== null && excludes !== void 0) {
+      const excludeList = Array.isArray(excludes) ? excludes : [excludes];
+      for (const exclude of excludeList) {
+        if (val.includes(exclude)) {
+          throw new z2.ZodError([{ code: "custom", message: getMessage("excludes", { excludes: exclude }), path: [] }]);
+        }
+      }
+    }
+    const today = dayjs().startOf("day");
+    const targetDate = dateObj.startOf("day");
+    if (val !== null && mustBePast && !targetDate.isBefore(today)) {
+      throw new z2.ZodError([{ code: "custom", message: getMessage("past"), path: [] }]);
+    }
+    if (val !== null && mustBeFuture && !targetDate.isAfter(today)) {
+      throw new z2.ZodError([{ code: "custom", message: getMessage("future"), path: [] }]);
+    }
+    if (val !== null && mustBeToday && !targetDate.isSame(today)) {
+      throw new z2.ZodError([{ code: "custom", message: getMessage("today"), path: [] }]);
+    }
+    if (val !== null && mustNotBeToday && targetDate.isSame(today)) {
+      throw new z2.ZodError([{ code: "custom", message: getMessage("notToday"), path: [] }]);
+    }
+    if (val !== null && weekdaysOnly && (dateObj.day() === 0 || dateObj.day() === 6)) {
+      throw new z2.ZodError([{ code: "custom", message: getMessage("weekday"), path: [] }]);
+    }
+    if (val !== null && weekendsOnly && dateObj.day() !== 0 && dateObj.day() !== 6) {
+      throw new z2.ZodError([{ code: "custom", message: getMessage("weekend"), path: [] }]);
+    }
+    return true;
+  });
   return schema;
 }
 
-// src/common/url.ts
+// src/validators/common/datetime.ts
 import { z as z3 } from "zod";
-function url(options) {
-  const { required = true, min, max, includes } = options ?? {};
-  const baseSchema = required ? z3.preprocess(
-    (val) => val === "" || val === null || val === void 0 ? null : val,
-    z3.url({
-      error: (issue) => {
-        if (issue.code === "invalid_type") return t("common.url.required");
-        else if (issue.code === "invalid_format") return t("common.url.invalid");
-        return t("common.url.invalid");
-      }
-    })
-  ) : z3.preprocess((val) => val === "" || val === null || val === void 0 ? null : val, z3.url({ message: t("common.url.invalid") }).nullable());
-  const schema = baseSchema.refine((val) => required ? val !== "" && val !== "null" && val !== "undefined" : true, { message: t("common.text.required") }).refine((val) => val === null || min === void 0 || val.length >= min, { message: t("common.text.min", { min }) }).refine((val) => val === null || max === void 0 || val.length <= max, { message: t("common.text.max", { max }) }).refine((val) => val === null || includes === void 0 || val.includes(includes), { message: t("common.text.includes", { includes }) });
+import dayjs2 from "dayjs";
+import customParseFormat2 from "dayjs/plugin/customParseFormat";
+import isSameOrAfter2 from "dayjs/plugin/isSameOrAfter";
+import isSameOrBefore2 from "dayjs/plugin/isSameOrBefore";
+import isToday2 from "dayjs/plugin/isToday";
+import weekday2 from "dayjs/plugin/weekday";
+import timezone from "dayjs/plugin/timezone";
+import utc from "dayjs/plugin/utc";
+dayjs2.extend(isSameOrAfter2);
+dayjs2.extend(isSameOrBefore2);
+dayjs2.extend(customParseFormat2);
+dayjs2.extend(isToday2);
+dayjs2.extend(weekday2);
+dayjs2.extend(timezone);
+dayjs2.extend(utc);
+var DATETIME_PATTERNS = {
+  "YYYY-MM-DD HH:mm": /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/,
+  "YYYY-MM-DD HH:mm:ss": /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/,
+  "YYYY-MM-DD hh:mm A": /^\d{4}-\d{2}-\d{2} \d{1,2}:\d{2} (AM|PM)$/i,
+  "YYYY-MM-DD hh:mm:ss A": /^\d{4}-\d{2}-\d{2} \d{1,2}:\d{2}:\d{2} (AM|PM)$/i,
+  "DD/MM/YYYY HH:mm": /^\d{1,2}\/\d{1,2}\/\d{4} \d{2}:\d{2}$/,
+  "DD/MM/YYYY HH:mm:ss": /^\d{1,2}\/\d{1,2}\/\d{4} \d{2}:\d{2}:\d{2}$/,
+  "DD/MM/YYYY hh:mm A": /^\d{1,2}\/\d{1,2}\/\d{4} \d{1,2}:\d{2} (AM|PM)$/i,
+  "MM/DD/YYYY HH:mm": /^\d{1,2}\/\d{1,2}\/\d{4} \d{2}:\d{2}$/,
+  "MM/DD/YYYY hh:mm A": /^\d{1,2}\/\d{1,2}\/\d{4} \d{1,2}:\d{2} (AM|PM)$/i,
+  "YYYY/MM/DD HH:mm": /^\d{4}\/\d{2}\/\d{2} \d{2}:\d{2}$/,
+  "DD-MM-YYYY HH:mm": /^\d{1,2}-\d{1,2}-\d{4} \d{2}:\d{2}$/,
+  "MM-DD-YYYY HH:mm": /^\d{1,2}-\d{1,2}-\d{4} \d{2}:\d{2}$/,
+  ISO: /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/,
+  RFC: /^[A-Za-z]{3}, \d{1,2} [A-Za-z]{3} \d{4} \d{2}:\d{2}:\d{2} [A-Z]{3}$/,
+  UNIX: /^\d{10}$/
+};
+var validateDateTimeFormat = (value, format) => {
+  const pattern = DATETIME_PATTERNS[format];
+  if (!pattern.test(value.trim())) {
+    return false;
+  }
+  const parsed = parseDateTimeValue(value, format);
+  return parsed !== null;
+};
+var parseDateTimeValue = (value, format, timezone2) => {
+  try {
+    const cleanValue = value.trim();
+    let parsed;
+    switch (format) {
+      case "ISO":
+        parsed = dayjs2(cleanValue);
+        break;
+      case "RFC":
+        parsed = dayjs2(cleanValue);
+        break;
+      case "UNIX":
+        parsed = dayjs2.unix(parseInt(cleanValue, 10));
+        break;
+      default:
+        parsed = dayjs2(cleanValue, format, true);
+        break;
+    }
+    if (!parsed.isValid()) {
+      return null;
+    }
+    if (timezone2) {
+      parsed = parsed.tz(timezone2);
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+};
+var normalizeDateTimeValue = (value, format, timezone2) => {
+  const parsed = parseDateTimeValue(value, format, timezone2);
+  if (!parsed) return null;
+  switch (format) {
+    case "ISO":
+      return parsed.toISOString();
+    case "RFC":
+      return parsed.format("ddd, DD MMM YYYY HH:mm:ss [GMT]");
+    case "UNIX":
+      return parsed.unix().toString();
+    default:
+      return parsed.format(format);
+  }
+};
+function datetime(options) {
+  const {
+    required = true,
+    format = "YYYY-MM-DD HH:mm",
+    min,
+    max,
+    minHour,
+    maxHour,
+    allowedHours,
+    minuteStep,
+    timezone: timezone2,
+    includes,
+    excludes,
+    regex,
+    trimMode = "trim",
+    casing = "none",
+    mustBePast,
+    mustBeFuture,
+    mustBeToday,
+    mustNotBeToday,
+    weekdaysOnly,
+    weekendsOnly,
+    whitelist,
+    whitelistOnly = false,
+    transform,
+    defaultValue,
+    i18n
+  } = options ?? {};
+  const actualDefaultValue = defaultValue ?? (required ? "" : null);
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale2 = getLocale();
+      const customMessages = i18n[currentLocale2];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`common.datetime.${key}`, params);
+  };
+  const preprocessFn = (val) => {
+    if (val === null || val === void 0) {
+      return actualDefaultValue;
+    }
+    let processed = String(val);
+    switch (trimMode) {
+      case "trim":
+        processed = processed.trim();
+        break;
+      case "trimStart":
+        processed = processed.trimStart();
+        break;
+      case "trimEnd":
+        processed = processed.trimEnd();
+        break;
+      case "none":
+        break;
+    }
+    if (processed === "") {
+      if (whitelist && whitelist.includes("")) {
+        return "";
+      }
+      if (!required) {
+        return actualDefaultValue;
+      }
+      return actualDefaultValue;
+    }
+    switch (casing) {
+      case "upper":
+        processed = processed.toUpperCase();
+        break;
+      case "lower":
+        processed = processed.toLowerCase();
+        break;
+      case "none":
+        break;
+    }
+    if (transform) {
+      processed = transform(processed);
+    }
+    return processed;
+  };
+  const baseSchema = required ? z3.preprocess(preprocessFn, z3.string()) : z3.preprocess(preprocessFn, z3.string().nullable());
+  const schema = baseSchema.refine((val) => {
+    if (val === null) return true;
+    if (required && (val === "" || val === "null" || val === "undefined")) {
+      throw new z3.ZodError([{ code: "custom", message: getMessage("required"), path: [] }]);
+    }
+    if (val === null) return true;
+    if (!required && val === "") return true;
+    if (whitelist && whitelist.length > 0) {
+      if (whitelist.includes(val)) {
+        return true;
+      }
+      if (whitelistOnly) {
+        throw new z3.ZodError([{ code: "custom", message: getMessage("notInWhitelist"), path: [] }]);
+      }
+    }
+    if (regex) {
+      if (!regex.test(val)) {
+        throw new z3.ZodError([{ code: "custom", message: getMessage("customRegex"), path: [] }]);
+      }
+    } else {
+      if (!validateDateTimeFormat(val, format)) {
+        throw new z3.ZodError([{ code: "custom", message: getMessage("format", { format }), path: [] }]);
+      }
+    }
+    if (includes && !val.includes(includes)) {
+      throw new z3.ZodError([{ code: "custom", message: getMessage("includes", { includes }), path: [] }]);
+    }
+    if (excludes) {
+      const excludeList = Array.isArray(excludes) ? excludes : [excludes];
+      for (const exclude of excludeList) {
+        if (val.includes(exclude)) {
+          throw new z3.ZodError([{ code: "custom", message: getMessage("excludes", { excludes: exclude }), path: [] }]);
+        }
+      }
+    }
+    if (regex) {
+      return true;
+    }
+    const parsed = parseDateTimeValue(val, format, timezone2);
+    if (!parsed) {
+      const pattern = DATETIME_PATTERNS[format];
+      if (!pattern.test(val.trim())) {
+        throw new z3.ZodError([{ code: "custom", message: getMessage("format", { format }), path: [] }]);
+      } else {
+        throw new z3.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }]);
+      }
+    }
+    const hour = parsed.hour();
+    if (minHour !== void 0 && hour < minHour) {
+      throw new z3.ZodError([{ code: "custom", message: getMessage("hour", { minHour, maxHour: maxHour ?? 23 }), path: [] }]);
+    }
+    if (maxHour !== void 0 && hour > maxHour) {
+      throw new z3.ZodError([{ code: "custom", message: getMessage("hour", { minHour: minHour ?? 0, maxHour }), path: [] }]);
+    }
+    if (allowedHours && allowedHours.length > 0) {
+      if (!allowedHours.includes(hour)) {
+        throw new z3.ZodError([{ code: "custom", message: getMessage("hour", { allowedHours: allowedHours.join(", ") }), path: [] }]);
+      }
+    }
+    const minute = parsed.minute();
+    if (minuteStep !== void 0 && minute % minuteStep !== 0) {
+      throw new z3.ZodError([{ code: "custom", message: getMessage("minute", { minuteStep }), path: [] }]);
+    }
+    if (min) {
+      const minParsed = typeof min === "string" ? parseDateTimeValue(min, format, timezone2) : dayjs2(min);
+      if (minParsed && parsed.isBefore(minParsed)) {
+        const minFormatted = typeof min === "string" ? min : minParsed.format(format);
+        throw new z3.ZodError([{ code: "custom", message: getMessage("min", { min: minFormatted }), path: [] }]);
+      }
+    }
+    if (max) {
+      const maxParsed = typeof max === "string" ? parseDateTimeValue(max, format, timezone2) : dayjs2(max);
+      if (maxParsed && parsed.isAfter(maxParsed)) {
+        const maxFormatted = typeof max === "string" ? max : maxParsed.format(format);
+        throw new z3.ZodError([{ code: "custom", message: getMessage("max", { max: maxFormatted }), path: [] }]);
+      }
+    }
+    const now = timezone2 ? dayjs2().tz(timezone2) : dayjs2();
+    if (mustBePast && !parsed.isBefore(now)) {
+      throw new z3.ZodError([{ code: "custom", message: getMessage("past"), path: [] }]);
+    }
+    if (mustBeFuture && !parsed.isAfter(now)) {
+      throw new z3.ZodError([{ code: "custom", message: getMessage("future"), path: [] }]);
+    }
+    if (mustBeToday && !parsed.isSame(now, "day")) {
+      throw new z3.ZodError([{ code: "custom", message: getMessage("today"), path: [] }]);
+    }
+    if (mustNotBeToday && parsed.isSame(now, "day")) {
+      throw new z3.ZodError([{ code: "custom", message: getMessage("notToday"), path: [] }]);
+    }
+    const dayOfWeek = parsed.day();
+    if (weekdaysOnly && (dayOfWeek === 0 || dayOfWeek === 6)) {
+      throw new z3.ZodError([{ code: "custom", message: getMessage("weekday"), path: [] }]);
+    }
+    if (weekendsOnly && dayOfWeek !== 0 && dayOfWeek !== 6) {
+      throw new z3.ZodError([{ code: "custom", message: getMessage("weekend"), path: [] }]);
+    }
+    return true;
+  });
   return schema;
 }
 
-// src/common/text.ts
+// src/validators/common/email.ts
 import { z as z4 } from "zod";
-function text(options) {
-  const { required = true, min, max, startsWith, endsWith, includes, regex, defaultValue = null } = options ?? {};
-  const baseSchema = required ? z4.preprocess((val) => val === "" || val === null || val === void 0 ? defaultValue : val, z4.coerce.string().trim()) : z4.preprocess((val) => val === "" || val === null || val === void 0 ? defaultValue : val, z4.coerce.string().trim().nullable());
-  const schema = baseSchema.refine((val) => required ? val !== "" && val !== "null" && val !== "undefined" : true, { message: t("common.text.required") }).refine((val) => val === null || min === void 0 || val.length >= min, { message: t("common.text.min", { min }) }).refine((val) => val === null || max === void 0 || val.length <= max, { message: t("common.text.max", { max }) }).refine((val) => val === null || startsWith === void 0 || val.startsWith(startsWith), { message: t("common.text.startsWith", { startsWith }) }).refine((val) => val === null || endsWith === void 0 || val.endsWith(endsWith), { message: t("common.text.endsWith", { endsWith }) }).refine((val) => val === null || includes === void 0 || val.includes(includes), { message: t("common.text.includes", { includes }) }).refine((val) => val === null || regex === void 0 || regex.test(val), { message: t("common.text.invalid", { regex }) });
+function email(options) {
+  const {
+    required = true,
+    domain,
+    domainBlacklist,
+    minLength,
+    maxLength,
+    includes,
+    excludes,
+    allowSubdomains = true,
+    businessOnly = false,
+    noDisposable = false,
+    lowercase = true,
+    transform,
+    defaultValue,
+    i18n
+  } = options ?? {};
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale2 = getLocale();
+      const customMessages = i18n[currentLocale2];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`common.email.${key}`, params);
+  };
+  const disposableDomains = ["10minutemail.com", "tempmail.org", "guerrillamail.com", "mailinator.com", "yopmail.com", "temp-mail.org", "throwaway.email", "getnada.com", "maildrop.cc"];
+  const freeEmailDomains = ["gmail.com", "yahoo.com", "hotmail.com", "outlook.com", "icloud.com", "aol.com", "protonmail.com", "zoho.com"];
+  const actualDefaultValue = defaultValue ?? null;
+  const baseSchema = z4.preprocess(
+    (val) => {
+      if (val === "" || val === null || val === void 0) {
+        return actualDefaultValue;
+      }
+      let processed = String(val).trim();
+      if (lowercase) {
+        processed = processed.toLowerCase();
+      }
+      if (transform) {
+        processed = transform(processed);
+      }
+      return processed;
+    },
+    z4.union([z4.string().email(), z4.null()])
+  );
+  const schema = baseSchema.refine((val) => {
+    if (required && val === null) {
+      throw new z4.ZodError([{ code: "custom", message: getMessage("required"), path: [] }]);
+    }
+    if (val === null) return true;
+    if (typeof val !== "string") {
+      throw new z4.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }]);
+    }
+    if (minLength !== void 0 && val.length < minLength) {
+      throw new z4.ZodError([{ code: "custom", message: getMessage("minLength", { minLength }), path: [] }]);
+    }
+    if (maxLength !== void 0 && val.length > maxLength) {
+      throw new z4.ZodError([{ code: "custom", message: getMessage("maxLength", { maxLength }), path: [] }]);
+    }
+    if (includes !== void 0 && !val.includes(includes)) {
+      throw new z4.ZodError([{ code: "custom", message: getMessage("includes", { includes }), path: [] }]);
+    }
+    if (excludes !== void 0) {
+      const excludeList = Array.isArray(excludes) ? excludes : [excludes];
+      for (const exclude of excludeList) {
+        if (val.includes(exclude)) {
+          throw new z4.ZodError([{ code: "custom", message: getMessage("includes", { includes: exclude }), path: [] }]);
+        }
+      }
+    }
+    const emailDomain = val.split("@")[1]?.toLowerCase();
+    if (!emailDomain) {
+      throw new z4.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }]);
+    }
+    if (businessOnly) {
+      const isFreeProvider = freeEmailDomains.some((freeDomain) => {
+        if (allowSubdomains) {
+          return emailDomain === freeDomain || emailDomain.endsWith("." + freeDomain);
+        }
+        return emailDomain === freeDomain;
+      });
+      if (isFreeProvider) {
+        throw new z4.ZodError([{ code: "custom", message: getMessage("businessOnly"), path: [] }]);
+      }
+    }
+    if (domainBlacklist && domainBlacklist.length > 0) {
+      const isBlacklisted = domainBlacklist.some((blacklistedDomain) => {
+        const lowerDomain = blacklistedDomain.toLowerCase();
+        if (allowSubdomains) {
+          return emailDomain === lowerDomain || emailDomain.endsWith("." + lowerDomain);
+        }
+        return emailDomain === lowerDomain;
+      });
+      if (isBlacklisted) {
+        throw new z4.ZodError([{ code: "custom", message: getMessage("domainBlacklist", { domain: emailDomain }), path: [] }]);
+      }
+    }
+    if (domain !== void 0) {
+      const allowedDomains = Array.isArray(domain) ? domain : [domain];
+      const isAllowed = allowedDomains.some((allowedDomain) => {
+        const lowerDomain = allowedDomain.toLowerCase();
+        if (allowSubdomains) {
+          return emailDomain === lowerDomain || emailDomain.endsWith("." + lowerDomain);
+        }
+        return emailDomain === lowerDomain;
+      });
+      if (!isAllowed) {
+        throw new z4.ZodError([{ code: "custom", message: getMessage("domain", { domain: Array.isArray(domain) ? domain.join(", ") : domain }), path: [] }]);
+      }
+    }
+    if (noDisposable) {
+      const isDisposable = disposableDomains.some((disposableDomain) => {
+        if (allowSubdomains) {
+          return emailDomain === disposableDomain || emailDomain.endsWith("." + disposableDomain);
+        }
+        return emailDomain === disposableDomain;
+      });
+      if (isDisposable) {
+        throw new z4.ZodError([{ code: "custom", message: getMessage("noDisposable"), path: [] }]);
+      }
+    }
+    return true;
+  });
   return schema;
 }
 
-// src/common/number.ts
+// src/validators/common/file.ts
 import { z as z5 } from "zod";
-function number(options) {
-  const { required = true, min, max, defaultValue } = options ?? {};
-  const schema = z5.preprocess(
+function file(options) {
+  const {
+    required = true,
+    maxSize,
+    minSize,
+    type,
+    typeBlacklist,
+    extension,
+    extensionBlacklist,
+    namePattern,
+    nameBlacklist,
+    imageOnly = false,
+    documentOnly = false,
+    videoOnly = false,
+    audioOnly = false,
+    archiveOnly = false,
+    caseSensitive = false,
+    transform,
+    defaultValue,
+    i18n
+  } = options ?? {};
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale2 = getLocale();
+      const customMessages = i18n[currentLocale2];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`common.file.${key}`, params);
+  };
+  const imageTypes = ["image/jpeg", "image/jpg", "image/png", "image/gif", "image/webp", "image/svg+xml", "image/bmp", "image/tiff"];
+  const documentTypes = [
+    "application/pdf",
+    "application/msword",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/vnd.ms-excel",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "application/vnd.ms-powerpoint",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "text/plain",
+    "text/csv"
+  ];
+  const videoTypes = ["video/mp4", "video/mpeg", "video/quicktime", "video/x-msvideo", "video/x-ms-wmv", "video/webm", "video/ogg"];
+  const audioTypes = ["audio/mpeg", "audio/wav", "audio/ogg", "audio/aac", "audio/webm", "audio/mp3", "audio/x-wav"];
+  const archiveTypes = ["application/zip", "application/x-rar-compressed", "application/x-7z-compressed", "application/x-tar", "application/gzip"];
+  const actualDefaultValue = defaultValue ?? null;
+  const baseSchema = z5.preprocess(
+    (val) => {
+      if (val === "" || val === null || val === void 0) {
+        return actualDefaultValue;
+      }
+      if (!(val instanceof File)) {
+        return val;
+      }
+      let processed = val;
+      if (transform) {
+        processed = transform(processed);
+      }
+      return processed;
+    },
+    z5.union([z5.instanceof(File).refine(() => true, { message: getMessage("invalid") }), z5.null()])
+  );
+  const schema = baseSchema.refine((val) => required === false || val !== null, {
+    message: getMessage("required")
+  }).refine((val) => val === null || val instanceof File, {
+    message: getMessage("invalid")
+  }).refine((val) => val === null || minSize === void 0 || val.size >= minSize, {
+    message: getMessage("minSize", { minSize: formatFileSize(minSize || 0) })
+  }).refine((val) => val === null || maxSize === void 0 || val.size <= maxSize, {
+    message: getMessage("maxSize", { maxSize: formatFileSize(maxSize || 0) })
+  }).refine((val) => val === null || !imageOnly || imageTypes.includes(val.type), {
+    message: getMessage("imageOnly")
+  }).refine((val) => val === null || !documentOnly || documentTypes.includes(val.type), {
+    message: getMessage("documentOnly")
+  }).refine((val) => val === null || !videoOnly || videoTypes.includes(val.type), {
+    message: getMessage("videoOnly")
+  }).refine((val) => val === null || !audioOnly || audioTypes.includes(val.type), {
+    message: getMessage("audioOnly")
+  }).refine((val) => val === null || !archiveOnly || archiveTypes.includes(val.type), {
+    message: getMessage("archiveOnly")
+  }).refine(
+    (val) => {
+      if (val === null || !typeBlacklist || typeBlacklist.length === 0) return true;
+      return !typeBlacklist.includes(val.type);
+    },
+    {
+      message: getMessage("type", { type: typeBlacklist?.join(", ") || "" })
+    }
+  ).refine(
+    (val) => {
+      if (val === null || type === void 0) return true;
+      const allowedTypes = Array.isArray(type) ? type : [type];
+      return allowedTypes.includes(val.type);
+    },
+    {
+      message: getMessage("type", { type: Array.isArray(type) ? type.join(", ") : type || "" })
+    }
+  ).refine(
+    (val) => {
+      if (val === null || extensionBlacklist === void 0 || extensionBlacklist.length === 0) return true;
+      const fileExtension = getFileExtension(val.name, caseSensitive);
+      const normalizedBlacklist = extensionBlacklist.map((ext) => normalizeExtension(ext, caseSensitive));
+      return !normalizedBlacklist.includes(fileExtension);
+    },
+    {
+      message: getMessage("extensionBlacklist", { extension: extensionBlacklist?.join(", ") || "" })
+    }
+  ).refine(
+    (val) => {
+      if (val === null || extension === void 0) return true;
+      const fileName = val.name;
+      const fileExtension = getFileExtension(fileName, caseSensitive);
+      const allowedExtensions = Array.isArray(extension) ? extension : [extension];
+      const normalizedExtensions = allowedExtensions.map((ext) => normalizeExtension(ext, caseSensitive));
+      return normalizedExtensions.includes(fileExtension);
+    },
+    {
+      message: getMessage("extension", { extension: Array.isArray(extension) ? extension.join(", ") : extension || "" })
+    }
+  ).refine(
+    (val) => {
+      if (val === null || namePattern === void 0) return true;
+      const pattern = typeof namePattern === "string" ? new RegExp(namePattern) : namePattern;
+      return pattern.test(val.name);
+    },
+    {
+      message: getMessage("name", { pattern: namePattern?.toString() || "" })
+    }
+  ).refine(
     (val) => {
-      if (val === "" || val === void 0 || val === null) return defaultValue ?? null;
-      return typeof val === "string" ? Number(val) : val;
-    },
-    z5.union([
-      z5.number({
-        error: (issue) => {
-          if (issue.code === "invalid_type") return t("common.number.integer");
-          return t("common.number.required");
+      if (val === null || nameBlacklist === void 0) return true;
+      const blacklistPatterns = Array.isArray(nameBlacklist) ? nameBlacklist : [nameBlacklist];
+      for (const blacklistPattern of blacklistPatterns) {
+        const pattern = typeof blacklistPattern === "string" ? new RegExp(blacklistPattern) : blacklistPattern;
+        if (pattern.test(val.name)) {
+          return false;
         }
-      }),
-      z5.null()
-    ])
-  ).refine((val) => !required || val !== null, { message: t("common.number.required") }).refine((val) => val === null || min === void 0 || val >= min, { message: t("common.number.min", { min }) }).refine((val) => val === null || max === void 0 || val <= max, { message: t("common.number.max", { max }) });
+      }
+      return true;
+    },
+    {
+      message: getMessage("nameBlacklist", { pattern: "" })
+    }
+  );
   return schema;
 }
+function getFileExtension(fileName, caseSensitive) {
+  const lastDotIndex = fileName.lastIndexOf(".");
+  if (lastDotIndex === -1) return "";
+  const extension = fileName.substring(lastDotIndex);
+  return caseSensitive ? extension : extension.toLowerCase();
+}
+function normalizeExtension(extension, caseSensitive) {
+  const normalized = extension.startsWith(".") ? extension : `.${extension}`;
+  return caseSensitive ? normalized : normalized.toLowerCase();
+}
+function formatFileSize(bytes) {
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let size = bytes;
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  return `${Math.round(size * 100) / 100} ${units[unitIndex]}`;
+}
 
-// src/common/password.ts
+// src/validators/common/id.ts
 import { z as z6 } from "zod";
-function password(options) {
-  const { required = true, min, max, uppercase, lowercase, digits, special } = options ?? {};
-  const baseSchema = required ? z6.preprocess((val) => val === "" || val === null || val === void 0 ? null : val, z6.coerce.string().trim()) : z6.preprocess((val) => val === "" || val === null || val === void 0 ? null : val, z6.coerce.string().trim().nullable());
-  const schema = baseSchema.refine((val) => required ? val !== "" && val !== "null" && val !== "undefined" : true, { message: t("common.password.required") }).refine((val) => val === null || min === void 0 || val.length >= min, { message: t("common.password.min", { min }) }).refine((val) => val === null || max === void 0 || val.length <= max, { message: t("common.password.max", { max }) }).refine((val) => val === null || !uppercase || /[A-Z]/.test(val), { message: t("common.password.uppercase") }).refine((val) => val === null || !lowercase || /[a-z]/.test(val), { message: t("common.password.lowercase") }).refine((val) => val === null || !special || /[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]+/.test(val), { message: t("common.password.special") }).refine((val) => val === null || !digits || /[0-9]/.test(val), { message: t("common.password.digits") });
+var 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,
+  objectId: /^[0-9a-f]{24}$/i,
+  nanoid: /^[A-Za-z0-9_-]{21}$/,
+  snowflake: /^\d{19}$/,
+  cuid: /^c[a-z0-9]{24}$/,
+  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+  shortid: /^[A-Za-z0-9_-]{7,14}$/
+};
+var detectIdType = (value) => {
+  const orderedTypes = [
+    ["uuid", ID_PATTERNS.uuid],
+    ["objectId", ID_PATTERNS.objectId],
+    ["snowflake", ID_PATTERNS.snowflake],
+    ["cuid", ID_PATTERNS.cuid],
+    ["ulid", ID_PATTERNS.ulid],
+    ["nanoid", ID_PATTERNS.nanoid],
+    ["numeric", ID_PATTERNS.numeric],
+    ["shortid", ID_PATTERNS.shortid]
+    // 放最後，因為最通用
+  ];
+  for (const [type, pattern] of orderedTypes) {
+    if (pattern.test(value)) {
+      return type;
+    }
+  }
+  return null;
+};
+var validateIdType = (value, type) => {
+  if (type === "auto") {
+    return detectIdType(value) !== null;
+  }
+  const pattern = ID_PATTERNS[type];
+  return pattern ? pattern.test(value) : false;
+};
+function id(options) {
+  const {
+    required = true,
+    type = "auto",
+    minLength,
+    maxLength,
+    allowedTypes,
+    customRegex,
+    includes,
+    excludes,
+    startsWith,
+    endsWith,
+    caseSensitive = true,
+    transform,
+    defaultValue,
+    i18n
+  } = options ?? {};
+  const actualDefaultValue = defaultValue ?? (required ? "" : null);
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale2 = getLocale();
+      const customMessages = i18n[currentLocale2];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`common.id.${key}`, params);
+  };
+  const preprocessFn = (val) => {
+    if (val === "" || val === null || val === void 0) {
+      return actualDefaultValue;
+    }
+    let processed = String(val);
+    if (transform) {
+      processed = transform(processed);
+    }
+    return processed;
+  };
+  const baseSchema = required ? z6.preprocess(preprocessFn, z6.string()) : z6.preprocess(preprocessFn, z6.string().nullable());
+  const schema = baseSchema.refine((val) => {
+    if (val === null) return true;
+    if (required && (val === "" || val === "null" || val === "undefined")) {
+      throw new z6.ZodError([{ code: "custom", message: getMessage("required"), path: [] }]);
+    }
+    const comparisonVal = !caseSensitive ? val.toLowerCase() : val;
+    if (val !== null && minLength !== void 0 && val.length < minLength) {
+      throw new z6.ZodError([{ code: "custom", message: getMessage("minLength", { minLength }), path: [] }]);
+    }
+    if (val !== null && maxLength !== void 0 && val.length > maxLength) {
+      throw new z6.ZodError([{ code: "custom", message: getMessage("maxLength", { maxLength }), path: [] }]);
+    }
+    const hasContentValidations = customRegex !== void 0 || startsWith !== void 0 || endsWith !== void 0 || includes !== void 0 || excludes !== void 0;
+    if (val !== null && customRegex !== void 0) {
+      if (!customRegex.test(val)) {
+        throw new z6.ZodError([{ code: "custom", message: getMessage("customFormat"), path: [] }]);
+      }
+    } else if (val !== null && !hasContentValidations) {
+      let isValidId;
+      if (allowedTypes && allowedTypes.length > 0) {
+        isValidId = allowedTypes.some((allowedType) => validateIdType(val, allowedType));
+        if (!isValidId) {
+          const typeNames = allowedTypes.join(", ");
+          throw new z6.ZodError([{ code: "custom", message: getMessage("invalid") + ` (allowed types: ${typeNames})`, path: [] }]);
+        }
+      } else if (type !== "auto") {
+        isValidId = validateIdType(val, type);
+        if (!isValidId) {
+          throw new z6.ZodError([{ code: "custom", message: getMessage(type) || getMessage("invalid"), path: [] }]);
+        }
+      } else {
+        isValidId = detectIdType(val) !== null;
+        if (!isValidId) {
+          throw new z6.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }]);
+        }
+      }
+    } else if (val !== null && hasContentValidations && type !== "auto" && !customRegex) {
+      if (allowedTypes && allowedTypes.length > 0) {
+        const isValidType = allowedTypes.some((allowedType) => validateIdType(val, allowedType));
+        if (!isValidType) {
+          const typeNames = allowedTypes.join(", ");
+          throw new z6.ZodError([{ code: "custom", message: getMessage("invalid") + ` (allowed types: ${typeNames})`, path: [] }]);
+        }
+      } else {
+        if (!validateIdType(val, type)) {
+          throw new z6.ZodError([{ code: "custom", message: getMessage(type) || getMessage("invalid"), path: [] }]);
+        }
+      }
+    }
+    const searchStartsWith = !caseSensitive && startsWith ? startsWith.toLowerCase() : startsWith;
+    const searchEndsWith = !caseSensitive && endsWith ? endsWith.toLowerCase() : endsWith;
+    const searchIncludes = !caseSensitive && includes ? includes.toLowerCase() : includes;
+    if (val !== null && startsWith !== void 0 && !comparisonVal.startsWith(searchStartsWith)) {
+      throw new z6.ZodError([{ code: "custom", message: getMessage("startsWith", { startsWith }), path: [] }]);
+    }
+    if (val !== null && endsWith !== void 0 && !comparisonVal.endsWith(searchEndsWith)) {
+      throw new z6.ZodError([{ code: "custom", message: getMessage("endsWith", { endsWith }), path: [] }]);
+    }
+    if (val !== null && includes !== void 0 && !comparisonVal.includes(searchIncludes)) {
+      throw new z6.ZodError([{ code: "custom", message: getMessage("includes", { includes }), path: [] }]);
+    }
+    if (val !== null && excludes !== void 0) {
+      const excludeList = Array.isArray(excludes) ? excludes : [excludes];
+      for (const exclude of excludeList) {
+        const searchExclude = !caseSensitive ? exclude.toLowerCase() : exclude;
+        if (comparisonVal.includes(searchExclude)) {
+          throw new z6.ZodError([{ code: "custom", message: getMessage("excludes", { excludes: exclude }), path: [] }]);
+        }
+      }
+    }
+    return true;
+  }).transform((val) => {
+    if (val === null) return val;
+    const shouldPreserveCase = type === "uuid" || type === "objectId";
+    if (!caseSensitive && !shouldPreserveCase) {
+      return val.toLowerCase();
+    }
+    return val;
+  });
   return schema;
 }
 
-// src/common/integer.ts
+// src/validators/common/number.ts
 import { z as z7 } from "zod";
-function integer(options) {
-  const { required = true, min, max, defaultValue } = options ?? {};
+function number(options) {
+  const {
+    required = true,
+    min,
+    max,
+    defaultValue,
+    type = "both",
+    positive,
+    negative,
+    nonNegative,
+    nonPositive,
+    multipleOf,
+    precision,
+    finite = true,
+    transform,
+    parseCommas = false,
+    i18n
+  } = options ?? {};
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale2 = getLocale();
+      const customMessages = i18n[currentLocale2];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`common.number.${key}`, params);
+  };
+  const actualDefaultValue = defaultValue ?? null;
   const schema = z7.preprocess(
     (val) => {
-      if (val === "" || val === void 0 || val === null) return defaultValue ?? null;
-      return typeof val === "string" ? Number(val) : val;
-    },
-    z7.union([
-      z7.number({
-        error: (issue) => {
-          if (issue.code === "invalid_type") return t("common.integer.integer");
-          return t("common.integer.required");
+      if (val === "" || val === void 0 || val === null) {
+        return actualDefaultValue;
+      }
+      if (typeof val === "string") {
+        let processedVal = val.trim();
+        if (parseCommas) {
+          processedVal = processedVal.replace(/,/g, "");
+        }
+        const parsed = Number(processedVal);
+        if (isNaN(parsed)) {
+          return parsed;
         }
-      }),
-      z7.null()
-    ])
-  ).refine((val) => !required || val !== null, {
-    message: t("common.integer.required")
-  }).refine((val) => val === null || Number.isInteger(val), {
-    message: t("common.integer.integer")
-  }).refine((val) => val === null || min === void 0 || val >= min, {
-    message: t("common.integer.min", { min })
-  }).refine((val) => val === null || max === void 0 || val <= max, {
-    message: t("common.integer.max", { max })
+        if (transform) {
+          return transform(parsed);
+        }
+        return parsed;
+      }
+      if (typeof val === "number") {
+        if (transform && Number.isFinite(val)) {
+          return transform(val);
+        }
+        return val;
+      }
+      return val;
+    },
+    z7.union([z7.number(), z7.null(), z7.nan(), z7.custom((val) => val === Infinity || val === -Infinity)])
+  ).refine((val) => {
+    if (required && val === null) {
+      throw new z7.ZodError([{ code: "custom", message: getMessage("required"), path: [] }]);
+    }
+    if (val === null) return true;
+    if (typeof val === "number" && isNaN(val)) {
+      if (type === "integer") {
+        throw new z7.ZodError([{ code: "custom", message: getMessage("integer"), path: [] }]);
+      } else if (type === "float") {
+        throw new z7.ZodError([{ code: "custom", message: getMessage("float"), path: [] }]);
+      } else {
+        throw new z7.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }]);
+      }
+    }
+    if (typeof val !== "number") {
+      throw new z7.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }]);
+    }
+    if (finite && !Number.isFinite(val)) {
+      throw new z7.ZodError([{ code: "custom", message: getMessage("finite"), path: [] }]);
+    }
+    if (type === "integer" && !Number.isInteger(val)) {
+      throw new z7.ZodError([{ code: "custom", message: getMessage("integer"), path: [] }]);
+    }
+    if (type === "float" && Number.isInteger(val)) {
+      throw new z7.ZodError([{ code: "custom", message: getMessage("float"), path: [] }]);
+    }
+    if (positive && val <= 0) {
+      throw new z7.ZodError([{ code: "custom", message: getMessage("positive"), path: [] }]);
+    }
+    if (negative && val >= 0) {
+      throw new z7.ZodError([{ code: "custom", message: getMessage("negative"), path: [] }]);
+    }
+    if (nonNegative && val < 0) {
+      throw new z7.ZodError([{ code: "custom", message: getMessage("nonNegative"), path: [] }]);
+    }
+    if (nonPositive && val > 0) {
+      throw new z7.ZodError([{ code: "custom", message: getMessage("nonPositive"), path: [] }]);
+    }
+    if (min !== void 0 && val < min) {
+      throw new z7.ZodError([{ code: "custom", message: getMessage("min", { min }), path: [] }]);
+    }
+    if (max !== void 0 && val > max) {
+      throw new z7.ZodError([{ code: "custom", message: getMessage("max", { max }), path: [] }]);
+    }
+    if (multipleOf !== void 0 && val % multipleOf !== 0) {
+      throw new z7.ZodError([{ code: "custom", message: getMessage("multipleOf", { multipleOf }), path: [] }]);
+    }
+    if (precision !== void 0) {
+      const decimalPlaces = (val.toString().split(".")[1] || "").length;
+      if (decimalPlaces > precision) {
+        throw new z7.ZodError([{ code: "custom", message: getMessage("precision", { precision }), path: [] }]);
+      }
+    }
+    return true;
+  });
+  return schema;
+}
+
+// src/validators/common/password.ts
+import { z as z8 } from "zod";
+var COMMON_PASSWORDS = [
+  "password",
+  "123456",
+  "123456789",
+  "12345678",
+  "12345",
+  "1234567",
+  "admin",
+  "qwerty",
+  "abc123",
+  "password123",
+  "letmein",
+  "welcome",
+  "monkey",
+  "dragon",
+  "sunshine",
+  "princess"
+];
+var calculatePasswordStrength = (password2) => {
+  let score = 0;
+  if (password2.length >= 8) score += 1;
+  if (password2.length >= 12) score += 1;
+  if (password2.length >= 16) score += 1;
+  if (/[a-z]/.test(password2)) score += 1;
+  if (/[A-Z]/.test(password2)) score += 1;
+  if (/[0-9]/.test(password2)) score += 1;
+  if (/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(password2)) score += 1;
+  if (/(.)\1{2,}/.test(password2)) score -= 1;
+  if (/(?:abc|bcd|cde|def|efg|fgh|ghi|hij|ijk|jkl|klm|lmn|mno|nop|opq|pqr|qrs|rst|stu|tuv|uvw|vwx|wxy|xyz|012|123|234|345|456|567|678|789)/i.test(password2)) score -= 1;
+  if (score <= 2) return "weak";
+  if (score <= 4) return "medium";
+  if (score <= 6) return "strong";
+  return "very-strong";
+};
+function password(options) {
+  const {
+    required = true,
+    min,
+    max,
+    uppercase,
+    lowercase,
+    digits,
+    special,
+    noRepeating,
+    noSequential,
+    noCommonWords,
+    minStrength,
+    excludes,
+    includes,
+    regex,
+    transform,
+    defaultValue,
+    i18n
+  } = options ?? {};
+  const actualDefaultValue = defaultValue ?? (required ? "" : null);
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale2 = getLocale();
+      const customMessages = i18n[currentLocale2];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`common.password.${key}`, params);
+  };
+  const preprocessFn = (val) => {
+    if (val === "" || val === null || val === void 0) {
+      return actualDefaultValue;
+    }
+    let processed = String(val);
+    if (transform) {
+      processed = transform(processed);
+    }
+    return processed;
+  };
+  const baseSchema = required ? z8.preprocess(preprocessFn, z8.string()) : z8.preprocess(preprocessFn, z8.string().nullable());
+  const schema = baseSchema.refine((val) => {
+    if (val === null) return true;
+    if (required && (val === "" || val === "null" || val === "undefined")) {
+      throw new z8.ZodError([{ code: "custom", message: getMessage("required"), path: [] }]);
+    }
+    if (val !== null && min !== void 0 && val.length < min) {
+      throw new z8.ZodError([{ code: "custom", message: getMessage("min", { min }), path: [] }]);
+    }
+    if (val !== null && max !== void 0 && val.length > max) {
+      throw new z8.ZodError([{ code: "custom", message: getMessage("max", { max }), path: [] }]);
+    }
+    if (val !== null && uppercase && !/[A-Z]/.test(val)) {
+      throw new z8.ZodError([{ code: "custom", message: getMessage("uppercase"), path: [] }]);
+    }
+    if (val !== null && lowercase && !/[a-z]/.test(val)) {
+      throw new z8.ZodError([{ code: "custom", message: getMessage("lowercase"), path: [] }]);
+    }
+    if (val !== null && digits && !/[0-9]/.test(val)) {
+      throw new z8.ZodError([{ code: "custom", message: getMessage("digits"), path: [] }]);
+    }
+    if (val !== null && special && !/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(val)) {
+      throw new z8.ZodError([{ code: "custom", message: getMessage("special"), path: [] }]);
+    }
+    if (val !== null && noRepeating && /(.)\1{2,}/.test(val)) {
+      throw new z8.ZodError([{ code: "custom", message: getMessage("noRepeating"), path: [] }]);
+    }
+    if (val !== null && noSequential && /(?:abc|bcd|cde|def|efg|fgh|ghi|hij|ijk|jkl|klm|lmn|mno|nop|opq|pqr|qrs|rst|stu|tuv|uvw|vwx|wxy|xyz|012|123|234|345|456|567|678|789)/i.test(val)) {
+      throw new z8.ZodError([{ code: "custom", message: getMessage("noSequential"), path: [] }]);
+    }
+    if (val !== null && noCommonWords && COMMON_PASSWORDS.some((common) => val.toLowerCase().includes(common.toLowerCase()))) {
+      throw new z8.ZodError([{ code: "custom", message: getMessage("noCommonWords"), path: [] }]);
+    }
+    if (val !== null && minStrength) {
+      const strength = calculatePasswordStrength(val);
+      const strengthLevels = ["weak", "medium", "strong", "very-strong"];
+      const currentLevel = strengthLevels.indexOf(strength);
+      const requiredLevel = strengthLevels.indexOf(minStrength);
+      if (currentLevel < requiredLevel) {
+        throw new z8.ZodError([{ code: "custom", message: getMessage("minStrength", { minStrength }), path: [] }]);
+      }
+    }
+    if (val !== null && includes !== void 0 && !val.includes(includes)) {
+      throw new z8.ZodError([{ code: "custom", message: getMessage("includes", { includes }), path: [] }]);
+    }
+    if (val !== null && excludes !== void 0) {
+      const excludeList = Array.isArray(excludes) ? excludes : [excludes];
+      for (const exclude of excludeList) {
+        if (val.includes(exclude)) {
+          throw new z8.ZodError([{ code: "custom", message: getMessage("excludes", { excludes: exclude }), path: [] }]);
+        }
+      }
+    }
+    if (val !== null && regex !== void 0 && !regex.test(val)) {
+      throw new z8.ZodError([{ code: "custom", message: getMessage("invalid", { regex }), path: [] }]);
+    }
+    return true;
+  });
+  return schema;
+}
+
+// src/validators/common/text.ts
+import { z as z9 } from "zod";
+function text(options) {
+  const { required = true, minLength, maxLength, startsWith, endsWith, includes, excludes, regex, trimMode = "trim", casing = "none", transform, notEmpty, defaultValue, i18n } = options ?? {};
+  const actualDefaultValue = defaultValue ?? (required ? "" : null);
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale2 = getLocale();
+      const customMessages = i18n[currentLocale2];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`common.text.${key}`, params);
+  };
+  const applyTrim = (str) => {
+    switch (trimMode) {
+      case "trimStart":
+        return str.trimStart();
+      case "trimEnd":
+        return str.trimEnd();
+      case "none":
+        return str;
+      default:
+        return str.trim();
+    }
+  };
+  const applyCasing = (str) => {
+    switch (casing) {
+      case "upper":
+        return str.toUpperCase();
+      case "lower":
+        return str.toLowerCase();
+      case "title":
+        return str.replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase());
+      default:
+        return str;
+    }
+  };
+  const preprocessFn = (val) => {
+    if (val === "" || val === null || val === void 0) {
+      return actualDefaultValue;
+    }
+    let processed = String(val);
+    processed = applyTrim(processed);
+    processed = applyCasing(processed);
+    if (transform) {
+      processed = transform(processed);
+    }
+    return processed;
+  };
+  const baseSchema = required ? z9.preprocess(preprocessFn, z9.string()) : z9.preprocess(preprocessFn, z9.string().nullable());
+  const schema = baseSchema.refine((val) => {
+    if (val === null) return true;
+    if (required && (val === "" || val === "null" || val === "undefined")) {
+      throw new z9.ZodError([{ code: "custom", message: getMessage("required"), path: [] }]);
+    }
+    if (notEmpty && val !== null && val.trim() === "") {
+      throw new z9.ZodError([{ code: "custom", message: getMessage("notEmpty"), path: [] }]);
+    }
+    if (val !== null && minLength !== void 0 && val.length < minLength) {
+      throw new z9.ZodError([{ code: "custom", message: getMessage("minLength", { minLength }), path: [] }]);
+    }
+    if (val !== null && maxLength !== void 0 && val.length > maxLength) {
+      throw new z9.ZodError([{ code: "custom", message: getMessage("maxLength", { maxLength }), path: [] }]);
+    }
+    if (val !== null && startsWith !== void 0 && !val.startsWith(startsWith)) {
+      throw new z9.ZodError([{ code: "custom", message: getMessage("startsWith", { startsWith }), path: [] }]);
+    }
+    if (val !== null && endsWith !== void 0 && !val.endsWith(endsWith)) {
+      throw new z9.ZodError([{ code: "custom", message: getMessage("endsWith", { endsWith }), path: [] }]);
+    }
+    if (val !== null && includes !== void 0 && !val.includes(includes)) {
+      throw new z9.ZodError([{ code: "custom", message: getMessage("includes", { includes }), path: [] }]);
+    }
+    if (val !== null && excludes !== void 0) {
+      const excludeList = Array.isArray(excludes) ? excludes : [excludes];
+      for (const exclude of excludeList) {
+        if (val.includes(exclude)) {
+          throw new z9.ZodError([{ code: "custom", message: getMessage("excludes", { excludes: exclude }), path: [] }]);
+        }
+      }
+    }
+    if (val !== null && regex !== void 0 && !regex.test(val)) {
+      throw new z9.ZodError([{ code: "custom", message: getMessage("invalid", { regex }), path: [] }]);
+    }
+    return true;
+  });
+  return schema;
+}
+
+// src/validators/common/time.ts
+import { z as z10 } from "zod";
+var TIME_PATTERNS = {
+  "HH:mm": /^([01]?[0-9]|2[0-3]):[0-5][0-9]$/,
+  "HH:mm:ss": /^([01]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]$/,
+  "hh:mm A": /^(0?[1-9]|1[0-2]):[0-5][0-9]\s?(AM|PM)$/i,
+  "hh:mm:ss A": /^(0?[1-9]|1[0-2]):[0-5][0-9]:[0-5][0-9]\s?(AM|PM)$/i,
+  "H:mm": /^([0-9]|1[0-9]|2[0-3]):[0-5][0-9]$/,
+  "h:mm A": /^([1-9]|1[0-2]):[0-5][0-9]\s?(AM|PM)$/i
+};
+var parseTimeToMinutes = (timeStr, format) => {
+  const cleanTime = timeStr.trim();
+  try {
+    if (format.includes("A")) {
+      const match = cleanTime.match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?\s?(AM|PM)$/i);
+      if (!match) return null;
+      const [, hourStr, minuteStr, , period] = match;
+      let hour = parseInt(hourStr, 10);
+      const minute = parseInt(minuteStr, 10);
+      if (hour < 1 || hour > 12 || minute < 0 || minute > 59) {
+        return null;
+      }
+      if (period.toUpperCase() === "PM" && hour !== 12) {
+        hour += 12;
+      } else if (period.toUpperCase() === "AM" && hour === 12) {
+        hour = 0;
+      }
+      return hour * 60 + minute;
+    } else {
+      const match = cleanTime.match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?$/);
+      if (!match) return null;
+      const [, hourStr, minuteStr] = match;
+      const hour = parseInt(hourStr, 10);
+      const minute = parseInt(minuteStr, 10);
+      if (hour < 0 || hour > 23 || minute < 0 || minute > 59) {
+        return null;
+      }
+      return hour * 60 + minute;
+    }
+  } catch {
+    return null;
+  }
+};
+var validateTimeFormat = (value, format) => {
+  const pattern = TIME_PATTERNS[format];
+  return pattern.test(value.trim());
+};
+var normalizeTime = (timeStr, format) => {
+  const cleanTime = timeStr.trim();
+  if (format.includes("A")) {
+    const match = cleanTime.match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?\s?(AM|PM)$/i);
+    if (!match) return null;
+    const [, hourStr, minuteStr, secondStr = "00", period] = match;
+    let hour = parseInt(hourStr, 10);
+    const minute = parseInt(minuteStr, 10);
+    const second = parseInt(secondStr, 10);
+    if (period.toUpperCase() === "PM" && hour !== 12) {
+      hour += 12;
+    } else if (period.toUpperCase() === "AM" && hour === 12) {
+      hour = 0;
+    }
+    return format.includes("ss") ? `${hour.toString().padStart(2, "0")}:${minute.toString().padStart(2, "0")}:${second.toString().padStart(2, "0")}` : `${hour.toString().padStart(2, "0")}:${minute.toString().padStart(2, "0")}`;
+  }
+  if (format === "H:mm") {
+    const match = cleanTime.match(/^(\d{1,2}):(\d{2})$/);
+    if (!match) return null;
+    const [, hourStr, minuteStr] = match;
+    return `${hourStr.padStart(2, "0")}:${minuteStr}`;
+  }
+  return cleanTime;
+};
+function time(options) {
+  const {
+    required = true,
+    format = "HH:mm",
+    min,
+    max,
+    minHour,
+    maxHour,
+    allowedHours,
+    minuteStep,
+    secondStep,
+    includes,
+    excludes,
+    regex,
+    trimMode = "trim",
+    casing = "none",
+    whitelist,
+    whitelistOnly = false,
+    transform,
+    defaultValue,
+    i18n
+  } = options ?? {};
+  const actualDefaultValue = defaultValue ?? (required ? "" : null);
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale2 = getLocale();
+      const customMessages = i18n[currentLocale2];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`common.time.${key}`, params);
+  };
+  const preprocessFn = (val) => {
+    if (val === null || val === void 0) {
+      return actualDefaultValue;
+    }
+    let processed = String(val);
+    switch (trimMode) {
+      case "trim":
+        processed = processed.trim();
+        break;
+      case "trimStart":
+        processed = processed.trimStart();
+        break;
+      case "trimEnd":
+        processed = processed.trimEnd();
+        break;
+      case "none":
+        break;
+    }
+    if (processed === "") {
+      if (whitelist && whitelist.includes("")) {
+        return "";
+      }
+      if (!required) {
+        return actualDefaultValue;
+      }
+      return actualDefaultValue;
+    }
+    switch (casing) {
+      case "upper":
+        processed = processed.toUpperCase();
+        break;
+      case "lower":
+        processed = processed.toLowerCase();
+        break;
+      case "none":
+        break;
+    }
+    if (transform) {
+      processed = transform(processed);
+    }
+    return processed;
+  };
+  const baseSchema = required ? z10.preprocess(preprocessFn, z10.string()) : z10.preprocess(preprocessFn, z10.string().nullable());
+  const schema = baseSchema.refine((val) => {
+    if (val === null) return true;
+    if (required && (val === "" || val === "null" || val === "undefined")) {
+      throw new z10.ZodError([{ code: "custom", message: getMessage("required"), path: [] }]);
+    }
+    if (val === null) return true;
+    if (!required && val === "") return true;
+    if (whitelist && whitelist.length > 0) {
+      if (whitelist.includes(val)) {
+        return true;
+      }
+      if (whitelistOnly) {
+        throw new z10.ZodError([{ code: "custom", message: getMessage("notInWhitelist"), path: [] }]);
+      }
+    }
+    if (regex) {
+      if (!regex.test(val)) {
+        throw new z10.ZodError([{ code: "custom", message: getMessage("customRegex"), path: [] }]);
+      }
+    } else {
+      if (!validateTimeFormat(val, format)) {
+        throw new z10.ZodError([{ code: "custom", message: getMessage("format", { format }), path: [] }]);
+      }
+    }
+    if (includes && !val.includes(includes)) {
+      throw new z10.ZodError([{ code: "custom", message: getMessage("includes", { includes }), path: [] }]);
+    }
+    if (excludes) {
+      const excludeList = Array.isArray(excludes) ? excludes : [excludes];
+      for (const exclude of excludeList) {
+        if (val.includes(exclude)) {
+          throw new z10.ZodError([{ code: "custom", message: getMessage("excludes", { excludes: exclude }), path: [] }]);
+        }
+      }
+    }
+    if (regex) {
+      return true;
+    }
+    const timeMinutes = parseTimeToMinutes(val, format);
+    if (timeMinutes === null) {
+      throw new z10.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }]);
+    }
+    const hour = Math.floor(timeMinutes / 60);
+    if (minHour !== void 0 && hour < minHour) {
+      throw new z10.ZodError([{ code: "custom", message: getMessage("hour", { minHour, maxHour: maxHour ?? 23 }), path: [] }]);
+    }
+    if (maxHour !== void 0 && hour > maxHour) {
+      throw new z10.ZodError([{ code: "custom", message: getMessage("hour", { minHour: minHour ?? 0, maxHour }), path: [] }]);
+    }
+    if (allowedHours && allowedHours.length > 0) {
+      if (!allowedHours.includes(hour)) {
+        throw new z10.ZodError([{ code: "custom", message: getMessage("hour", { allowedHours: allowedHours.join(", ") }), path: [] }]);
+      }
+    }
+    const minute = timeMinutes % 60;
+    if (minuteStep !== void 0 && minute % minuteStep !== 0) {
+      throw new z10.ZodError([{ code: "custom", message: getMessage("minute", { minuteStep }), path: [] }]);
+    }
+    if (secondStep !== void 0 && format.includes("ss")) {
+      const secondMatch = val.match(/:(\d{2})$/);
+      if (secondMatch) {
+        const seconds = parseInt(secondMatch[1], 10);
+        if (seconds % secondStep !== 0) {
+          throw new z10.ZodError([{ code: "custom", message: getMessage("second", { secondStep }), path: [] }]);
+        }
+      }
+    }
+    if (min) {
+      const minMinutes = parseTimeToMinutes(min, format);
+      if (minMinutes !== null && timeMinutes < minMinutes) {
+        throw new z10.ZodError([{ code: "custom", message: getMessage("min", { min }), path: [] }]);
+      }
+    }
+    if (max) {
+      const maxMinutes = parseTimeToMinutes(max, format);
+      if (maxMinutes !== null && timeMinutes > maxMinutes) {
+        throw new z10.ZodError([{ code: "custom", message: getMessage("max", { max }), path: [] }]);
+      }
+    }
+    return true;
+  });
+  return schema;
+}
+
+// src/validators/common/url.ts
+import { z as z11 } from "zod";
+function url(options) {
+  const {
+    required = true,
+    min,
+    max,
+    includes,
+    excludes,
+    protocols,
+    allowedDomains,
+    blockedDomains,
+    allowedPorts,
+    blockedPorts,
+    pathStartsWith,
+    pathEndsWith,
+    mustHaveQuery,
+    mustNotHaveQuery,
+    mustHaveFragment,
+    mustNotHaveFragment,
+    allowLocalhost = true,
+    blockLocalhost,
+    transform,
+    defaultValue = null,
+    i18n
+  } = options ?? {};
+  const actualDefaultValue = defaultValue ?? (required ? "" : null);
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale2 = getLocale();
+      const customMessages = i18n[currentLocale2];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`common.url.${key}`, params);
+  };
+  const preprocessFn = (val) => {
+    if (val === "" || val === null || val === void 0) {
+      return actualDefaultValue;
+    }
+    let processed = String(val).trim();
+    if (transform) {
+      processed = transform(processed);
+    }
+    return processed;
+  };
+  const baseSchema = required ? z11.preprocess(preprocessFn, z11.string()) : z11.preprocess(preprocessFn, z11.string().nullable());
+  const schema = baseSchema.refine((val) => {
+    if (val === null) return true;
+    if (required && (val === "" || val === "null" || val === "undefined")) {
+      throw new z11.ZodError([{ code: "custom", message: getMessage("required"), path: [] }]);
+    }
+    let urlObj;
+    try {
+      urlObj = new URL(val);
+    } catch {
+      throw new z11.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }]);
+    }
+    if (val !== null && min !== void 0 && val.length < min) {
+      throw new z11.ZodError([{ code: "custom", message: getMessage("min", { min }), path: [] }]);
+    }
+    if (val !== null && max !== void 0 && val.length > max) {
+      throw new z11.ZodError([{ code: "custom", message: getMessage("max", { max }), path: [] }]);
+    }
+    if (val !== null && includes !== void 0 && !val.includes(includes)) {
+      throw new z11.ZodError([{ code: "custom", message: getMessage("includes", { includes }), path: [] }]);
+    }
+    if (val !== null && excludes !== void 0) {
+      const excludeList = Array.isArray(excludes) ? excludes : [excludes];
+      for (const exclude of excludeList) {
+        if (val.includes(exclude)) {
+          throw new z11.ZodError([{ code: "custom", message: getMessage("excludes", { excludes: exclude }), path: [] }]);
+        }
+      }
+    }
+    if (protocols && !protocols.includes(urlObj.protocol.slice(0, -1))) {
+      throw new z11.ZodError([{ code: "custom", message: getMessage("protocol", { protocols: protocols.join(", ") }), path: [] }]);
+    }
+    const hostname = urlObj.hostname.toLowerCase();
+    if (allowedDomains && !allowedDomains.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`))) {
+      throw new z11.ZodError([{ code: "custom", message: getMessage("domain", { domains: allowedDomains.join(", ") }), path: [] }]);
+    }
+    if (blockedDomains && blockedDomains.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`))) {
+      const blockedDomain = blockedDomains.find((domain) => hostname === domain || hostname.endsWith(`.${domain}`));
+      throw new z11.ZodError([{ code: "custom", message: getMessage("domainBlacklist", { domain: blockedDomain }), path: [] }]);
+    }
+    const port = urlObj.port ? parseInt(urlObj.port) : urlObj.protocol === "https:" ? 443 : 80;
+    if (allowedPorts && !allowedPorts.includes(port)) {
+      throw new z11.ZodError([{ code: "custom", message: getMessage("port", { ports: allowedPorts.join(", ") }), path: [] }]);
+    }
+    if (blockedPorts && blockedPorts.includes(port)) {
+      throw new z11.ZodError([{ code: "custom", message: getMessage("port", { port }), path: [] }]);
+    }
+    if (pathStartsWith && !urlObj.pathname.startsWith(pathStartsWith)) {
+      throw new z11.ZodError([{ code: "custom", message: getMessage("pathStartsWith", { path: pathStartsWith }), path: [] }]);
+    }
+    if (pathEndsWith && !urlObj.pathname.endsWith(pathEndsWith)) {
+      throw new z11.ZodError([{ code: "custom", message: getMessage("pathEndsWith", { path: pathEndsWith }), path: [] }]);
+    }
+    if (mustHaveQuery && !urlObj.search) {
+      throw new z11.ZodError([{ code: "custom", message: getMessage("hasQuery"), path: [] }]);
+    }
+    if (mustNotHaveQuery && urlObj.search) {
+      throw new z11.ZodError([{ code: "custom", message: getMessage("noQuery"), path: [] }]);
+    }
+    if (mustHaveFragment && !urlObj.hash) {
+      throw new z11.ZodError([{ code: "custom", message: getMessage("hasFragment"), path: [] }]);
+    }
+    if (mustNotHaveFragment && urlObj.hash) {
+      throw new z11.ZodError([{ code: "custom", message: getMessage("noFragment"), path: [] }]);
+    }
+    const isLocalhost = hostname === "localhost" || hostname === "127.0.0.1" || hostname.startsWith("192.168.") || hostname.startsWith("10.") || hostname.match(/^172\.(1[6-9]|2[0-9]|3[0-1])\./);
+    if (blockLocalhost && isLocalhost) {
+      throw new z11.ZodError([{ code: "custom", message: getMessage("noLocalhost"), path: [] }]);
+    }
+    if (!allowLocalhost && isLocalhost) {
+      throw new z11.ZodError([{ code: "custom", message: getMessage("localhost"), path: [] }]);
+    }
+    return true;
+  });
+  return schema;
+}
+
+// src/validators/taiwan/business-id.ts
+import { z as z12 } from "zod";
+var validateTaiwanBusinessId = (value) => {
+  if (!/^\d{8}$/.test(value)) {
+    return false;
+  }
+  const digits = value.split("").map(Number);
+  const coefficients = [1, 2, 1, 2, 1, 2, 4];
+  let sum = 0;
+  for (let i = 0; i < 7; i++) {
+    const product = digits[i] * coefficients[i];
+    sum += Math.floor(product / 10) + product % 10;
+  }
+  sum += digits[7];
+  if (sum % 5 === 0) {
+    return true;
+  }
+  if (sum % 10 === 0) {
+    return true;
+  }
+  if (digits[6] === 7) {
+    let altSum = 0;
+    for (let i = 0; i < 7; i++) {
+      const product = digits[i] * coefficients[i];
+      altSum += Math.floor(product / 10) + product % 10;
+    }
+    altSum += 1 + digits[7];
+    if (altSum % 5 === 0 || altSum % 10 === 0) {
+      return true;
+    }
+  }
+  return false;
+};
+function businessId(options) {
+  const {
+    required = true,
+    transform,
+    defaultValue,
+    i18n
+  } = options ?? {};
+  const actualDefaultValue = defaultValue ?? (required ? "" : null);
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale2 = getLocale();
+      const customMessages = i18n[currentLocale2];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`taiwan.businessId.${key}`, params);
+  };
+  const preprocessFn = (val) => {
+    if (val === "" || val === null || val === void 0) {
+      return actualDefaultValue;
+    }
+    let processed = String(val).trim();
+    if (processed === "" && !required) {
+      return null;
+    }
+    if (transform) {
+      processed = transform(processed);
+    }
+    return processed;
+  };
+  const baseSchema = required ? z12.preprocess(preprocessFn, z12.string()) : z12.preprocess(preprocessFn, z12.string().nullable());
+  const schema = baseSchema.refine((val) => {
+    if (val === null) return true;
+    if (required && (val === "" || val === "null" || val === "undefined")) {
+      throw new z12.ZodError([{ code: "custom", message: getMessage("required"), path: [] }]);
+    }
+    if (val === null) return true;
+    if (!required && val === "") return true;
+    if (!validateTaiwanBusinessId(val)) {
+      throw new z12.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }]);
+    }
+    return true;
+  });
+  return schema;
+}
+
+// src/validators/taiwan/national-id.ts
+import { z as z13 } from "zod";
+var CITY_CODES = {
+  "A": 10,
+  "B": 11,
+  "C": 12,
+  "D": 13,
+  "E": 14,
+  "F": 15,
+  "G": 16,
+  "H": 17,
+  "I": 34,
+  "J": 18,
+  "K": 19,
+  "L": 20,
+  "M": 21,
+  "N": 22,
+  "O": 35,
+  "P": 23,
+  "Q": 24,
+  "R": 25,
+  "S": 26,
+  "T": 27,
+  "U": 28,
+  "V": 29,
+  "W": 32,
+  "X": 30,
+  "Y": 31,
+  "Z": 33
+};
+var validateCitizenId = (value) => {
+  if (!/^[A-Z][1-2]\d{8}$/.test(value)) {
+    return false;
+  }
+  const letter = value[0];
+  const digits = value.slice(1).split("").map(Number);
+  const cityCode = CITY_CODES[letter];
+  if (!cityCode) return false;
+  const cityDigits = [Math.floor(cityCode / 10), cityCode % 10];
+  const coefficients = [1, 9, 8, 7, 6, 5, 4, 3, 2, 1];
+  let sum = cityDigits[0] * coefficients[0] + cityDigits[1] * coefficients[1];
+  for (let i = 0; i < 8; i++) {
+    sum += digits[i] * coefficients[i + 2];
+  }
+  const checksum = (10 - sum % 10) % 10;
+  return checksum === digits[8];
+};
+var validateOldResidentId = (value) => {
+  if (!/^[A-Z][ABCD]\d{8}$/.test(value)) {
+    return false;
+  }
+  const letter = value[0];
+  const genderCode = value[1];
+  const digits = value.slice(2).split("").map(Number);
+  const cityCode = CITY_CODES[letter];
+  if (!cityCode) return false;
+  const genderValue = genderCode === "A" || genderCode === "C" ? 1 : 0;
+  const cityDigits = [Math.floor(cityCode / 10), cityCode % 10];
+  const coefficients = [1, 9, 8, 7, 6, 5, 4, 3, 2, 1];
+  let sum = cityDigits[0] * coefficients[0] + cityDigits[1] * coefficients[1] + genderValue * coefficients[2];
+  for (let i = 0; i < 7; i++) {
+    sum += digits[i] * coefficients[i + 3];
+  }
+  const checksum = (10 - sum % 10) % 10;
+  return checksum === digits[7];
+};
+var validateNewResidentId = (value) => {
+  if (!/^[A-Z][89]\d{8}$/.test(value)) {
+    return false;
+  }
+  const letter = value[0];
+  const digits = value.slice(1).split("").map(Number);
+  const cityCode = CITY_CODES[letter];
+  if (!cityCode) return false;
+  const cityDigits = [Math.floor(cityCode / 10), cityCode % 10];
+  const coefficients = [1, 9, 8, 7, 6, 5, 4, 3, 2, 1];
+  let sum = cityDigits[0] * coefficients[0] + cityDigits[1] * coefficients[1];
+  for (let i = 0; i < 8; i++) {
+    sum += digits[i] * coefficients[i + 2];
+  }
+  const checksum = (10 - sum % 10) % 10;
+  return checksum === digits[8];
+};
+var validateTaiwanNationalId = (value, type = "both", allowOldResident = true) => {
+  if (!/^[A-Z].{9}$/.test(value)) {
+    return false;
+  }
+  switch (type) {
+    case "citizen":
+      return validateCitizenId(value);
+    case "resident":
+      return (allowOldResident ? validateOldResidentId(value) : false) || validateNewResidentId(value);
+    case "both":
+      return validateCitizenId(value) || (allowOldResident ? validateOldResidentId(value) : false) || validateNewResidentId(value);
+    default:
+      return false;
+  }
+};
+function nationalId(options) {
+  const {
+    required = true,
+    type = "both",
+    allowOldResident = true,
+    transform,
+    defaultValue,
+    i18n
+  } = options ?? {};
+  const actualDefaultValue = defaultValue ?? (required ? "" : null);
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale2 = getLocale();
+      const customMessages = i18n[currentLocale2];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`taiwan.nationalId.${key}`, params);
+  };
+  const preprocessFn = (val) => {
+    if (val === "" || val === null || val === void 0) {
+      return actualDefaultValue;
+    }
+    let processed = String(val).trim().toUpperCase();
+    if (processed === "" && !required) {
+      return null;
+    }
+    if (transform) {
+      processed = transform(processed);
+    }
+    return processed;
+  };
+  const baseSchema = required ? z13.preprocess(preprocessFn, z13.string()) : z13.preprocess(preprocessFn, z13.string().nullable());
+  const schema = baseSchema.refine((val) => {
+    if (val === null) return true;
+    if (required && (val === "" || val === "null" || val === "undefined")) {
+      throw new z13.ZodError([{ code: "custom", message: getMessage("required"), path: [] }]);
+    }
+    if (val === null) return true;
+    if (!required && val === "") return true;
+    if (!validateTaiwanNationalId(val, type, allowOldResident)) {
+      throw new z13.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }]);
+    }
+    return true;
+  });
+  return schema;
+}
+
+// src/validators/taiwan/mobile.ts
+import { z as z14 } from "zod";
+var validateTaiwanMobile = (value) => {
+  return /^09[0-9]\d{7}$/.test(value);
+};
+function mobile(options) {
+  const { required = true, whitelist, transform, defaultValue, i18n } = options ?? {};
+  const actualDefaultValue = defaultValue ?? (required ? "" : null);
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale2 = getLocale();
+      const customMessages = i18n[currentLocale2];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`taiwan.mobile.${key}`, params);
+  };
+  const preprocessFn = (val) => {
+    if (val === null || val === void 0) {
+      return actualDefaultValue;
+    }
+    let processed = String(val).trim();
+    if (processed === "") {
+      if (whitelist && whitelist.includes("")) {
+        return "";
+      }
+      if (!required) {
+        return actualDefaultValue;
+      }
+      return actualDefaultValue;
+    }
+    if (transform) {
+      processed = transform(processed);
+    }
+    return processed;
+  };
+  const baseSchema = required ? z14.preprocess(preprocessFn, z14.string()) : z14.preprocess(preprocessFn, z14.string().nullable());
+  const schema = baseSchema.refine((val) => {
+    if (val === null) return true;
+    if (required && (val === "" || val === "null" || val === "undefined")) {
+      throw new z14.ZodError([{ code: "custom", message: getMessage("required"), path: [] }]);
+    }
+    if (val === null) return true;
+    if (!required && val === "") return true;
+    if (whitelist && whitelist.length > 0) {
+      if (whitelist.includes(val)) {
+        return true;
+      }
+      throw new z14.ZodError([{ code: "custom", message: getMessage("notInWhitelist"), path: [] }]);
+    }
+    if (!validateTaiwanMobile(val)) {
+      throw new z14.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }]);
+    }
+    return true;
+  });
+  return schema;
+}
+
+// src/validators/taiwan/postal-code.ts
+import { z as z15 } from "zod";
+var VALID_3_DIGIT_PREFIXES = [
+  // Taipei City (台北市) - 100-116
+  "100",
+  "103",
+  "104",
+  "105",
+  "106",
+  "108",
+  "110",
+  "111",
+  "112",
+  "114",
+  "115",
+  "116",
+  // New Taipei City (新北市) - 200-253
+  "200",
+  "201",
+  "202",
+  "203",
+  "204",
+  "205",
+  "206",
+  "207",
+  "208",
+  "220",
+  "221",
+  "222",
+  "223",
+  "224",
+  "226",
+  "227",
+  "228",
+  "231",
+  "232",
+  "233",
+  "234",
+  "235",
+  "236",
+  "237",
+  "238",
+  "239",
+  "241",
+  "242",
+  "243",
+  "244",
+  "247",
+  "248",
+  "249",
+  "251",
+  "252",
+  "253",
+  // Keelung City (基隆市) - 200-206
+  "200",
+  "201",
+  "202",
+  "203",
+  "204",
+  "205",
+  "206",
+  // Taoyuan City (桃園市) - 300-338
+  "300",
+  "302",
+  "303",
+  "304",
+  "305",
+  "306",
+  "307",
+  "308",
+  "310",
+  "311",
+  "312",
+  "313",
+  "314",
+  "315",
+  "316",
+  "317",
+  "318",
+  "320",
+  "324",
+  "325",
+  "326",
+  "327",
+  "328",
+  "330",
+  "333",
+  "334",
+  "335",
+  "336",
+  "337",
+  "338",
+  // Hsinchu County (新竹縣) - 300-315
+  "300",
+  "302",
+  "303",
+  "304",
+  "305",
+  "306",
+  "307",
+  "308",
+  "310",
+  "311",
+  "312",
+  "313",
+  "314",
+  "315",
+  // Hsinchu City (新竹市) - 300
+  "300",
+  // Miaoli County (苗栗縣) - 350-369
+  "350",
+  "351",
+  "352",
+  "353",
+  "354",
+  "356",
+  "357",
+  "358",
+  "360",
+  "361",
+  "362",
+  "363",
+  "364",
+  "365",
+  "366",
+  "367",
+  "368",
+  "369",
+  // Taichung City (台中市) - 400-439
+  "400",
+  "401",
+  "402",
+  "403",
+  "404",
+  "406",
+  "407",
+  "408",
+  "411",
+  "412",
+  "413",
+  "414",
+  "420",
+  "421",
+  "422",
+  "423",
+  "424",
+  "426",
+  "427",
+  "428",
+  "429",
+  "432",
+  "433",
+  "434",
+  "435",
+  "436",
+  "437",
+  "438",
+  "439",
+  // Changhua County (彰化縣) - 500-530
+  "500",
+  "502",
+  "503",
+  "504",
+  "505",
+  "506",
+  "507",
+  "508",
+  "509",
+  "510",
+  "511",
+  "512",
+  "513",
+  "514",
+  "515",
+  "516",
+  "520",
+  "521",
+  "522",
+  "523",
+  "524",
+  "525",
+  "526",
+  "527",
+  "528",
+  "530",
+  // Nantou County (南投縣) - 540-558
+  "540",
+  "541",
+  "542",
+  "544",
+  "545",
+  "546",
+  "551",
+  "552",
+  "553",
+  "555",
+  "556",
+  "557",
+  "558",
+  // Yunlin County (雲林縣) - 630-655
+  "630",
+  "631",
+  "632",
+  "633",
+  "634",
+  "635",
+  "636",
+  "637",
+  "638",
+  "640",
+  "643",
+  "646",
+  "647",
+  "648",
+  "649",
+  "651",
+  "652",
+  "653",
+  "654",
+  "655",
+  // Chiayi County (嘉義縣) - 600-625
+  "600",
+  "602",
+  "603",
+  "604",
+  "605",
+  "606",
+  "607",
+  "608",
+  "611",
+  "612",
+  "613",
+  "614",
+  "615",
+  "616",
+  "621",
+  "622",
+  "623",
+  "624",
+  "625",
+  // Chiayi City (嘉義市) - 600
+  "600",
+  // Tainan City (台南市) - 700-745
+  "700",
+  "701",
+  "702",
+  "704",
+  "708",
+  "709",
+  "710",
+  "711",
+  "712",
+  "713",
+  "714",
+  "715",
+  "716",
+  "717",
+  "718",
+  "719",
+  "720",
+  "721",
+  "722",
+  "723",
+  "724",
+  "725",
+  "726",
+  "727",
+  "730",
+  "731",
+  "732",
+  "733",
+  "734",
+  "735",
+  "736",
+  "737",
+  "741",
+  "742",
+  "743",
+  "744",
+  "745",
+  // Kaohsiung City (高雄市) - 800-852
+  "800",
+  "801",
+  "802",
+  "803",
+  "804",
+  "805",
+  "806",
+  "807",
+  "811",
+  "812",
+  "813",
+  "814",
+  "815",
+  "820",
+  "821",
+  "822",
+  "823",
+  "824",
+  "825",
+  "826",
+  "827",
+  "828",
+  "829",
+  "830",
+  "831",
+  "832",
+  "833",
+  "840",
+  "842",
+  "843",
+  "844",
+  "845",
+  "846",
+  "847",
+  "848",
+  "849",
+  "851",
+  "852",
+  // Pingtung County (屏東縣) - 900-947
+  "900",
+  "901",
+  "902",
+  "903",
+  "904",
+  "905",
+  "906",
+  "907",
+  "908",
+  "909",
+  "911",
+  "912",
+  "913",
+  "920",
+  "921",
+  "922",
+  "923",
+  "924",
+  "925",
+  "926",
+  "927",
+  "928",
+  "929",
+  "931",
+  "932",
+  "940",
+  "941",
+  "942",
+  "943",
+  "944",
+  "945",
+  "946",
+  "947",
+  // Yilan County (宜蘭縣) - 260-269
+  "260",
+  "261",
+  "262",
+  "263",
+  "264",
+  "265",
+  "266",
+  "267",
+  "268",
+  "269",
+  // Hualien County (花蓮縣) - 970-983
+  "970",
+  "971",
+  "972",
+  "973",
+  "974",
+  "975",
+  "976",
+  "977",
+  "978",
+  "979",
+  "981",
+  "982",
+  "983",
+  // Taitung County (台東縣) - 950-966
+  "950",
+  "951",
+  "952",
+  "953",
+  "954",
+  "955",
+  "956",
+  "957",
+  "958",
+  "959",
+  "961",
+  "962",
+  "963",
+  "964",
+  "965",
+  "966",
+  // Penghu County (澎湖縣) - 880-885
+  "880",
+  "881",
+  "882",
+  "883",
+  "884",
+  "885",
+  // Kinmen County (金門縣) - 890-896
+  "890",
+  "891",
+  "892",
+  "893",
+  "894",
+  "895",
+  "896",
+  // Lienchiang County (連江縣/馬祖) - 209-212
+  "209",
+  "210",
+  "211",
+  "212"
+];
+var POSTAL_CODE_RANGES = {
+  // Major cities with extensive postal networks
+  "100": { range5: [1, 99], range6: [1, 999] },
+  // Taipei City - Zhongzheng
+  "103": { range5: [1, 99], range6: [1, 999] },
+  // Taipei City - Datong
+  "104": { range5: [1, 99], range6: [1, 999] },
+  // Taipei City - Zhongshan
+  "105": { range5: [1, 99], range6: [1, 999] },
+  // Taipei City - Songshan
+  "106": { range5: [1, 99], range6: [1, 999] },
+  // Taipei City - Da'an
+  "108": { range5: [1, 99], range6: [1, 999] },
+  // Taipei City - Wanhua
+  "110": { range5: [1, 99], range6: [1, 999] },
+  // Taipei City - Xinyi
+  "111": { range5: [1, 99], range6: [1, 999] },
+  // Taipei City - Shilin
+  "112": { range5: [1, 99], range6: [1, 999] },
+  // Taipei City - Beitou
+  "114": { range5: [1, 99], range6: [1, 999] },
+  // Taipei City - Neihu
+  "115": { range5: [1, 99], range6: [1, 999] },
+  // Taipei City - Nangang
+  "116": { range5: [1, 99], range6: [1, 999] },
+  // Taipei City - Wenshan
+  // New Taipei City major areas
+  "220": { range5: [1, 99], range6: [1, 999] },
+  // Banqiao
+  "221": { range5: [1, 99], range6: [1, 999] },
+  // Xizhi
+  "222": { range5: [1, 99], range6: [1, 999] },
+  // Shenkeng
+  "223": { range5: [1, 99], range6: [1, 999] },
+  // Shiding
+  "224": { range5: [1, 99], range6: [1, 999] },
+  // Ruifang
+  // Taoyuan City
+  "320": { range5: [1, 99], range6: [1, 999] },
+  // Zhongli
+  "324": { range5: [1, 99], range6: [1, 999] },
+  // Pingzhen
+  "330": { range5: [1, 99], range6: [1, 999] },
+  // Taoyuan
+  // Taichung City
+  "400": { range5: [1, 99], range6: [1, 999] },
+  // Central District
+  "401": { range5: [1, 99], range6: [1, 999] },
+  // East District
+  "402": { range5: [1, 99], range6: [1, 999] },
+  // South District
+  "403": { range5: [1, 99], range6: [1, 999] },
+  // West District
+  "404": { range5: [1, 99], range6: [1, 999] },
+  // North District
+  // Tainan City
+  "700": { range5: [1, 99], range6: [1, 999] },
+  // Central District
+  "701": { range5: [1, 99], range6: [1, 999] },
+  // East District
+  "702": { range5: [1, 99], range6: [1, 999] },
+  // South District
+  // Kaohsiung City
+  "800": { range5: [1, 99], range6: [1, 999] },
+  // Xinxing
+  "801": { range5: [1, 99], range6: [1, 999] },
+  // Qianjin
+  "802": { range5: [1, 99], range6: [1, 999] },
+  // Lingya
+  "803": { range5: [1, 99], range6: [1, 999] },
+  // Yancheng
+  // Smaller areas with more limited ranges
+  "880": { range5: [1, 50], range6: [1, 500] },
+  // Penghu (smaller population)
+  "890": { range5: [1, 30], range6: [1, 300] },
+  // Kinmen (smaller population)
+  "209": { range5: [1, 20], range6: [1, 200] }
+  // Lienchiang/Matsu (smallest population)
+};
+var getPostalCodeRanges = (prefix) => {
+  return POSTAL_CODE_RANGES[prefix] || {
+    range5: [1, 99],
+    // Default range for 5-digit
+    range6: [1, 999]
+    // Default range for 6-digit
+  };
+};
+var validate3DigitPostalCode = (value, strictValidation = true, allowedPrefixes, blockedPrefixes) => {
+  if (!/^\d{3}$/.test(value)) {
+    return false;
+  }
+  if (blockedPrefixes && blockedPrefixes.includes(value)) {
+    return false;
+  }
+  if (allowedPrefixes) {
+    return allowedPrefixes.includes(value);
+  }
+  if (strictValidation) {
+    return VALID_3_DIGIT_PREFIXES.includes(value);
+  }
+  const num = parseInt(value, 10);
+  return num >= 100 && num <= 999;
+};
+var validate5DigitPostalCode = (value, strictValidation = true, strictSuffixValidation = false, allowedPrefixes, blockedPrefixes) => {
+  if (!/^\d{5}$/.test(value)) {
+    return false;
+  }
+  const prefix = value.substring(0, 3);
+  const suffix = value.substring(3, 5);
+  if (!validate3DigitPostalCode(prefix, strictValidation, allowedPrefixes, blockedPrefixes)) {
+    return false;
+  }
+  if (strictSuffixValidation) {
+    const suffixNum = parseInt(suffix, 10);
+    const ranges = getPostalCodeRanges(prefix);
+    if (suffixNum < ranges.range5[0] || suffixNum > ranges.range5[1]) {
+      return false;
+    }
+  }
+  return true;
+};
+var validate6DigitPostalCode = (value, strictValidation = true, strictSuffixValidation = false, allowedPrefixes, blockedPrefixes) => {
+  if (!/^\d{6}$/.test(value)) {
+    return false;
+  }
+  const prefix = value.substring(0, 3);
+  const suffix = value.substring(3, 6);
+  if (!validate3DigitPostalCode(prefix, strictValidation, allowedPrefixes, blockedPrefixes)) {
+    return false;
+  }
+  if (strictSuffixValidation) {
+    const suffixNum = parseInt(suffix, 10);
+    const ranges = getPostalCodeRanges(prefix);
+    if (suffixNum < ranges.range6[0] || suffixNum > ranges.range6[1]) {
+      return false;
+    }
+  }
+  return true;
+};
+var validateTaiwanPostalCode = (value, format = "3+6", strictValidation = true, strictSuffixValidation = false, allowDashes = true, allowedPrefixes, blockedPrefixes) => {
+  if (!value || typeof value !== "string") {
+    return false;
+  }
+  const cleanValue = allowDashes ? value.replace(/[-\s]/g, "") : value;
+  if (!allowDashes && /[-\s]/.test(value)) {
+    return false;
+  }
+  switch (format) {
+    case "3":
+      return cleanValue.length === 3 && validate3DigitPostalCode(cleanValue, strictValidation, allowedPrefixes, blockedPrefixes);
+    case "5":
+      return cleanValue.length === 5 && validate5DigitPostalCode(cleanValue, strictValidation, strictSuffixValidation, allowedPrefixes, blockedPrefixes);
+    case "6":
+      return cleanValue.length === 6 && validate6DigitPostalCode(cleanValue, strictValidation, strictSuffixValidation, allowedPrefixes, blockedPrefixes);
+    case "3+5":
+      return cleanValue.length === 3 && validate3DigitPostalCode(cleanValue, strictValidation, allowedPrefixes, blockedPrefixes) || cleanValue.length === 5 && validate5DigitPostalCode(cleanValue, strictValidation, strictSuffixValidation, allowedPrefixes, blockedPrefixes);
+    case "3+6":
+      return cleanValue.length === 3 && validate3DigitPostalCode(cleanValue, strictValidation, allowedPrefixes, blockedPrefixes) || cleanValue.length === 6 && validate6DigitPostalCode(cleanValue, strictValidation, strictSuffixValidation, allowedPrefixes, blockedPrefixes);
+    case "5+6":
+      return cleanValue.length === 5 && validate5DigitPostalCode(cleanValue, strictValidation, strictSuffixValidation, allowedPrefixes, blockedPrefixes) || cleanValue.length === 6 && validate6DigitPostalCode(cleanValue, strictValidation, strictSuffixValidation, allowedPrefixes, blockedPrefixes);
+    case "all":
+      return cleanValue.length === 3 && validate3DigitPostalCode(cleanValue, strictValidation, allowedPrefixes, blockedPrefixes) || cleanValue.length === 5 && validate5DigitPostalCode(cleanValue, strictValidation, strictSuffixValidation, allowedPrefixes, blockedPrefixes) || cleanValue.length === 6 && validate6DigitPostalCode(cleanValue, strictValidation, strictSuffixValidation, allowedPrefixes, blockedPrefixes);
+    default:
+      return false;
+  }
+};
+function postalCode(options) {
+  const {
+    required = true,
+    format = "3+6",
+    strictValidation = true,
+    allowDashes = true,
+    warn5Digit = true,
+    allowedPrefixes,
+    blockedPrefixes,
+    transform,
+    defaultValue,
+    i18n,
+    strictSuffixValidation = false,
+    deprecate5Digit = false
+  } = options ?? {};
+  const actualDefaultValue = defaultValue ?? (required ? "" : null);
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale2 = getLocale();
+      const customMessages = i18n[currentLocale2];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`taiwan.postalCode.${key}`, params);
+  };
+  const preprocessFn = (val) => {
+    if (val === "" || val === null || val === void 0) {
+      return actualDefaultValue;
+    }
+    let processed = String(val).trim();
+    if (allowDashes) {
+      processed = processed.replace(/[-\s]/g, "");
+    }
+    if (processed === "" && !required) {
+      return null;
+    }
+    if (transform) {
+      processed = transform(processed);
+    }
+    return processed;
+  };
+  const baseSchema = required ? z15.preprocess(preprocessFn, z15.string()) : z15.preprocess(preprocessFn, z15.string().nullable());
+  const schema = baseSchema.refine((val) => {
+    if (val === null) return true;
+    if (required && (val === "" || val === "null" || val === "undefined")) {
+      throw new z15.ZodError([{ code: "custom", message: getMessage("required"), path: [] }]);
+    }
+    if (val === null) return true;
+    if (!required && val === "") return true;
+    const cleanValue = val.replace(/[-\s]/g, "");
+    if (format === "3" && cleanValue.length !== 3) {
+      throw new z15.ZodError([{ code: "custom", message: getMessage("format3Only"), path: [] }]);
+    }
+    if (format === "5" && cleanValue.length !== 5) {
+      throw new z15.ZodError([{ code: "custom", message: getMessage("format5Only"), path: [] }]);
+    }
+    if (format === "6" && cleanValue.length !== 6) {
+      throw new z15.ZodError([{ code: "custom", message: getMessage("format6Only"), path: [] }]);
+    }
+    if (deprecate5Digit && cleanValue.length === 5) {
+      throw new z15.ZodError([{ code: "custom", message: getMessage("deprecated5Digit"), path: [] }]);
+    }
+    if (strictSuffixValidation) {
+      if (cleanValue.length === 5) {
+        const prefix = cleanValue.substring(0, 3);
+        const suffix = cleanValue.substring(3, 5);
+        const suffixNum = parseInt(suffix, 10);
+        const ranges = getPostalCodeRanges(prefix);
+        if (suffixNum < ranges.range5[0] || suffixNum > ranges.range5[1]) {
+          throw new z15.ZodError([{ code: "custom", message: getMessage("invalidSuffix"), path: [] }]);
+        }
+      } else if (cleanValue.length === 6) {
+        const prefix = cleanValue.substring(0, 3);
+        const suffix = cleanValue.substring(3, 6);
+        const suffixNum = parseInt(suffix, 10);
+        const ranges = getPostalCodeRanges(prefix);
+        if (suffixNum < ranges.range6[0] || suffixNum > ranges.range6[1]) {
+          throw new z15.ZodError([{ code: "custom", message: getMessage("invalidSuffix"), path: [] }]);
+        }
+      }
+    }
+    if (!validateTaiwanPostalCode(val, format, strictValidation, strictSuffixValidation, allowDashes, allowedPrefixes, blockedPrefixes)) {
+      throw new z15.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }]);
+    }
+    if (warn5Digit && cleanValue.length === 5 && format !== "5" && !deprecate5Digit) {
+      console.warn(getMessage("legacy5DigitWarning"));
+    }
+    return true;
+  });
+  return schema;
+}
+
+// src/validators/taiwan/tel.ts
+import { z as z16 } from "zod";
+var validateTaiwanTel = (value) => {
+  const cleanValue = value.replace(/[-\s]/g, "");
+  if (!/^0\d{7,10}$/.test(cleanValue)) {
+    return false;
+  }
+  const areaCode4 = cleanValue.substring(0, 4);
+  if (areaCode4 === "0826") {
+    return cleanValue.length === 9 && /^0826[6]\d{4}$/.test(cleanValue);
+  }
+  if (areaCode4 === "0836") {
+    return cleanValue.length === 9 && /^0836[2-9]\d{4}$/.test(cleanValue);
+  }
+  const areaCode3 = cleanValue.substring(0, 3);
+  if (areaCode3 === "037") {
+    return cleanValue.length === 9 && /^037[2-9]\d{5}$/.test(cleanValue);
+  }
+  if (areaCode3 === "049") {
+    return cleanValue.length === 10 && /^049[2-9]\d{6}$/.test(cleanValue);
+  }
+  if (areaCode3 === "082") {
+    return cleanValue.length === 9 && /^082[2-57-9]\d{5}$/.test(cleanValue);
+  }
+  if (areaCode3 === "089") {
+    return cleanValue.length === 9 && /^089[2-9]\d{5}$/.test(cleanValue);
+  }
+  const areaCode2 = cleanValue.substring(0, 2);
+  if (areaCode2 === "02") {
+    return cleanValue.length === 10 && /^02[235-8]\d{7}$/.test(cleanValue);
+  }
+  if (["03", "04", "05", "06"].includes(areaCode2)) {
+    return cleanValue.length === 9;
+  }
+  if (areaCode2 === "07") {
+    return cleanValue.length === 9 && /^07[2-9]\d{6}$/.test(cleanValue);
+  }
+  if (areaCode2 === "08") {
+    return cleanValue.length === 9 && /^08[478]\d{6}$/.test(cleanValue);
+  }
+  return false;
+};
+function tel(options) {
+  const { required = true, whitelist, transform, defaultValue, i18n } = options ?? {};
+  const actualDefaultValue = defaultValue ?? (required ? "" : null);
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale2 = getLocale();
+      const customMessages = i18n[currentLocale2];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`taiwan.tel.${key}`, params);
+  };
+  const preprocessFn = (val) => {
+    if (val === null || val === void 0) {
+      return actualDefaultValue;
+    }
+    let processed = String(val).trim();
+    if (processed === "") {
+      if (whitelist && whitelist.includes("")) {
+        return "";
+      }
+      if (!required) {
+        return actualDefaultValue;
+      }
+      return actualDefaultValue;
+    }
+    if (transform) {
+      processed = transform(processed);
+    }
+    return processed;
+  };
+  const baseSchema = required ? z16.preprocess(preprocessFn, z16.string()) : z16.preprocess(preprocessFn, z16.string().nullable());
+  const schema = baseSchema.refine((val) => {
+    if (val === null) return true;
+    if (required && (val === "" || val === "null" || val === "undefined")) {
+      throw new z16.ZodError([{ code: "custom", message: getMessage("required"), path: [] }]);
+    }
+    if (val === null) return true;
+    if (!required && val === "") return true;
+    if (whitelist && whitelist.length > 0) {
+      if (whitelist.includes(val)) {
+        return true;
+      }
+      throw new z16.ZodError([{ code: "custom", message: getMessage("notInWhitelist"), path: [] }]);
+    }
+    if (!validateTaiwanTel(val)) {
+      throw new z16.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }]);
+    }
+    return true;
+  });
+  return schema;
+}
+
+// src/validators/taiwan/fax.ts
+import { z as z17 } from "zod";
+var validateTaiwanFax = (value) => {
+  const cleanValue = value.replace(/[-\s]/g, "");
+  if (!/^0\d{7,10}$/.test(cleanValue)) {
+    return false;
+  }
+  const areaCode4 = cleanValue.substring(0, 4);
+  if (areaCode4 === "0826") {
+    return cleanValue.length === 9 && /^0826[6]\d{4}$/.test(cleanValue);
+  }
+  if (areaCode4 === "0836") {
+    return cleanValue.length === 9 && /^0836[2-9]\d{4}$/.test(cleanValue);
+  }
+  const areaCode3 = cleanValue.substring(0, 3);
+  if (areaCode3 === "037") {
+    return cleanValue.length === 9 && /^037[2-9]\d{5}$/.test(cleanValue);
+  }
+  if (areaCode3 === "049") {
+    return cleanValue.length === 10 && /^049[2-9]\d{6}$/.test(cleanValue);
+  }
+  if (areaCode3 === "082") {
+    return cleanValue.length === 9 && /^082[2-57-9]\d{5}$/.test(cleanValue);
+  }
+  if (areaCode3 === "089") {
+    return cleanValue.length === 9 && /^089[2-9]\d{5}$/.test(cleanValue);
+  }
+  const areaCode2 = cleanValue.substring(0, 2);
+  if (areaCode2 === "02") {
+    return cleanValue.length === 10 && /^02[235-8]\d{7}$/.test(cleanValue);
+  }
+  if (["03", "04", "05", "06"].includes(areaCode2)) {
+    return cleanValue.length === 9;
+  }
+  if (areaCode2 === "07") {
+    return cleanValue.length === 9 && /^07[2-9]\d{6}$/.test(cleanValue);
+  }
+  if (areaCode2 === "08") {
+    return cleanValue.length === 9 && /^08[478]\d{6}$/.test(cleanValue);
+  }
+  return false;
+};
+function fax(options) {
+  const { required = true, whitelist, transform, defaultValue, i18n } = options ?? {};
+  const actualDefaultValue = defaultValue ?? (required ? "" : null);
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale2 = getLocale();
+      const customMessages = i18n[currentLocale2];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`taiwan.fax.${key}`, params);
+  };
+  const preprocessFn = (val) => {
+    if (val === null || val === void 0) {
+      return actualDefaultValue;
+    }
+    let processed = String(val).trim();
+    if (processed === "") {
+      if (whitelist && whitelist.includes("")) {
+        return "";
+      }
+      if (!required) {
+        return actualDefaultValue;
+      }
+      return actualDefaultValue;
+    }
+    if (transform) {
+      processed = transform(processed);
+    }
+    return processed;
+  };
+  const baseSchema = required ? z17.preprocess(preprocessFn, z17.string()) : z17.preprocess(preprocessFn, z17.string().nullable());
+  const schema = baseSchema.refine((val) => {
+    if (val === null) return true;
+    if (required && (val === "" || val === "null" || val === "undefined")) {
+      throw new z17.ZodError([{ code: "custom", message: getMessage("required"), path: [] }]);
+    }
+    if (val === null) return true;
+    if (!required && val === "") return true;
+    if (whitelist && whitelist.length > 0) {
+      if (whitelist.includes(val)) {
+        return true;
+      }
+      throw new z17.ZodError([{ code: "custom", message: getMessage("notInWhitelist"), path: [] }]);
+    }
+    if (!validateTaiwanFax(val)) {
+      throw new z17.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }]);
+    }
+    return true;
   });
   return schema;
 }
 export {
+  DATETIME_PATTERNS,
+  ID_PATTERNS,
+  TIME_PATTERNS,
+  VALID_3_DIGIT_PREFIXES,
   boolean,
+  businessId,
+  date,
+  datetime,
+  detectIdType,
   email,
+  fax,
+  file,
   getLocale,
-  integer,
+  id,
+  mobile,
+  nationalId,
+  normalizeDateTimeValue,
+  normalizeTime,
   number,
+  parseDateTimeValue,
+  parseTimeToMinutes,
   password,
+  postalCode,
   setLocale,
+  tel,
   text,
-  url
+  time,
+  url,
+  validate3DigitPostalCode,
+  validate5DigitPostalCode,
+  validate6DigitPostalCode,
+  validateCitizenId,
+  validateDateTimeFormat,
+  validateIdType,
+  validateNewResidentId,
+  validateOldResidentId,
+  validateTaiwanBusinessId,
+  validateTaiwanFax,
+  validateTaiwanMobile,
+  validateTaiwanNationalId,
+  validateTaiwanPostalCode,
+  validateTaiwanTel,
+  validateTimeFormat
 };