@h-ai/core 0.1.0-alpha.66 → 0.1.0-alpha.68

package/dist/{core-function-config.node-7KVlEiFk.d.ts → core-function-config.node-DJ6Hb1ee.d.ts}

@@ -9,10 +9,10 @@ import { z, ZodType } from 'zod';
 
 /**
  * 环境类型 Schema。
- *
  * @example
  * ```ts
- * EnvSchema.parse('development')
+ * import { EnvSchema } from '@h-ai/core'
+ * const config = EnvSchema.parse('production')
  * ```
  */
 declare const EnvSchema: z.ZodEnum<{
@@ -21,13 +21,21 @@ declare const EnvSchema: z.ZodEnum<{
     test: "test";
     staging: "staging";
 }>;
+/**
+ * 运行环境标识；不会自行设置进程环境或初始化模块。
+ * @example
+ * ```ts
+ * import type { Env } from '@h-ai/core'
+ * const value: Env = 'production'
+ * ```
+ */
 type Env = z.infer<typeof EnvSchema>;
 /**
  * 日志级别 Schema。
- *
  * @example
  * ```ts
- * LogLevelSchema.parse('info')
+ * import { LogLevelSchema } from '@h-ai/core'
+ * const config = LogLevelSchema.parse('info')
  * ```
  */
 declare const LogLevelSchema: z.ZodEnum<{
@@ -38,56 +46,42 @@ declare const LogLevelSchema: z.ZodEnum<{
     error: "error";
     fatal: "fatal";
 }>;
+/**
+ * 日志输出级别；未显式配置的 Logger 动态继承全局级别。
+ * @example
+ * ```ts
+ * import type { LogLevel } from '@h-ai/core'
+ * const value: LogLevel = 'warn'
+ * ```
+ */
 type LogLevel = z.infer<typeof LogLevelSchema>;
 /**
  * 日志格式 Schema。
- *
  * @example
  * ```ts
- * LogFormatSchema.parse('json')
+ * import { LogFormatSchema } from '@h-ai/core'
+ * const config = LogFormatSchema.parse('json')
  * ```
  */
 declare const LogFormatSchema: z.ZodEnum<{
     json: "json";
     pretty: "pretty";
 }>;
-type LogFormat = z.infer<typeof LogFormatSchema>;
 /**
- * 日志配置 Schema。
- *
- * @example 最小配置（全部使用默认值）
- * ```ts
- * LoggingConfigSchema.parse({})
- * // => { level: 'info', format: 'json', redact: [] }
- * ```
- *
- * @example 开发环境（pretty 格式 + debug 级别）
+ * 日志输出格式：JSON 或适合终端阅读的 pretty。
+ * @example
  * ```ts
- * LoggingConfigSchema.parse({ level: 'debug', format: 'pretty' })
- * // => { level: 'debug', format: 'pretty', redact: [] }
+ * import type { LogFormat } from '@h-ai/core'
+ * const value: LogFormat = 'json'
  * ```
- *
- * @example 带上下文与脱敏
+ */
+type LogFormat = z.infer<typeof LogFormatSchema>;
+/**
+ * 日志配置 Schema。
+ * @example
  * ```ts
- * LoggingConfigSchema.parse({
- *   level: 'warn',
- *   format: 'json',
- *   context: { service: 'api-gateway', region: 'us-east-1' },
- *   redact: ['password', 'token', 'headers.authorization'],
- * })
- * // => { level: 'warn', format: 'json', context: { service: 'api-gateway', region: 'us-east-1' }, redact: ['password', 'token', 'headers.authorization'] }
- * ```
- *
- * @example 在 _core.yml 中配置
- * ```yaml
- * logging:
- *   level: info
- *   format: json
- *   context:
- *     service: my-app
- *   redact:
- *     - password
- *     - token
+ * import { LoggingConfigSchema } from '@h-ai/core'
+ * const config = LoggingConfigSchema.parse({ level: 'warn', format: 'json', redact: ['password'] })
  * ```
  */
 declare const LoggingConfigSchema: z.ZodObject<{
@@ -106,33 +100,25 @@ declare const LoggingConfigSchema: z.ZodObject<{
     context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     redact: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
-type LoggingConfig = z.infer<typeof LoggingConfigSchema>;
 /**
- * ID 生成器配置 Schema。
- *
+ * 经过默认值填充的 Logger 配置；redact 是输出脱敏路径。
  * @example
  * ```ts
- * IdConfigSchema.parse({ length: 12 })
- * // => { length: 12 }
- *
- * IdConfigSchema.parse({ prefix: 'usr_', length: 16 })
- * // => { prefix: 'usr_', length: 16 }
+ * import { LoggingConfigSchema, type LoggingConfig } from '@h-ai/core'
+ * const config: LoggingConfig = LoggingConfigSchema.parse({})
  * ```
  */
-declare const IdConfigSchema: z.ZodObject<{
-    prefix: z.ZodOptional<z.ZodString>;
-    length: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip>;
-type IdConfig = z.infer<typeof IdConfigSchema>;
+type LoggingConfig = z.infer<typeof LoggingConfigSchema>;
 /**
  * Core 配置 Schema。
  *
- * 描述应用的基础配置，通常通过 `_core.yml` 加载。
- *
+ * 描述应用的基础元数据和日志配置，通常通过 `_core.yml` 加载。
+ * 未声明的字段拒绝加载；业务配置放独立 app.yml 并使用应用 Schema 校验。
+ * ID 长度/前缀由每次 core.id 调用参数决定，不存在全局 ID 配置。
  * @example
  * ```ts
- * CoreConfigSchema.parse({ name: 'demo', env: 'production' })
- * // => { name: 'demo', version: '0.1.0', env: 'production', debug: false, defaultLocale: 'zh-CN' }
+ * import { CoreConfigSchema } from '@h-ai/core'
+ * const config = CoreConfigSchema.parse({ name: 'orders', env: 'production', logging: { level: 'info' } })
  * ```
  */
 declare const CoreConfigSchema: z.ZodObject<{
@@ -144,7 +130,6 @@ declare const CoreConfigSchema: z.ZodObject<{
         test: "test";
         staging: "staging";
     }>>;
-    debug: z.ZodDefault<z.ZodBoolean>;
     logging: z.ZodOptional<z.ZodObject<{
         level: z.ZodDefault<z.ZodEnum<{
             trace: "trace";
@@ -161,12 +146,16 @@ declare const CoreConfigSchema: z.ZodObject<{
         context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         redact: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
-    id: z.ZodOptional<z.ZodObject<{
-        prefix: z.ZodOptional<z.ZodString>;
-        length: z.ZodDefault<z.ZodNumber>;
-    }, z.core.$strip>>;
     defaultLocale: z.ZodDefault<z.ZodString>;
-}, z.core.$strip>;
+}, z.core.$strict>;
+/**
+ * 严格校验后的 Core 配置；业务配置使用独立 Schema。
+ * @example
+ * ```ts
+ * import { CoreConfigSchema, type CoreConfig } from '@h-ai/core'
+ * const config: CoreConfig = CoreConfigSchema.parse({})
+ * ```
+ */
 type CoreConfig = z.infer<typeof CoreConfigSchema>;
 
 /**
@@ -228,16 +217,11 @@ declare function mapZodErrorToFormErrors(error: unknown, getMessage: ZodMessageG
  * 按最小知识原则，仅暴露调用方真正需要的两个入口：
  * 1. `createPrefixedZodMessageGetter()`：把模块前缀与消息获取器适配起来
  * 2. `mapZodErrorToFormErrors()`：一步完成 ZodError → 本地化扁平错误列表
- *
  * @example
  * ```ts
- * const getMessage = zodValidation.createPrefixedZodMessageGetter(
- *   'kit',
- *   (messageKey, params) => messageKey === 'kit_validationEmail'
- *     ? '请输入合法邮箱地址'
- *     : `至少输入 ${params?.min} 个字符`,
- * )
- * const errors = zodValidation.mapZodErrorToFormErrors(zodError, getMessage)
+ * import { core } from '@h-ai/core'
+ * const tools = core.zodValidation
+ * tools.mapZodErrorToFormErrors({ issues: [{ path: ['name'], code: 'invalid_type', expected: 'string', message: 'Invalid input' }] }, key => key)
  * ```
  */
 declare const zodValidation: {
@@ -321,11 +305,27 @@ declare function buildHaiErrorsDef<T extends Record<string, string>>(module: str
  * ```
  */
 declare function buildHaiErrorInst(def: HaiErrorDef, message: string, cause?: unknown, suggestion?: string): HaiError;
+/**
+ * 错误定义生成及错误实例组装工具；通过 core.error 使用。
+ * @example
+ * ```ts
+ * import { core } from '@h-ai/core'
+ * const tools = core.error
+ * tools.buildHaiErrorsDef('orders', { NOT_FOUND: '001:404' })
+ * ```
+ */
 declare const error: {
     buildHaiErrorsDef: typeof buildHaiErrorsDef;
     buildHaiErrorInst: typeof buildHaiErrorInst;
 };
-/** error 子工具类型 */
+/**
+ * error 子工具类型
+ * @example 模块内部上下文
+ * ```ts
+ * const tools: ErrorFn = error
+ * tools.buildHaiErrorsDef('orders', { NOT_FOUND: '001:404' })
+ * ```
+ */
 type ErrorFn = typeof error;
 
 /**
@@ -336,11 +336,11 @@ type ErrorFn = typeof error;
  */
 /**
  * ID 生成工具对象。
- *
  * @example
  * ```ts
- * const id1 = id.generate()
- * const id2 = id.short()
+ * import { core } from '@h-ai/core'
+ * const tools = core.id
+ * tools.withPrefix('order_')
  * ```
  */
 declare const id: {
@@ -426,7 +426,14 @@ declare const id: {
      */
     isValidNanoId(str: string, length?: number): boolean;
 };
-/** id 子工具类型 */
+/**
+ * id 子工具类型
+ * @example 模块内部上下文
+ * ```ts
+ * const tools: IdFn = id
+ * tools.withPrefix('order_')
+ * ```
+ */
 type IdFn = typeof id;
 
 /**
@@ -438,10 +445,28 @@ type IdFn = typeof id;
 
 declare function getGlobalLocale(): Locale;
 declare function setGlobalLocale(locale: Locale): void;
+/**
+ * 在独立的 Node 请求语言上下文中运行操作，异步子任务继承当前语言。
+ *
+ * 显式 MessageOptions.locale 优先于请求语言，请求结束不会改变进程启动默认值。
+ *
+ * @param locale - 当前请求的语言
+ * @param operation - 请求处理或 SSR 操作；保留原同步值或 Promise 返回类型
+ * @returns operation 的原始返回值
+ * @throws 浏览器入口没有 Node 请求上下文时抛出错误；浏览器使用 setGlobalLocale。
+ * @example
+ * ```ts
+ * const response = await core.i18n.runWithLocale('en-US', async () => {
+ *   await loadData()
+ *   return renderPage()
+ * })
+ * ```
+ */
+declare function runWithLocale<T>(locale: Locale, operation: () => T): T;
 /**
  * 创建消息获取函数。
  *
- * 各模块通过此函数创建自己的消息获取器，自动读取全局 locale。
+ * 各模块通过此函数创建消息获取器，依次读取显式 locale、Node 请求语言和应用默认语言。
  * 若指定的 locale 不支持，回退到默认语言；key 不存在时返回 key 本身。
  *
  * @param messages - 多语言消息对象
@@ -459,15 +484,34 @@ declare function setGlobalLocale(locale: Locale): void;
  * ```
  */
 declare function createMessageGetter<K extends string>(messages: LocaleMessages<K>): (key: K, options?: MessageOptions) => string;
+/**
+ * 语言上下文、字典消息获取与插值工具；Node 请求通过 runWithLocale 隔离语言。
+ * @example
+ * ```ts
+ * import { core } from '@h-ai/core'
+ * const tools = core.i18n
+ * const message = tools.createMessageGetter({ 'en-US': { hello: 'Hello' }, 'zh-CN': { hello: '你好' } })
+ * message('hello', { locale: 'en-US' })
+ * ```
+ */
 declare const i18n: {
     DEFAULT_LOCALES: LocaleInfo[];
     DEFAULT_LOCALE: string;
     setGlobalLocale: typeof setGlobalLocale;
     getGlobalLocale: typeof getGlobalLocale;
+    runWithLocale: typeof runWithLocale;
     createMessageGetter: typeof createMessageGetter;
-    coreM: (key: "$schema" | "core_errorUnknown" | "core_errorNetwork" | "core_errorTimeout" | "core_errorNotFound" | "core_errorUnauthorized" | "core_errorForbidden" | "core_errorValidation" | "core_errorInternal" | "core_actionConfirm" | "core_actionCancel" | "core_actionSave" | "core_actionDelete" | "core_actionEdit" | "core_actionCreate" | "core_actionUpdate" | "core_actionSearch" | "core_actionReset" | "core_actionSubmit" | "core_actionLoading" | "core_actionRetry" | "core_statusSuccess" | "core_statusFailed" | "core_statusPending" | "core_statusProcessing" | "core_statusCompleted" | "core_statusCancelled" | "core_validationRequired" | "core_validationMinLength" | "core_validationMaxLength" | "core_validationEmail" | "core_validationUrl" | "core_validationNumber" | "core_validationInteger" | "core_validationPositive" | "core_validationPattern" | "core_timeJustNow" | "core_timeSecondsAgo" | "core_timeMinutesAgo" | "core_timeHoursAgo" | "core_timeDaysAgo" | "core_timeWeeksAgo" | "core_timeMonthsAgo" | "core_timeYearsAgo" | "core_browserFeatureUnsupported" | "core_configEnvVarMissing" | "core_configFileNotExist" | "core_configParseFailed" | "core_configValidationFailed" | "core_configNotLoaded" | "core_configUnsupportedInBrowser", options?: MessageOptions) => string;
+    coreM: (key: "$schema" | "core_errorUnknown" | "core_errorNetwork" | "core_errorTimeout" | "core_errorNotFound" | "core_errorUnauthorized" | "core_errorForbidden" | "core_errorValidation" | "core_errorInternal" | "core_actionConfirm" | "core_actionCancel" | "core_actionSave" | "core_actionDelete" | "core_actionEdit" | "core_actionCreate" | "core_actionUpdate" | "core_actionSearch" | "core_actionReset" | "core_actionSubmit" | "core_actionLoading" | "core_actionRetry" | "core_statusSuccess" | "core_statusFailed" | "core_statusPending" | "core_statusProcessing" | "core_statusCompleted" | "core_statusCancelled" | "core_validationRequired" | "core_validationMinLength" | "core_validationMaxLength" | "core_validationEmail" | "core_validationUrl" | "core_validationNumber" | "core_validationInteger" | "core_validationPositive" | "core_validationPattern" | "core_timeJustNow" | "core_timeSecondsAgo" | "core_timeMinutesAgo" | "core_timeHoursAgo" | "core_timeDaysAgo" | "core_timeWeeksAgo" | "core_timeMonthsAgo" | "core_timeYearsAgo" | "core_browserFeatureUnsupported" | "core_configEnvVarMissing" | "core_configFileNotExist" | "core_configParseFailed" | "core_configValidationFailed" | "core_configNotLoaded" | "core_configUnsupportedInBrowser" | "core_cryptoRandomUnavailable", options?: MessageOptions) => string;
 };
-/** i18n 子工具类型 */
+/**
+ * i18n 子工具类型
+ * @example 模块内部上下文
+ * ```ts
+ * const tools: I18nFn = i18n
+ * const message = tools.createMessageGetter({ 'en-US': { hello: 'Hello' }, 'zh-CN': { hello: '你好' } })
+ * message('hello', { locale: 'en-US' })
+ * ```
+ */
 type I18nFn = typeof i18n;
 
 /**
@@ -600,10 +644,11 @@ declare function intersection<T>(arr1: T[], arr2: T[]): T[];
 declare function difference<T>(arr1: T[], arr2: T[]): T[];
 /**
  * 数组操作工具对象。
- *
  * @example
  * ```ts
- * array.unique([1, 1, 2])
+ * import { core } from '@h-ai/core'
+ * const tools = core.array
+ * tools.chunk([1, 2, 3], 2)
  * ```
  */
 declare const array: {
@@ -618,7 +663,14 @@ declare const array: {
     intersection: typeof intersection;
     difference: typeof difference;
 };
-/** array 子工具类型 */
+/**
+ * array 子工具类型
+ * @example 模块内部上下文
+ * ```ts
+ * const tools: ArrayFn = array
+ * tools.chunk([1, 2, 3], 2)
+ * ```
+ */
 type ArrayFn = typeof array;
 
 /**
@@ -728,10 +780,11 @@ declare function debounce<T extends (...args: unknown[]) => unknown>(fn: T, ms:
 declare function throttle<T extends (...args: unknown[]) => unknown>(fn: T, ms: number): (...args: Parameters<T>) => void;
 /**
  * 异步操作工具对象。
- *
  * @example
  * ```ts
- * await async.delay(100)
+ * import { core } from '@h-ai/core'
+ * const tools = core.async
+ * await tools.retry(async () => 'ready', { maxRetries: 2 })
  * ```
  */
 declare const async: {
@@ -743,7 +796,14 @@ declare const async: {
     debounce: typeof debounce;
     throttle: typeof throttle;
 };
-/** async 子工具类型 */
+/**
+ * async 子工具类型
+ * @example 模块内部上下文
+ * ```ts
+ * const tools: AsyncFn = async
+ * await tools.retry(async () => 'ready', { maxRetries: 2 })
+ * ```
+ */
 type AsyncFn = typeof async;
 
 /**
@@ -846,10 +906,11 @@ declare function entries<T extends Record<string, unknown>>(obj: T): [keyof T, T
 declare function fromEntries<K extends string, V>(entries: [K, V][]): Record<K, V>;
 /**
  * 对象操作工具对象。
- *
  * @example
  * ```ts
- * object.deepMerge({ a: 1 }, { b: 2 })
+ * import { core } from '@h-ai/core'
+ * const tools = core.object
+ * tools.pick({ id: 'order-1', password: 'example-only' }, ['id'])
  * ```
  */
 declare const object: {
@@ -862,20 +923,66 @@ declare const object: {
     entries: typeof entries;
     fromEntries: typeof fromEntries;
 };
-/** object 子工具类型 */
+/**
+ * object 子工具类型
+ * @example 模块内部上下文
+ * ```ts
+ * const tools: ObjectFn = object
+ * tools.pick({ id: 'order-1', password: 'example-only' }, ['id'])
+ * ```
+ */
 type ObjectFn = typeof object;
 
-/** 敏感字段匹配器 */
+/**
+ * 敏感字段匹配器
+ * @example 模块内部上下文
+ * ```ts
+ * const matcher: SensitiveKeyMatcher = ['password', 'credential']
+ * const safe = sanitizeSensitiveFields({ credential: 'example-only', id: 'order-1' }, { matcher })
+ * ```
+ */
 type SensitiveKeyMatcher = RegExp | string[] | ((key: string) => boolean);
-/** 敏感字段脱敏选项 */
+/**
+ * 敏感字段脱敏选项
+ * @example 模块内部上下文
+ * ```ts
+ * const options: SanitizeSensitiveFieldsOptions = { matcher: ['credential'], replacement: '[HIDDEN]' }
+ * const safe = sanitizeSensitiveFields({ credential: 'example-only' }, options)
+ * ```
+ */
 interface SanitizeSensitiveFieldsOptions {
     /** 自定义敏感字段匹配规则 */
     matcher?: SensitiveKeyMatcher;
     /** 自定义脱敏替换值 */
     replacement?: unknown;
 }
-/** 判断键名是否属于敏感字段 */
+/**
+ * 判断键名是否属于敏感字段
+ * @param key - 原始字段名；会统一 camelCase、kebab-case 与 snake_case。
+ * @param matcher - 自定义规则；省略时使用凭证字段默认规则。
+ * @returns 当前字段名是否被匹配为敏感字段。
+ * @example
+ * ```ts
+ * import { core } from '@h-ai/core'
+ * const safe = core.sanitize.isSensitiveKey('apiKey')
+ * ```
+ */
 declare function isSensitiveKey(key: string, matcher?: SensitiveKeyMatcher): boolean;
+/**
+ * 遮蔽 URL 的用户名、密码及敏感查询参数；OAuth 风格 fragment 按查询参数处理。
+ *
+ * 解析失败返回固定占位符，避免畸形地址把凭据原样写入日志。
+ *
+ * @param url - 待记录的绝对 URL
+ * @param options - 与对象脱敏一致的匹配规则和替换值
+ * @returns 可安全用于结构化日志的 URL
+ * @example
+ * ```ts
+ * import { core } from '@h-ai/core'
+ * const safe = core.sanitize.sanitizeUrl('https://service.example/path?token=example-only')
+ * ```
+ */
+declare function sanitizeUrl(url: string, options?: SanitizeSensitiveFieldsOptions): string;
 /**
  * 递归脱敏单个值。
  *
@@ -883,25 +990,54 @@ declare function isSensitiveKey(key: string, matcher?: SensitiveKeyMatcher): boo
  * @param key - 当前字段名；根节点传 null
  * @param options - 脱敏选项
  * @param cache - 循环引用 / 重复引用缓存
+ * @returns 递归脱敏后的值；普通对象循环保留，Error 规范化为有界诊断树，原值不被修改。
+ * @example
+ * ```ts
+ * import { core } from '@h-ai/core'
+ * const safe = core.sanitize.sanitizeSensitiveValue('example-only', 'password')
+ * ```
  */
 declare function sanitizeSensitiveValue(value: unknown, key: string | null, options?: SanitizeSensitiveFieldsOptions, cache?: WeakMap<object, unknown>): unknown;
 /**
  * 对对象中的敏感字段执行递归脱敏，并自动处理 URL/endpoint 字段中的内嵌凭证。
+ * Error 保留 name/message/stack/cause、aggregate errors 与枚举上下文；错误子图循环和过深路径用固定标记，普通对象循环保留。
+ * 诊断文本不会自动解析自由文本中的秘密；记录前仍需调用方清理，或配置明确的 redact 路径。
  *
  * @param value - 原始对象/数组/值
  * @param options - 脱敏选项
  * @returns 脱敏后的新值
+ * @example
+ * ```ts
+ * import { core } from '@h-ai/core'
+ * const safe = core.sanitize.sanitizeSensitiveFields({ password: 'example-only', id: 'order-1' })
+ * ```
  */
 declare function sanitizeSensitiveFields<T>(value: T, options?: SanitizeSensitiveFieldsOptions): T;
-/** 脱敏工具对象。 */
+/**
+ * 脱敏工具对象。
+ * @example
+ * ```ts
+ * import { core } from '@h-ai/core'
+ * const tools = core.sanitize
+ * tools.sanitizeSensitiveFields({ apiKey: 'example-only', id: 'order-1' })
+ * ```
+ */
 declare const sanitize: {
     defaultSensitiveKeyRegex: RegExp;
     defaultSensitiveReplacement: string;
     isSensitiveKey: typeof isSensitiveKey;
+    sanitizeUrl: typeof sanitizeUrl;
     sanitizeSensitiveValue: typeof sanitizeSensitiveValue;
     sanitizeSensitiveFields: typeof sanitizeSensitiveFields;
 };
-/** sanitize 子工具类型 */
+/**
+ * sanitize 子工具类型
+ * @example 模块内部上下文
+ * ```ts
+ * const tools: SanitizeFn = sanitize
+ * tools.sanitizeSensitiveFields({ apiKey: 'example-only', id: 'order-1' })
+ * ```
+ */
 type SanitizeFn = typeof sanitize;
 
 /**
@@ -1043,10 +1179,9 @@ declare function padStart(str: string, length: number, char?: string): string;
  */
 declare function padEnd(str: string, length: number, char?: string): string;
 /**
- * 常量时间字符串比较。
+ * 无内容提前返回的字符串比较；Node 入口使用原生 timingSafeEqual 覆盖此实现。
  *
- * 防止时序侧信道攻击：无论输入差异位置如何，执行时间恒定。
- * 兼容 Node.js 与浏览器环境（纯 JS 实现，无平台依赖）。
+ * 浏览器 JavaScript 引擎不提供恒时保证，不能将此实现当作服务端凭证校验的安全边界。
  *
  * @param a - 字符串 a
  * @param b - 字符串 b
@@ -1061,10 +1196,11 @@ declare function padEnd(str: string, length: number, char?: string): string;
 declare function constantTimeEqual(a: string, b: string): boolean;
 /**
  * 字符串操作工具对象。
- *
  * @example
  * ```ts
- * string.capitalize('hello')
+ * import { core } from '@h-ai/core'
+ * const tools = core.string
+ * tools.camelCase('order-created')
  * ```
  */
 declare const string: {
@@ -1081,7 +1217,14 @@ declare const string: {
     padEnd: typeof padEnd;
     constantTimeEqual: typeof constantTimeEqual;
 };
-/** string 子工具类型 */
+/**
+ * string 子工具类型
+ * @example 模块内部上下文
+ * ```ts
+ * const tools: StringFn = string
+ * tools.camelCase('order-created')
+ * ```
+ */
 type StringFn = typeof string;
 
 /**
@@ -1203,10 +1346,11 @@ declare function startOfDay(date: Date): Date;
 declare function endOfDay(date: Date): Date;
 /**
  * 时间操作工具对象。
- *
  * @example
  * ```ts
- * time.formatDate(new Date())
+ * import { core } from '@h-ai/core'
+ * const tools = core.time
+ * tools.addDays(new Date('2026-01-01T00:00:00Z'), 1)
  * ```
  */
 declare const time: {
@@ -1221,7 +1365,14 @@ declare const time: {
     startOfDay: typeof startOfDay;
     endOfDay: typeof endOfDay;
 };
-/** time 子工具类型 */
+/**
+ * time 子工具类型
+ * @example 模块内部上下文
+ * ```ts
+ * const tools: TimeFn = time
+ * tools.addDays(new Date('2026-01-01T00:00:00Z'), 1)
+ * ```
+ */
 type TimeFn = typeof time;
 
 /**
@@ -1318,10 +1469,12 @@ declare function isBoolean(value: unknown): value is boolean;
 declare function isArray<T = unknown>(value: unknown): value is T[];
 /**
  * 类型检查工具对象。
- *
  * @example
  * ```ts
- * typeUtils.isDefined('x')
+ * import { core } from '@h-ai/core'
+ * const tools = core.typeUtils
+ * const value: unknown = 'order-1'
+ * if (tools.isString(value)) value.toUpperCase()
  * ```
  */
 declare const typeUtils: {
@@ -1334,19 +1487,72 @@ declare const typeUtils: {
     isBoolean: typeof isBoolean;
     isArray: typeof isArray;
 };
-/** typeUtils 子工具类型 */
+/**
+ * typeUtils 子工具类型
+ * @example 模块内部上下文
+ * ```ts
+ * const tools: TypeUtilFn = typeUtils
+ * const value: unknown = 'order-1'
+ * if (tools.isString(value)) value.toUpperCase()
+ * ```
+ */
 type TypeUtilFn = typeof typeUtils;
 
+/**
+ * Zod 校验错误使用的稳定消息键。
+ * @example
+ * ```ts
+ * import type { ZodValidationMessageKey } from '@h-ai/core'
+ * const value: ZodValidationMessageKey = 'validationRequired'
+ * ```
+ */
 type ZodValidationMessageKey = 'validationFailed' | 'validationRequired' | 'validationInvalid' | 'validationInvalidType' | 'validationStringMin' | 'validationStringMax' | 'validationNumberMin' | 'validationNumberMax' | 'validationArrayMin' | 'validationArrayMax' | 'validationTooSmall' | 'validationTooBig' | 'validationEmail' | 'validationUrl' | 'validationUuid' | 'validationEnum';
+/**
+ * 把校验消息键及插值参数转换为显示文本的函数。
+ * @example
+ * ```ts
+ * import type { ZodMessageGetter } from '@h-ai/core'
+ * const message: ZodMessageGetter = (key, params) => key === 'validationRequired' ? 'Required' : `${key}: ${String(params?.field ?? '')}`
+ * message('validationRequired')
+ * ```
+ */
 type ZodMessageGetter = (key: ZodValidationMessageKey, params?: Record<string, string | number>) => string;
+/**
+ * 可绑定表单字段路径的本地化错误。
+ * @example
+ * ```ts
+ * import type { ValidationFormError } from '@h-ai/core'
+ * const value: ValidationFormError = { field: 'email', message: 'Enter an email address' }
+ * ```
+ */
 interface ValidationFormError {
     field: string;
     message: string;
 }
+/**
+ * 共享 Zod 错误映射契约；业务自定义消息保持原文。
+ * @example
+ * ```ts
+ * import { core, type ZodValidationFn } from '@h-ai/core'
+ * import { z } from 'zod'
+ * const validator: ZodValidationFn = core.zodValidation
+ * const input = z.object({ email: z.email() }).safeParse({ email: 'invalid' })
+ * if (!input.success) validator.mapZodErrorToFormErrors(input.error, key => key)
+ * ```
+ */
 interface ZodValidationFn {
     readonly createPrefixedZodMessageGetter: <TMessageKey extends string>(prefix: string, getMessage: (messageKey: TMessageKey, params?: Record<string, string | number>) => string) => ZodMessageGetter;
     readonly mapZodErrorToFormErrors: (error: unknown, getMessage: ZodMessageGetter) => ValidationFormError[];
 }
+/**
+ * 业务操作的成功数据或标准失败；访问 data/error 前必须按 success 收窄。
+ * @example
+ * ```ts
+ * import { ok, type HaiResult } from '@h-ai/core'
+ * const result: HaiResult<{ id: string }> = ok({ id: 'order-1' })
+ * const label = result.success ? result.data.id : result.error.message
+ * ```
+ */
 type HaiResult<T> = {
     success: true;
     data: T;
@@ -1354,7 +1560,32 @@ type HaiResult<T> = {
     success: false;
     error: HaiError;
 };
+/**
+ * 创建成功结果；不会自动捕获后续操作异常。
+ * @param data - 成功分支的数据；保留原类型和对象引用。
+ * @returns success 为 true、data 为输入值的结果。
+ * @example
+ * ```ts
+ * import { ok } from '@h-ai/core'
+ * const result = ok({ id: 'order-1' })
+ * if (result.success) result.data.id.toUpperCase()
+ * ```
+ */
 declare function ok<T>(data: T): HaiResult<T>;
+/**
+ * 创建失败结果；支持标准错误定义、已有 HaiError 与原生 Error。
+ * @param errorOrDef - 已定义的错误、已有业务错误或原生异常。
+ * @param message - 从错误定义创建实例时使用的消息。
+ * @param cause - 原始原因；对外展示前应按边界脱敏。
+ * @param suggestion - 可选的处理建议。
+ * @returns success 为 false、error 为标准业务错误的结果。
+ * @example
+ * ```ts
+ * import { err, HaiCommonError } from '@h-ai/core'
+ * const result = err(HaiCommonError.NOT_FOUND, 'Order not found')
+ * if (!result.success) result.error.httpStatus
+ * ```
+ */
 declare function err(errorOrDef: HaiErrorDef | HaiError | Error, message?: string, cause?: unknown, suggestion?: string): HaiResult<never>;
 /**
  * HaiResult 模式匹配处理器。
@@ -1364,13 +1595,12 @@ declare function err(errorOrDef: HaiErrorDef | HaiError | Error, message?: strin
  * @template T - 成功数据类型
  * @template R1 - ok 分支返回类型
  * @template R2 - err 分支返回类型
- *
  * @example
  * ```ts
- * const handlers: MatchHandlers<number, number, number> = {
- *   ok: n => n + 1,
- *   err: () => 0,
- * }
+ * import { type MatchHandlers, ok } from '@h-ai/core'
+ * const handlers: MatchHandlers<number, string, string> = { ok: n => String(n + 1), err: error => error.message }
+ * const result = ok(2)
+ * const label = result.success ? handlers.ok(result.data) : handlers.err(result.error)
  * ```
  */
 interface MatchHandlers<T, R1, R2> {
@@ -1379,16 +1609,46 @@ interface MatchHandlers<T, R1, R2> {
     /** 失败分支处理器 */
     err: (error: HaiError) => R2;
 }
-/** 错误信息值格式：`错误码数字段:HTTP状态码`，例如 `001:500`。 */
+/**
+ * 错误信息值格式：`错误码数字段:HTTP状态码`，例如 `001:500`。
+ * @example
+ * ```ts
+ * import type { ErrorInfoValue } from '@h-ai/core'
+ * const value: ErrorInfoValue = '001:500'
+ * ```
+ */
 type ErrorInfoValue = `${string}:${string}`;
-/** 模块错误信息映射。 */
+/**
+ * 模块错误信息映射。
+ * @example
+ * ```ts
+ * import type { ErrorInfo } from '@h-ai/core'
+ * const value: ErrorInfo = { NOT_READY: '001:503' }
+ * ```
+ */
 type ErrorInfo = Record<string, ErrorInfoValue>;
+/**
+ * 稳定的错误码与 HTTP 映射；消息在创建错误实例时填入。
+ * @example
+ * ```ts
+ * import type { HaiErrorDef } from '@h-ai/core'
+ * const value: HaiErrorDef = { code: 'app:orders:001', httpStatus: 409, system: 'app', module: 'orders' }
+ * ```
+ */
 interface HaiErrorDef {
     code: string | number;
     httpStatus: number;
     system: string;
     module: string;
 }
+/**
+ * 可跨业务边界传递的错误；cause/ext 对外展示前仍需脱敏。
+ * @example
+ * ```ts
+ * import type { HaiError } from '@h-ai/core'
+ * const value: HaiError = { code: 'app:orders:001', message: 'Order already exists', httpStatus: 409 }
+ * ```
+ */
 interface HaiError {
     code: string | number;
     message: string;
@@ -1399,6 +1659,15 @@ interface HaiError {
     suggestion?: string;
     ext?: Record<string, unknown>;
 }
+/**
+ * 跨模块通用错误定义及 HTTP 状态映射。
+ * @example
+ * ```ts
+ * import { err, HaiCommonError } from '@h-ai/core'
+ * const result = err(HaiCommonError.UNAUTHORIZED, 'Authentication required')
+ * if (!result.success) result.error.code
+ * ```
+ */
 declare const HaiCommonError: {
     readonly NOT_INITIALIZED: HaiErrorDef;
     readonly INIT_FAILED: HaiErrorDef;
@@ -1421,6 +1690,15 @@ declare const HaiCommonError: {
     readonly DATABASE_ERROR: HaiErrorDef;
     readonly UNKNOWN_ERROR: HaiErrorDef;
 };
+/**
+ * 文件配置加载、校验、环境缺失及缓存读取的错误定义。
+ * @example
+ * ```ts
+ * import { err, HaiConfigError } from '@h-ai/core'
+ * const result = err(HaiConfigError.CONFIG_NOT_LOADED, 'App configuration is unavailable')
+ * if (!result.success) result.error.message
+ * ```
+ */
 declare const HaiConfigError: {
     readonly CONFIG_FILE_NOT_FOUND: HaiErrorDef;
     readonly CONFIG_PARSE_ERROR: HaiErrorDef;
@@ -1430,10 +1708,10 @@ declare const HaiConfigError: {
 };
 /**
  * 分页参数输入（可选字段，未提供时使用默认值）。
- *
  * @example
  * ```ts
- * const input: PaginationOptionsInput = { page: 2, pageSize: 20 }
+ * import type { PaginationOptionsInput } from '@h-ai/core'
+ * const value: PaginationOptionsInput = { page: 2, pageSize: 20 }
  * ```
  */
 interface PaginationOptionsInput {
@@ -1444,10 +1722,10 @@ interface PaginationOptionsInput {
 }
 /**
  * 分页参数（必填，已确定具体值）。
- *
  * @example
  * ```ts
- * const options: PaginationOptions = { page: 1, pageSize: 20 }
+ * import type { PaginationOptions } from '@h-ai/core'
+ * const value: PaginationOptions = { page: 1, pageSize: 20 }
  * ```
  */
 interface PaginationOptions {
@@ -1460,15 +1738,11 @@ interface PaginationOptions {
  * 分页结果。
  *
  * @template T - 数据项类型
- *
  * @example
  * ```ts
- * const result: PaginatedResult<User> = {
- *   items: [{ id: 1, name: 'Alice' }],
- *   total: 100,
- *   page: 1,
- *   pageSize: 20,
- * }
+ * import type { PaginatedResult } from '@h-ai/core'
+ * const page: PaginatedResult<{ id: string }> = { items: [{ id: 'order-1' }], total: 1, page: 1, pageSize: 20 }
+ * const ids = page.items.map(item => item.id)
  * ```
  */
 interface PaginatedResult<T> {
@@ -1483,10 +1757,10 @@ interface PaginatedResult<T> {
 }
 /**
  * 日志上下文。
- *
  * @example
  * ```ts
- * const context: LogContext = { requestId: 'req-1' }
+ * import type { LogContext } from '@h-ai/core'
+ * const value: LogContext = { requestId: 'request-1', level: 'info' }
  * ```
  */
 interface LogContext {
@@ -1497,10 +1771,10 @@ interface LogContext {
 }
 /**
  * 日志选项。
- *
  * @example
  * ```ts
- * const options: LoggerOptions = { name: 'api', level: 'debug' }
+ * import type { LoggerOptions } from '@h-ai/core'
+ * const value: LoggerOptions = { name: 'orders', level: 'debug', context: { service: 'api' } }
  * ```
  */
 interface LoggerOptions {
@@ -1515,10 +1789,11 @@ interface LoggerOptions {
 /**
  * Logger 接口。
  * 统一的日志记录接口，具体实现由 Provider 提供。
- *
  * @example
  * ```ts
- * core.logger.info('ready', { requestId: 'req-1' })
+ * import { core, type Logger } from '@h-ai/core'
+ * const logger: Logger = core.logger.child({ service: 'orders' })
+ * logger.info('Order created', { orderId: 'order-1' })
  * ```
  */
 interface Logger {
@@ -1532,14 +1807,12 @@ interface Logger {
 }
 /**
  * Core 公共 Logger — Logger 实例 + 管理方法。
- *
  * @example
  * ```ts
- * core.logger.info('ready')
- * core.logger.configure({ level: 'debug' })
- * core.logger.setLevel('warn')
- * const level = core.logger.getLevel()
- * const db = core.logger.create({ name: 'db' })
+ * import { core, type CoreLogger } from '@h-ai/core'
+ * const logger: CoreLogger = core.logger
+ * logger.configure({ level: 'warn', redact: ['password'] })
+ * logger.child({ component: 'worker' }).warn('Retry scheduled')
  * ```
  */
 interface CoreLogger extends Logger {
@@ -1556,16 +1829,11 @@ interface CoreLogger extends Logger {
  * Logger 函数组合（平台实现依赖）。
  *
  * 由各平台（Node.js / Browser）提供具体实现，通过 `createCore()` 注入。
- *
  * @example
  * ```ts
- * const fns: LoggerFunctions = {
- *   createLogger,
- *   getLogger,
- *   configureLogger,
- *   setLogLevel,
- *   getLogLevel,
- * }
+ * import { core, type LoggerFunctions } from '@h-ai/core'
+ * const platform: LoggerFunctions = { createLogger: options => core.logger.create(options), getLogger: name => core.logger.create({ name }), configureLogger: config => core.logger.configure(config), setLogLevel: level => core.logger.setLevel(level), getLogLevel: () => core.logger.getLevel() }
+ * platform.createLogger({ name: 'worker' }).info('Worker ready')
  * ```
  */
 interface LoggerFunctions {
@@ -1582,10 +1850,10 @@ interface LoggerFunctions {
 }
 /**
  * Core 配置选项。
- *
  * @example
  * ```ts
- * const options: CoreOptions = { configDir: './config', watchConfig: true }
+ * import type { CoreOptions } from '@h-ai/core'
+ * const value: CoreOptions = { configDir: './config', watchConfig: false }
  * ```
  */
 interface CoreOptions {
@@ -1598,6 +1866,10 @@ interface CoreOptions {
      * - `_core.yml` → 自动使用 CoreConfigSchema 校验
      * - `_xx.yml` → 加载为 'xx'（各模块自行调用 `config.validate` 校验）
      * - `app.yml` → 加载为 'app'（需使用方自行校验）
+     * - `_deploy.yml` / `_deploy.yaml` → 只由部署 CLI 解析，自动加载和监听均跳过；业务 `deploy.yml` 仍加载
+     *
+     * 单项加载返回失败时记日志并继续；必需配置须检查 `config.validate` 的 success。
+     * 目录扫描等文件系统异常仍可能向调用方传播。
      *
      * @example
      * ```ts
@@ -1610,16 +1882,19 @@ interface CoreOptions {
 }
 /**
  * 语言代码（ISO 639-1 + 地区代码）。
- *
- * @example 'zh-CN', 'en-US', 'ja-JP'
+ * @example
+ * ```ts
+ * import type { Locale } from '@h-ai/core'
+ * const value: Locale = 'en-US'
+ * ```
  */
 type Locale = string;
 /**
  * 语言信息。
- *
  * @example
  * ```ts
- * const locale: LocaleInfo = { code: 'zh-CN', label: '简体中文' }
+ * import type { LocaleInfo } from '@h-ai/core'
+ * const value: LocaleInfo = { code: 'en-US', label: 'English' }
  * ```
  */
 interface LocaleInfo {
@@ -1634,20 +1909,19 @@ interface LocaleInfo {
  * 插值参数类型。
  *
  * 用于 i18n 消息模板中的 `{key}` 占位符替换。
- *
  * @example
  * ```ts
- * const params: InterpolationParams = { name: 'Alice', count: 3 }
- * // 模板 'Hello, {name}! You have {count} items.'
+ * import type { InterpolationParams } from '@h-ai/core'
+ * const value: InterpolationParams = { name: 'Alice', count: 2 }
  * ```
  */
 type InterpolationParams = Record<string, string | number | boolean>;
 /**
  * 消息字典类型（单语言的 key-value 映射）。
- *
  * @example
  * ```ts
- * const dict: MessageDictionary = { hello: '你好', bye: '再见' }
+ * import type { MessageDictionary } from '@h-ai/core'
+ * const value: MessageDictionary = { greeting: 'Hello, {name}!' }
  * ```
  */
 type MessageDictionary = Record<string, string>;
@@ -1657,31 +1931,38 @@ type MessageDictionary = Record<string, string>;
  * 以 locale 为键，每个 locale 下包含该语言的所有消息 key-value。
  *
  * @template K - 消息 key 的联合类型
- *
  * @example
  * ```ts
- * const messages: LocaleMessages<'hello' | 'bye'> = {
- *   'zh-CN': { hello: '你好', bye: '再见' },
- *   'en-US': { hello: 'Hello', bye: 'Bye' },
- * }
+ * import { core, type LocaleMessages } from '@h-ai/core'
+ * const messages: LocaleMessages<'hello'> = { 'en-US': { hello: 'Hello, {name}!' }, 'zh-CN': { hello: '你好，{name}！' } }
+ * const message = core.i18n.createMessageGetter(messages)
+ * message('hello', { locale: 'en-US', params: { name: 'Alice' } })
  * ```
  */
 type LocaleMessages<K extends string = string> = Record<Locale, Record<K, string>>;
 /**
  * 消息获取选项。
- *
  * @example
  * ```ts
- * getMessage('hello', { locale: 'en-US', params: { name: 'World' } })
+ * import type { MessageOptions } from '@h-ai/core'
+ * const value: MessageOptions = { locale: 'en-US', params: { name: 'Alice' } }
  * ```
  */
 interface MessageOptions {
-    /** 指定 locale（不传则使用全局 locale） */
+    /** 指定 locale（不传时依次读取 Node 请求上下文、应用默认语言） */
     locale?: Locale;
     /** 插值参数 */
     params?: InterpolationParams;
 }
-/** Core 服务聚合接口（createCore 返回类型） */
+/**
+ * Core 服务聚合接口（createCore 返回类型）
+ * @example
+ * ```ts
+ * import { core, type CoreFunctions } from '@h-ai/core'
+ * function createRequestId(tools: CoreFunctions): string { return tools.id.request() }
+ * const requestId = createRequestId(core)
+ * ```
+ */
 interface CoreFunctions {
     /** 默认 Logger（懒加载单例），同时提供日志管理方法 */
     readonly logger: CoreLogger;
@@ -1725,6 +2006,12 @@ interface CoreFunctions {
  * 用于模块未初始化时的安全回退。
  *
  * @template E - 模块错误类型（必须继承 HaiError）
+ * @example 模块内部上下文
+ * ```ts
+ * const state: NotInitializedKit<HaiError> = createNotInitializedKit({ code: 'app:orders:001', httpStatus: 503, system: 'app', module: 'orders' }, () => 'Orders unavailable')
+ * const result = state.result<string>()
+ * if (!result.success) result.error.message
+ * ```
  */
 interface NotInitializedKit<E extends HaiError> {
     /** 创建未初始化错误对象 */
@@ -1739,13 +2026,53 @@ interface NotInitializedKit<E extends HaiError> {
     proxy: <T>(mode?: 'async' | 'sync') => T;
 }
 /** module 子工具类型 */
-/** overloaded function type for createNotInitializedKit */
+/**
+ * 未初始化代理的两个重载：错误定义或具体错误码。
+ * @example 模块内部上下文
+ * ```ts
+ * const create: CreateNotInitializedKitFn = createNotInitializedKit
+ * const state = create({ code: 'app:orders:001', httpStatus: 503, system: 'app', module: 'orders' }, () => 'Orders unavailable')
+ * const result = state.result<string>()
+ * if (!result.success) result.error.code
+ * ```
+ */
 interface CreateNotInitializedKitFn {
     (codeOrDef: HaiErrorDef, messageFn: () => string): NotInitializedKit<HaiError>;
     <E extends HaiError>(codeOrDef: E['code'], messageFn: () => string): NotInitializedKit<E>;
 }
+/**
+ * 生产进程默认要求跨主机共享状态；显式E2E测试可使用测试替身。
+ * @param environment - 服务端实际进程环境，不接受请求参数
+ * @param environment.NODE_ENV - 实际运行环境
+ * @param environment.HAI_CORE_ENV - 框架环境文件声明的运行环境
+ * @param environment.HAI_E2E - 显式真实端到端测试标记
+ * @param environment.HAI_E2E_MOCK - 显式模拟端到端测试标记
+ * @returns 是否拒绝仅本机/进程有效的状态后端
+ * @example
+ * ```ts
+ * import { core } from '@h-ai/core'
+ * const production = core.module.requiresSharedState({ HAI_CORE_ENV: 'production' }) // true
+ * const test = core.module.requiresSharedState({ NODE_ENV: 'production', HAI_E2E: '1' }) // false
+ * ```
+ */
+declare function requiresSharedState(environment: {
+    NODE_ENV?: string;
+    HAI_CORE_ENV?: string;
+    HAI_E2E?: string;
+    HAI_E2E_MOCK?: string;
+}): boolean;
+/**
+ * 模块初始化占位与生产共享状态要求的工具契约。
+ * @example 模块内部上下文
+ * ```ts
+ * const tools: ModuleFn = { createNotInitializedKit, requiresSharedState }
+ * const shared = tools.requiresSharedState({ NODE_ENV: 'production' })
+ * ```
+ */
 interface ModuleFn {
     createNotInitializedKit: CreateNotInitializedKitFn;
+    /** 生产共享状态要求；浏览器工具为纯函数，不隐式读取进程环境。 */
+    requiresSharedState: typeof requiresSharedState;
 }
 
 /**
@@ -1759,25 +2086,22 @@ interface ModuleFn {
  * 监听回调类型。
  *
  * @template T - 配置数据类型
- *
- * @example
+ * @example 模块内部上下文
  * ```ts
- * const callback: WatchCallback<AppConfig> = (cfg, error) => {
- *   if (error) { core.logger.error('Config reload failed', { error }); return }
- *   // 使用更新后的 cfg
+ * const callback: WatchCallback<{ enabled: boolean }> = (config, failure) => {
+ *   if (failure) { messages.push(failure.message); return }
+ *   if (config) messages.push(String(config.enabled))
  * }
+ * const messages: string[] = []
  * ```
  */
 type WatchCallback<T = unknown> = (config: T | null, error?: HaiError) => void;
 /**
  * 配置管理对象。
- *
- * @example
+ * @example 模块内部上下文
  * ```ts
- * const result = config.load('app', './config/app.yml')
- * if (result.success) {
- *   const cfg = config.get('app')
- * }
+ * const result = config.load('app', '/srv/app/config/app.yml')
+ * if (!result.success) result.error.message
  * ```
  */
 declare const config: {
@@ -1971,4 +2295,4 @@ declare const config: {
     isWatching(name: string): boolean;
 };
 
-export { err as $, type ArrayFn as A, LogLevelSchema as B, type CoreOptions as C, type Logger as D, type ErrorFn as E, type LoggerFunctions as F, type LoggerOptions as G, type HaiResult as H, type I18nFn as I, type LoggingConfig as J, LoggingConfigSchema as K, type Locale as L, type ModuleFn as M, type MatchHandlers as N, type ObjectFn as O, type MessageDictionary as P, type MessageOptions as Q, type PaginatedResult as R, type SanitizeFn as S, type TypeUtilFn as T, type PaginationOptions as U, type PaginationOptionsInput as V, type WatchCallback as W, type ValidationFormError as X, type ZodValidationFn as Y, type ZodMessageGetter as Z, type ZodValidationMessageKey as _, type CoreLogger as a, ok as a0, config as a1, type IdFn as b, type StringFn as c, type AsyncFn as d, type TimeFn as e, type CoreConfig as f, CoreConfigSchema as g, type CoreFunctions as h, type Env as i, EnvSchema as j, type ErrorInfo as k, type ErrorInfoValue as l, HaiCommonError as m, HaiConfigError as n, type HaiError as o, type HaiErrorDef as p, type IdConfig as q, IdConfigSchema as r, type InterpolationParams as s, type LocaleInfo as t, type LocaleMessages as u, type LogContext as v, type LogFormat as w, LogFormatSchema as x, type LogLevel as y, zodValidation as z };
+export { config as $, type ArrayFn as A, type LoggerFunctions as B, type CoreOptions as C, type LoggerOptions as D, type ErrorFn as E, type LoggingConfig as F, LoggingConfigSchema as G, type HaiResult as H, type I18nFn as I, type MatchHandlers as J, type MessageDictionary as K, type Locale as L, type ModuleFn as M, type MessageOptions as N, type ObjectFn as O, type PaginatedResult as P, type PaginationOptions as Q, type PaginationOptionsInput as R, type SanitizeFn as S, type TypeUtilFn as T, type ZodValidationFn as U, type ValidationFormError as V, type WatchCallback as W, type ZodValidationMessageKey as X, err as Y, type ZodMessageGetter as Z, ok as _, type CoreLogger as a, type IdFn as b, type StringFn as c, type AsyncFn as d, type TimeFn as e, type CoreConfig as f, CoreConfigSchema as g, type CoreFunctions as h, type Env as i, EnvSchema as j, type ErrorInfo as k, type ErrorInfoValue as l, HaiCommonError as m, HaiConfigError as n, type HaiError as o, type HaiErrorDef as p, type InterpolationParams as q, type LocaleInfo as r, type LocaleMessages as s, type LogContext as t, type LogFormat as u, LogFormatSchema as v, type LogLevel as w, LogLevelSchema as x, type Logger as y, zodValidation as z };