befly 3.10.17 → 3.10.19

package/{checks/checkHook.ts → dist/checks/checkHook.js}

@@ -1,11 +1,8 @@
 import { isPlainObject } from "es-toolkit/compat";
 import { omit } from "es-toolkit/object";
-
 import { Logger } from "../lib/logger.js";
-
-export async function checkHook(hooks: any[]): Promise<void> {
+export async function checkHook(hooks) {
     let hasError = false;
-
     for (const hook of hooks) {
         try {
             if (!isPlainObject(hook)) {
@@ -13,35 +10,29 @@ export async function checkHook(hooks: any[]): Promise<void> {
                 hasError = true;
                 continue;
             }
-
-            if (!Array.isArray((hook as any).deps)) {
+            if (!Array.isArray(hook.deps)) {
                 Logger.warn(omit(hook, ["handler"]), "钩子的 deps 属性必须是字符串数组");
                 hasError = true;
                 continue;
             }
-
-            if ((hook as any).deps.some((depItem: any) => typeof depItem !== "string")) {
+            if (hook.deps.some((depItem) => typeof depItem !== "string")) {
                 Logger.warn(omit(hook, ["handler"]), "钩子的 deps 属性必须是字符串数组");
                 hasError = true;
             }
-
-            if (typeof (hook as any).handler !== "function") {
+            if (typeof hook.handler !== "function") {
                 Logger.warn(omit(hook, ["handler"]), "钩子的 handler 属性必须是函数");
                 hasError = true;
                 continue;
             }
-        } catch (error: any) {
-            Logger.error(
-                {
-                    err: error,
-                    item: hook
-                },
-                "钩子解析失败"
-            );
+        }
+        catch (error) {
+            Logger.error({
+                err: error,
+                item: hook
+            }, "钩子解析失败");
             hasError = true;
         }
     }
-
     if (hasError) {
         throw new Error("钩子结构检查失败");
     }

package/dist/checks/checkMenu.d.ts

@@ -0,0 +1,7 @@
+import type { MenuConfig } from "../types/sync.ts";
+import type { AddonInfo } from "../utils/scanAddons.ts";
+type CheckMenuOptions = {
+    disableMenus?: string[];
+};
+export declare const checkMenu: (addons: AddonInfo[], options?: CheckMenuOptions) => Promise<MenuConfig[]>;
+export {};

package/{checks/checkMenu.ts → dist/checks/checkMenu.js}

@@ -1,11 +1,7 @@
-import type { MenuConfig } from "../types/sync.js";
-import type { AddonInfo } from "../utils/scanAddons.js";
-
 import { Logger } from "../lib/logger.js";
 import { compileDisableMenuGlobRules, isMenuPathDisabledByGlobRules } from "../utils/disableMenusGlob.js";
 import { loadMenuConfigs } from "../utils/loadMenuConfigs.js";
-
-function isValidMenuPath(path: string): { ok: boolean; reason: string } {
+function isValidMenuPath(path) {
     if (!path) {
         return { ok: false, reason: "path 不能为空" };
     }
@@ -23,96 +19,74 @@ function isValidMenuPath(path: string): { ok: boolean; reason: string } {
     }
     return { ok: true, reason: "" };
 }
-
-type CheckMenuOptions = {
-    disableMenus?: string[];
-};
-
-type DisableMenuRule = ReturnType<typeof compileDisableMenuGlobRules>[number];
-
-function filterMenusByDisableRules(mergedMenus: MenuConfig[], rules: DisableMenuRule[]): MenuConfig[] {
+function filterMenusByDisableRules(mergedMenus, rules) {
     if (rules.length === 0) {
         return mergedMenus;
     }
-
-    const filtered: MenuConfig[] = [];
-
+    const filtered = [];
     for (const menu of mergedMenus) {
-        const menuPath = typeof (menu as any)?.path === "string" ? String((menu as any).path).trim() : "";
+        const menuPath = typeof menu?.path === "string" ? String(menu.path).trim() : "";
         if (menuPath && isMenuPathDisabledByGlobRules(menuPath, rules)) {
             continue;
         }
-
-        const children = Array.isArray((menu as any)?.children) ? ((menu as any).children as MenuConfig[]) : null;
+        const children = Array.isArray(menu?.children) ? menu.children : null;
         if (children && children.length > 0) {
             const nextChildren = filterMenusByDisableRules(children, rules);
             if (nextChildren.length > 0) {
-                (menu as any).children = nextChildren;
-            } else {
-                delete (menu as any).children;
+                menu.children = nextChildren;
+            }
+            else {
+                delete menu.children;
             }
         }
-
         filtered.push(menu);
     }
-
     return filtered;
 }
-
-export const checkMenu = async (addons: AddonInfo[], options: CheckMenuOptions = {}): Promise<MenuConfig[]> => {
+export const checkMenu = async (addons, options = {}) => {
     let hasError = false;
-
     const mergedMenus = await loadMenuConfigs(addons);
-
     const disableRules = compileDisableMenuGlobRules(options.disableMenus);
     const filteredMenus = filterMenusByDisableRules(mergedMenus, disableRules);
-
-    const stack: Array<{ menu: any; depth: number }> = [];
+    const stack = [];
     for (const m of filteredMenus) {
         stack.push({ menu: m, depth: 1 });
     }
-
-    const pathSet = new Set<string>();
-
+    const pathSet = new Set();
     while (stack.length > 0) {
-        const current = stack.pop() as { menu: any; depth: number };
+        const current = stack.pop();
         const menu = current?.menu;
         const depth = typeof current?.depth === "number" ? current.depth : 0;
-
         if (menu === null || typeof menu !== "object") {
             hasError = true;
             Logger.warn({ menu: menu }, "菜单节点必须是对象");
             continue;
         }
-
         if (depth > 3) {
             hasError = true;
             Logger.warn({ path: menu?.path, depth: depth }, "菜单层级超过 3 级（最多三级）");
             continue;
         }
-
         const children = menu.children;
         if (typeof children !== "undefined" && !Array.isArray(children)) {
             hasError = true;
             Logger.warn({ path: menu?.path, childrenType: typeof children }, "菜单 children 必须是数组");
             continue;
         }
-
         if (Array.isArray(children) && children.length > 0) {
             if (depth >= 3) {
                 hasError = true;
                 Logger.warn({ path: menu?.path, depth: depth }, "菜单层级超过 3 级（最多三级）");
-            } else {
+            }
+            else {
                 for (const child of children) {
                     stack.push({ menu: child, depth: depth + 1 });
                 }
             }
         }
-
         const path = typeof menu.path === "string" ? menu.path.trim() : "";
         const name = typeof menu.name === "string" ? menu.name.trim() : "";
         const sort = typeof menu.sort === "number" ? menu.sort : 999999;
-
         // 标准化输出（用于后续 syncMenu 直接使用）
         if (typeof menu.path === "string") {
             menu.path = path;
@@ -123,46 +97,37 @@ export const checkMenu = async (addons: AddonInfo[], options: CheckMenuOptions =
         if (typeof menu.sort === "undefined") {
             menu.sort = sort;
         }
-
         if (!path) {
             hasError = true;
             Logger.warn({ menu: menu }, "菜单缺少 path（必须是非空字符串）");
             continue;
         }
-
         const pathCheck = isValidMenuPath(path);
         if (!pathCheck.ok) {
             hasError = true;
             Logger.warn({ path: path, reason: pathCheck.reason }, "菜单 path 不合法");
         }
-
         if (!name) {
             hasError = true;
             Logger.warn({ path: path, menu: menu }, "菜单缺少 name（必须是非空字符串）");
         }
-
         if (typeof menu.sort !== "undefined" && typeof menu.sort !== "number") {
             hasError = true;
             Logger.warn({ path: path, sort: menu.sort }, "菜单 sort 必须是 number");
         }
-
         if (typeof menu.sort === "number" && (!Number.isFinite(menu.sort) || menu.sort < 1)) {
             hasError = true;
             Logger.warn({ path: path, sort: menu.sort }, "菜单 sort 最小值为 1");
         }
-
         if (pathSet.has(path)) {
             hasError = true;
             Logger.warn({ path: path }, "菜单 path 重复（严格模式禁止重复 path）");
             continue;
         }
-
         pathSet.add(path);
     }
-
     if (hasError) {
         throw new Error("菜单结构检查失败");
     }
-
     return filteredMenus;
 };

package/dist/checks/checkPlugin.d.ts

@@ -0,0 +1 @@
+export declare function checkPlugin(plugins: any[]): Promise<void>;

package/{checks/checkPlugin.ts → dist/checks/checkPlugin.js}

@@ -1,11 +1,8 @@
 import { isPlainObject } from "es-toolkit/compat";
 import { omit } from "es-toolkit/object";
-
 import { Logger } from "../lib/logger.js";
-
-export async function checkPlugin(plugins: any[]): Promise<void> {
+export async function checkPlugin(plugins) {
     let hasError = false;
-
     for (const plugin of plugins) {
         try {
             if (!isPlainObject(plugin)) {
@@ -13,35 +10,29 @@ export async function checkPlugin(plugins: any[]): Promise<void> {
                 hasError = true;
                 continue;
             }
-
-            if (!Array.isArray((plugin as any).deps)) {
+            if (!Array.isArray(plugin.deps)) {
                 Logger.warn(omit(plugin, ["handler"]), "插件的 deps 属性必须是字符串数组");
                 hasError = true;
                 continue;
             }
-
-            if ((plugin as any).deps.some((depItem: any) => typeof depItem !== "string")) {
+            if (plugin.deps.some((depItem) => typeof depItem !== "string")) {
                 Logger.warn(omit(plugin, ["handler"]), "插件的 deps 属性必须是字符串数组");
                 hasError = true;
             }
-
-            if (typeof (plugin as any).handler !== "function") {
+            if (typeof plugin.handler !== "function") {
                 Logger.warn(omit(plugin, ["handler"]), "插件的 handler 属性必须是函数");
                 hasError = true;
                 continue;
             }
-        } catch (error: any) {
-            Logger.error(
-                {
-                    err: error,
-                    item: plugin
-                },
-                "插件解析失败"
-            );
+        }
+        catch (error) {
+            Logger.error({
+                err: error,
+                item: plugin
+            }, "插件解析失败");
             hasError = true;
         }
     }
-
     if (hasError) {
         throw new Error("插件结构检查失败");
     }

package/dist/checks/checkTable.d.ts

@@ -0,0 +1,6 @@
+import type { ScanFileResult } from "../utils/scanFiles.ts";
+/**
+ * 检查表定义文件
+ * @throws 当检查失败时抛出异常
+ */
+export declare function checkTable(tables: ScanFileResult[]): Promise<void>;

package/{checks/checkTable.ts → dist/checks/checkTable.js}

@@ -1,23 +1,16 @@
-import type { FieldDefinition } from "../types/validate.js";
-import type { ScanFileResult } from "../utils/scanFiles.js";
-
 import { Logger } from "../lib/logger.js";
-
 /**
  * 保留字段列表
  */
-const RESERVED_FIELDS = ["id", "created_at", "updated_at", "deleted_at", "state"] as const;
-
+const RESERVED_FIELDS = ["id", "created_at", "updated_at", "deleted_at", "state"];
 /**
  * 允许的字段类型
  */
-const FIELD_TYPES = ["string", "number", "text", "array_string", "array_text", "array_number_string", "array_number_text"] as const;
-
+const FIELD_TYPES = ["string", "number", "text", "array_string", "array_text", "array_number_string", "array_number_text"];
 /**
  * 允许的字段属性列表
  */
-const ALLOWED_FIELD_PROPERTIES = ["name", "type", "min", "max", "default", "detail", "index", "unique", "nullable", "unsigned", "regexp"] as const;
-
+const ALLOWED_FIELD_PROPERTIES = ["name", "type", "min", "max", "default", "detail", "index", "unique", "nullable", "unsigned", "regexp"];
 /**
  * 小驼峰命名正则
  * 可选：以下划线开头（用于特殊文件，如通用字段定义）
@@ -25,34 +18,28 @@ const ALLOWED_FIELD_PROPERTIES = ["name", "type", "min", "max", "default", "deta
  * 示例：userTable、testCustomers、common
  */
 const LOWER_CAMEL_CASE_REGEX = /^_?[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/;
-
 /**
  * 字段名称正则
  * 必须为中文、数字、字母、下划线、短横线、空格
  */
 const FIELD_NAME_REGEX = /^[\u4e00-\u9fa5a-zA-Z0-9 _-]+$/;
-
 /**
  * VARCHAR 最大长度限制
  */
 const MAX_VARCHAR_LENGTH = 65535;
-
 /**
  * 检查表定义文件
  * @throws 当检查失败时抛出异常
  */
-export async function checkTable(tables: ScanFileResult[]): Promise<void> {
+export async function checkTable(tables) {
     // 收集所有表文件
     let hasError = false;
-
     // 合并进行验证逻辑
     for (const item of tables) {
         if (item.type !== "table") {
             continue;
         }
-
         const sourceName = typeof item.sourceName === "string" ? item.sourceName : "";
-
         try {
             const fileName = item.fileName;
             const table = item.content || {};
@@ -62,7 +49,6 @@ export async function checkTable(tables: ScanFileResult[]): Promise<void> {
                 hasError = true;
                 continue;
             }
-
             // 检查 table 中的每个验证规则
             for (const [colKey, fieldDef] of Object.entries(table)) {
                 if (typeof fieldDef !== "object" || fieldDef === null || Array.isArray(fieldDef)) {
@@ -70,24 +56,20 @@ export async function checkTable(tables: ScanFileResult[]): Promise<void> {
                     hasError = true;
                     continue;
                 }
-
                 // 检查是否使用了保留字段
-                if (RESERVED_FIELDS.includes(colKey as any)) {
+                if (RESERVED_FIELDS.includes(colKey)) {
                     Logger.warn(`${sourceName}表 ${fileName} 文件包含保留字段 ${colKey}，` + `不能在表定义中使用以下字段: ${RESERVED_FIELDS.join(", ")}`);
                     hasError = true;
                 }
-
                 // 直接使用字段对象
-                const field = fieldDef as FieldDefinition;
-
+                const field = fieldDef;
                 // 检查是否存在非法属性
                 const fieldKeys = Object.keys(field);
-                const illegalProps = fieldKeys.filter((key) => !ALLOWED_FIELD_PROPERTIES.includes(key as any));
+                const illegalProps = fieldKeys.filter((key) => !ALLOWED_FIELD_PROPERTIES.includes(key));
                 if (illegalProps.length > 0) {
                     Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 包含非法属性: ${illegalProps.join(", ")}，` + `允许的属性为: ${ALLOWED_FIELD_PROPERTIES.join(", ")}`);
                     hasError = true;
                 }
-
                 // 检查必填字段：name, type
                 if (!field.name || typeof field.name !== "string") {
                     Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 缺少必填字段 name 或类型错误`);
@@ -99,7 +81,6 @@ export async function checkTable(tables: ScanFileResult[]): Promise<void> {
                     hasError = true;
                     continue;
                 }
-
                 // 检查可选字段的类型
                 if (field.min !== undefined && !(field.min === null || typeof field.min === "number")) {
                     Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 min 类型错误，必须为 null 或数字`);
@@ -133,33 +114,27 @@ export async function checkTable(tables: ScanFileResult[]): Promise<void> {
                     Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段 regexp 类型错误，必须为 null 或字符串`);
                     hasError = true;
                 }
-
                 const { name: fieldName, type: fieldType, min: fieldMin, max: fieldMax, default: fieldDefault } = field;
-
                 // 字段名称必须为中文、数字、字母、下划线、短横线、空格
                 if (!FIELD_NAME_REGEX.test(fieldName)) {
                     Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段名称 "${fieldName}" 格式错误，` + `必须为中文、数字、字母、下划线、短横线、空格`);
                     hasError = true;
                 }
-
                 // 字段类型必须为string,number,text,array_string,array_text之一
-                if (!FIELD_TYPES.includes(fieldType as any)) {
+                if (!FIELD_TYPES.includes(fieldType)) {
                     Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段类型 "${fieldType}" 格式错误，` + `必须为${FIELD_TYPES.join("、")}之一`);
                     hasError = true;
                 }
-
                 // unsigned 仅对 number 类型有效（且仅 MySQL 语义上生效）
                 if (fieldType !== "number" && field.unsigned !== undefined) {
                     Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 字段类型为 ${fieldType}，不允许设置 unsigned（仅 number 类型有效）`);
                     hasError = true;
                 }
-
                 // 约束：unique 与 index 不能同时为 true（否则会重复索引），必须阻断启动。
                 if (field.unique === true && field.index === true) {
                     Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 同时设置了 unique=true 和 index=true，` + `unique 和 index 不能同时设置，请删除其一（否则会创建重复索引）`);
                     hasError = true;
                 }
-
                 // 约束：当最小值与最大值均为数字时，要求最小值 <= 最大值
                 if (fieldMin !== undefined && fieldMax !== undefined && fieldMin !== null && fieldMax !== null) {
                     if (fieldMin > fieldMax) {
@@ -167,7 +142,6 @@ export async function checkTable(tables: ScanFileResult[]): Promise<void> {
                         hasError = true;
                     }
                 }
-
                 // 类型联动校验 + 默认值规则
                 if (fieldType === "text" || fieldType === "array_text" || fieldType === "array_number_text") {
                     // text / array_text / array_number_text：min/max 必须为 null，默认值必须为 null，且不支持索引/唯一约束
@@ -183,7 +157,6 @@ export async function checkTable(tables: ScanFileResult[]): Promise<void> {
                         Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，默认值必须为 null，当前为 "${fieldDefault}"`);
                         hasError = true;
                     }
-
                     if (field.index === true) {
                         Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，不支持创建索引（index=true 无效）`);
                         hasError = true;
@@ -192,15 +165,18 @@ export async function checkTable(tables: ScanFileResult[]): Promise<void> {
                         Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，不支持唯一约束（unique=true 无效）`);
                         hasError = true;
                     }
-                } else if (fieldType === "string" || fieldType === "array_string" || fieldType === "array_number_string") {
+                }
+                else if (fieldType === "string" || fieldType === "array_string" || fieldType === "array_number_string") {
                     if (fieldMax !== undefined && (fieldMax === null || typeof fieldMax !== "number")) {
                         Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，` + `最大长度必须为数字，当前为 "${fieldMax}"`);
                         hasError = true;
-                    } else if (fieldMax !== undefined && fieldMax > MAX_VARCHAR_LENGTH) {
+                    }
+                    else if (fieldMax !== undefined && fieldMax > MAX_VARCHAR_LENGTH) {
                         Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 最大长度 ${fieldMax} 越界，` + `${fieldType} 类型长度必须在 1..${MAX_VARCHAR_LENGTH} 范围内`);
                         hasError = true;
                     }
-                } else if (fieldType === "number") {
+                }
+                else if (fieldType === "number") {
                     // number 类型：default 如果存在，必须为 null 或 number
                     if (fieldDefault !== undefined && fieldDefault !== null && typeof fieldDefault !== "number") {
                         Logger.warn(`${sourceName}表 ${fileName} 文件 ${colKey} 为 number 类型，` + `默认值必须为数字或 null，当前为 "${fieldDefault}"`);
@@ -208,12 +184,12 @@ export async function checkTable(tables: ScanFileResult[]): Promise<void> {
                     }
                 }
             }
-        } catch (error: any) {
+        }
+        catch (error) {
             Logger.error(`${sourceName}表 ${item.fileName} 解析失败`, error);
             hasError = true;
         }
     }
-
     if (hasError) {
         throw new Error("表结构检查失败");
     }

package/dist/configs/presetFields.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 预定义的默认字段（API fields 的 @ 引用）
+ */
+export declare const presetFields: Record<string, any>;

package/{configs/presetFields.ts → dist/configs/presetFields.js}

@@ -1,7 +1,7 @@
 /**
  * 预定义的默认字段（API fields 的 @ 引用）
  */
-export const presetFields: Record<string, any> = {
+export const presetFields = {
     "@id": { name: "ID", type: "number", min: 1, max: null },
     "@page": { name: "页码", type: "number", min: 1, max: 9999, default: 1 },
     "@limit": { name: "每页数量", type: "number", min: 1, max: 100, default: 30 },

package/dist/configs/presetRegexp.d.ts

@@ -0,0 +1,145 @@
+/**
+ * 内置正则表达式别名
+ * 用于表单验证和数据校验
+ * 命名规范：小驼峰格式
+ */
+export declare const RegexAliases: {
+    /** 正整数（不含0） */
+    readonly number: "^\\d+$";
+    /** 整数（含负数） */
+    readonly integer: "^-?\\d+$";
+    /** 浮点数 */
+    readonly float: "^-?\\d+(\\.\\d+)?$";
+    /** 正整数（不含0） */
+    readonly positive: "^[1-9]\\d*$";
+    /** 负整数 */
+    readonly negative: "^-\\d+$";
+    /** 零 */
+    readonly zero: "^0$";
+    /** 纯字母 */
+    readonly word: "^[a-zA-Z]+$";
+    /** 字母和数字 */
+    readonly alphanumeric: "^[a-zA-Z0-9]+$";
+    /** 字母、数字和下划线 */
+    readonly alphanumeric_: "^[a-zA-Z0-9_]+$";
+    /** 字母、数字、下划线和短横线 */
+    readonly alphanumericDash_: "^[a-zA-Z0-9_-]+$";
+    /** 小写字母 */
+    readonly lowercase: "^[a-z]+$";
+    /** 大写字母 */
+    readonly uppercase: "^[A-Z]+$";
+    /** 纯中文 */
+    readonly chinese: "^[\\u4e00-\\u9fa5]+$";
+    /** 中文和字母 */
+    readonly chineseWord: "^[\\u4e00-\\u9fa5a-zA-Z]+$";
+    /** 邮箱地址 */
+    readonly email: "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$";
+    /** 中国大陆手机号 */
+    readonly phone: "^1[3-9]\\d{9}$";
+    /** 固定电话（区号-号码） */
+    readonly telephone: "^0\\d{2,3}-?\\d{7,8}$";
+    /** URL 地址 */
+    readonly url: "^https?://";
+    /** IPv4 地址 */
+    readonly ip: "^((25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(25[0-5]|2[0-4]\\d|[01]?\\d\\d?)$";
+    /** IPv6 地址 */
+    readonly ipv6: "^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$";
+    /** 域名 */
+    readonly domain: "^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]{2,}$";
+    /** UUID */
+    readonly uuid: "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$";
+    /** 十六进制字符串 */
+    readonly hex: "^[0-9a-fA-F]+$";
+    /** Base64 编码 */
+    readonly base64: "^[A-Za-z0-9+/=]+$";
+    /** MD5 哈希 */
+    readonly md5: "^[a-f0-9]{32}$";
+    /** SHA1 哈希 */
+    readonly sha1: "^[a-f0-9]{40}$";
+    /** SHA256 哈希 */
+    readonly sha256: "^[a-f0-9]{64}$";
+    /** 日期 YYYY-MM-DD */
+    readonly date: "^\\d{4}-\\d{2}-\\d{2}$";
+    /** 时间 HH:MM:SS */
+    readonly time: "^\\d{2}:\\d{2}:\\d{2}$";
+    /** ISO 日期时间 */
+    readonly datetime: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}";
+    /** 年份 */
+    readonly year: "^\\d{4}$";
+    /** 月份 01-12 */
+    readonly month: "^(0[1-9]|1[0-2])$";
+    /** 日期 01-31 */
+    readonly day: "^(0[1-9]|[12]\\d|3[01])$";
+    /** 变量名 */
+    readonly variable: "^[a-zA-Z_][a-zA-Z0-9_]*$";
+    /** 常量名（全大写） */
+    readonly constant: "^[A-Z][A-Z0-9_]*$";
+    /** 包名（小写+连字符） */
+    readonly package: "^[a-z][a-z0-9-]*$";
+    /** 中国身份证号（18位） */
+    readonly idCard: "^\\d{17}[\\dXx]$";
+    /** 护照号 */
+    readonly passport: "^[a-zA-Z0-9]{5,17}$";
+    /** 银行卡号（16-19位数字） */
+    readonly bankCard: "^\\d{16,19}$";
+    /** 微信号（6-20位，字母开头，可包含字母、数字、下划线、减号） */
+    readonly wechat: "^[a-zA-Z][a-zA-Z0-9_-]{5,19}$";
+    /** QQ号（5-11位数字，首位非0） */
+    readonly qq: "^[1-9]\\d{4,10}$";
+    /** 支付宝账号（手机号或邮箱） */
+    readonly alipay: "^(1[3-9]\\d{9}|[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,})$";
+    /** 用户名（4-20位，字母开头，可包含字母、数字、下划线） */
+    readonly username: "^[a-zA-Z][a-zA-Z0-9_]{3,19}$";
+    /** 昵称（2-20位，支持中文、字母、数字） */
+    readonly nickname: "^[\\u4e00-\\u9fa5a-zA-Z0-9]{2,20}$";
+    /** 弱密码（至少6位） */
+    readonly passwordWeak: "^.{6,}$";
+    /** 中等密码（至少8位，包含字母和数字） */
+    readonly passwordMedium: "^(?=.*[a-zA-Z])(?=.*\\d).{8,}$";
+    /** 强密码（至少8位，包含大小写字母、数字和特殊字符） */
+    readonly passwordStrong: "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[!@#$%^&*]).{8,}$";
+    /** 车牌号（新能源+普通） */
+    readonly licensePlate: "^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-Z][A-HJ-NP-Z0-9]{4,5}[A-HJ-NP-Z0-9挂学警港澳]$";
+    /** 邮政编码 */
+    readonly postalCode: "^\\d{6}$";
+    /** 版本号（语义化版本） */
+    readonly semver: "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.]+)?(\\+[a-zA-Z0-9.]+)?$";
+    /** 颜色值（十六进制） */
+    readonly colorHex: "^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$";
+    /** 空字符串 */
+    readonly empty: "^$";
+    /** 非空 */
+    readonly notempty: ".+";
+};
+/**
+ * 正则别名类型
+ */
+export type RegexAliasName = keyof typeof RegexAliases;
+/**
+ * 获取正则表达式字符串
+ * @param name 正则别名（以 @ 开头）或自定义正则字符串
+ * @returns 正则表达式字符串
+ */
+export declare function getRegex(name: string): string;
+/**
+ * 获取编译后的正则表达式对象（带缓存）
+ * @param pattern 正则别名或正则字符串
+ * @param flags 正则标志（如 'i', 'g'）
+ * @returns 编译后的 RegExp 对象
+ */
+export declare function getCompiledRegex(pattern: string, flags?: string): RegExp;
+/**
+ * 验证值是否匹配正则（使用缓存）
+ * @param value 要验证的值
+ * @param pattern 正则别名或正则字符串
+ * @returns 是否匹配
+ */
+export declare function matchRegex(value: string, pattern: string): boolean;
+/**
+ * 清除正则缓存
+ */
+export declare function clearRegexCache(): void;
+/**
+ * 获取缓存大小
+ */
+export declare function getRegexCacheSize(): number;