@logixjs/form 0.0.1

package/dist/Rule-BOAiSVz9.d.cts

@@ -0,0 +1,202 @@
+import * as Logix from '@logixjs/core';
+
+declare const ERROR_VALUE_MAX_BYTES = 256;
+declare const assertErrorValueBudget: (value: unknown, label: string) => unknown;
+type RequiredDecl = boolean | string | Readonly<{
+    readonly message?: string;
+    readonly trim?: boolean;
+}>;
+declare const required: (decl: RequiredDecl) => ((value: unknown) => unknown | undefined);
+type MinLengthDecl = number | Readonly<{
+    readonly min: number;
+    readonly message?: string;
+}>;
+declare const minLength: (decl: MinLengthDecl) => ((value: unknown) => unknown | undefined);
+type MaxLengthDecl = number | Readonly<{
+    readonly max: number;
+    readonly message?: string;
+}>;
+declare const maxLength: (decl: MaxLengthDecl) => ((value: unknown) => unknown | undefined);
+type MinDecl = number | Readonly<{
+    readonly min: number;
+    readonly message?: string;
+}>;
+declare const min: (decl: MinDecl) => ((value: unknown) => unknown | undefined);
+type MaxDecl = number | Readonly<{
+    readonly max: number;
+    readonly message?: string;
+}>;
+declare const max: (decl: MaxDecl) => ((value: unknown) => unknown | undefined);
+type PatternDecl = RegExp | Readonly<{
+    readonly re: RegExp;
+    readonly message?: string;
+}>;
+declare const pattern: (decl: PatternDecl) => ((value: unknown) => unknown | undefined);
+
+type Primitive = string | number | boolean | bigint | symbol | null | undefined | Date | RegExp | Function;
+type NonNull<T> = Exclude<T, null | undefined>;
+type IsPlainObject<T> = [NonNull<T>] extends [Primitive] ? false : [NonNull<T>] extends [readonly any[]] ? false : [NonNull<T>] extends [Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any>] ? false : [NonNull<T>] extends [object] ? true : false;
+type Join<K, P> = K extends string ? (P extends string ? `${K}.${P}` : never) : never;
+type PrevDepth<D extends number> = D extends 5 ? 4 : D extends 4 ? 3 : D extends 3 ? 2 : D extends 2 ? 1 : D extends 1 ? 0 : 0;
+type IndexSegment = `${number}`;
+type FieldPathInner<T, Depth extends number> = Depth extends 0 ? never : [NonNull<T>] extends [Primitive] ? never : [NonNull<T>] extends [readonly (infer Item)[]] ? IndexSegment | (FieldPathInner<Item, PrevDepth<Depth>> extends infer P ? P extends string ? `${IndexSegment}.${P}` : never : never) : [NonNull<T>] extends [object] ? {
+    [K in keyof NonNull<T> & string]: K | ([NonNull<T>[K]] extends [readonly (infer Item)[]] ? `${K}.${IndexSegment}` | (FieldPathInner<Item, PrevDepth<Depth>> extends infer P ? P extends string ? `${K}.${IndexSegment}.${P}` : never : never) : IsPlainObject<NonNull<T>[K]> extends true ? Join<K, FieldPathInner<NonNull<T>[K], PrevDepth<Depth>>> : never);
+}[keyof NonNull<T> & string] : never;
+/**
+ * FieldPath<TValues>：
+ * - A typed version of valuePath strings (aligned with the "ValuePath" mental model from 010).
+ *   Array indices are represented as `${number}`; examples:
+ *   - "profile.name"
+ *   - "items.${number}.warehouseId"
+ * - Uses a max recursion depth of 5 to avoid TS Server performance issues.
+ */
+type FieldPath<TValues extends object> = FieldPathInner<TValues, 5>;
+type AtIndex<T> = NonNull<T> extends readonly (infer Item)[] ? Item : never;
+type FieldValueInner<TValues, P> = P extends `${infer Head}.${infer Rest}` ? Head extends IndexSegment ? FieldValueInner<AtIndex<TValues>, Rest> : Head extends keyof NonNull<TValues> ? FieldValueInner<NonNull<TValues>[Head], Rest> : never : P extends IndexSegment ? AtIndex<TValues> : P extends keyof NonNull<TValues> ? NonNull<TValues>[P] : never;
+/**
+ * FieldValue<TValues, P>：
+ * - Given a values type and a FieldPath, infers the value type at that path.
+ */
+type FieldValue<TValues extends object, P extends FieldPath<TValues>> = FieldValueInner<TValues, P>;
+type UnwrapArray<T> = [NonNull<T>] extends [readonly (infer Item)[]] ? Item : NonNull<T>;
+type CanonicalPathInner<T, Depth extends number> = Depth extends 0 ? never : [NonNull<T>] extends [Primitive] ? never : [NonNull<T>] extends [readonly (infer Item)[]] ? CanonicalPathInner<Item, PrevDepth<Depth>> : [NonNull<T>] extends [object] ? {
+    [K in keyof NonNull<T> & string]: K | ([NonNull<T>[K]] extends [readonly (infer Item)[]] ? CanonicalPathInner<Item, PrevDepth<Depth>> extends infer P ? P extends string ? `${K}.${P}` : never : never : IsPlainObject<NonNull<T>[K]> extends true ? Join<K, CanonicalPathInner<NonNull<T>[K], PrevDepth<Depth>>> : never);
+}[keyof NonNull<T> & string] : never;
+/**
+ * CanonicalPath<TValues>：
+ * - The "canonical value path" aligned with Form.rules / Form.Rule.field/list:
+ *   - No numeric segments (`${number}`) and no bracket/[] syntax.
+ *   - For arrays: uses implicit pattern semantics to "pierce through array items"
+ *     (e.g. `items.title`, `items.allocations.amount`).
+ * - Uses a max recursion depth of 5 to avoid TS Server performance issues.
+ */
+type CanonicalPath<TValues extends object> = CanonicalPathInner<TValues, 5>;
+type CanonicalValueInner<TValues, P> = P extends `${infer Head}.${infer Rest}` ? Head extends keyof UnwrapArray<TValues> & string ? CanonicalValueInner<[
+    NonNull<UnwrapArray<TValues>[Head]>
+] extends [readonly (infer Item)[]] ? Item : UnwrapArray<TValues>[Head], Rest> : never : P extends keyof UnwrapArray<TValues> & string ? UnwrapArray<TValues>[P] : never;
+/**
+ * CanonicalValue<TValues, P>：
+ * - Given a values type and a CanonicalPath, infers the value type at that path.
+ */
+type CanonicalValue<TValues extends object, P extends CanonicalPath<TValues>> = CanonicalValueInner<TValues, P>;
+/**
+ * CanonicalListPath<TValues>：
+ * - The subset of CanonicalPath whose endpoints are arrays; used as listPath hints for Form.Rule.list.
+ */
+type CanonicalListPath<TValues extends object> = {
+    [P in CanonicalPath<TValues>]: CanonicalValue<TValues, P> extends readonly any[] ? P : never;
+}[CanonicalPath<TValues>];
+type CanonicalListItem<TValues extends object, P extends CanonicalListPath<TValues>> = CanonicalValue<TValues, P> extends readonly (infer Item)[] ? Item : never;
+
+type AutoValidateOn = 'onChange' | 'onBlur';
+type RuleValidateOn = ReadonlyArray<AutoValidateOn>;
+type RuleFn<Input, Ctx = unknown> = (input: Input, ctx: Ctx) => unknown | undefined;
+type RuleDeps<Input> = Input extends object ? CanonicalPath<Input> extends never ? string : CanonicalPath<Input> : string;
+type Rule<Input, Ctx = unknown> = Logix.StateTrait.CheckRule<Input, Ctx> & {
+    /**
+     * validateOn：
+     * - Only affects the auto-validation phase (onChange/onBlur); submit/manual always runs.
+     * - If an empty array, auto-validation is disabled (only submit/manual runs).
+     */
+    readonly validateOn?: RuleValidateOn;
+};
+type RuleSet<Input, Ctx = unknown> = Readonly<Record<string, Rule<Input, Ctx>>>;
+type RuleEntry<Input, Ctx = unknown> = RuleFn<Input, Ctx> | (Omit<Rule<Input, Ctx>, 'deps'> & {
+    readonly deps?: ReadonlyArray<RuleDeps<Input>>;
+});
+type RuleGroup<Input, Ctx = unknown> = Readonly<{
+    readonly deps?: ReadonlyArray<RuleDeps<Input>>;
+    readonly validateOn?: RuleValidateOn;
+    readonly validate: Readonly<Record<string, RuleEntry<Input, Ctx>>>;
+}>;
+type RuleConfig<Input, Ctx = unknown> = Readonly<{
+    readonly deps?: ReadonlyArray<RuleDeps<Input>>;
+    readonly validateOn?: RuleValidateOn;
+    readonly required?: RequiredDecl;
+    readonly minLength?: MinLengthDecl;
+    readonly maxLength?: MaxLengthDecl;
+    readonly min?: MinDecl;
+    readonly max?: MaxDecl;
+    readonly pattern?: PatternDecl;
+    readonly validate?: RuleFn<Input, Ctx> | Readonly<Record<string, RuleEntry<Input, Ctx>>>;
+}>;
+type RuleInput<Input, Ctx = unknown> = RuleFn<Input, Ctx> | RuleGroup<Input, Ctx> | RuleConfig<Input, Ctx>;
+/**
+ * make：
+ * - The result must be directly attachable to `StateTrait.node({ check })`.
+ * - Does not introduce an extra wrapper (e.g. `{ rules: ... }`).
+ */
+declare const make: <Input, Ctx = unknown>(input: RuleInput<Input, Ctx>) => RuleSet<Input, Ctx>;
+declare const merge: <Input, Ctx = unknown>(...rules: ReadonlyArray<RuleSet<Input, Ctx>>) => RuleSet<Input, Ctx>;
+type ErrorTarget = '$value' | '$self';
+type ListIdentityPolicy = Readonly<{
+    readonly mode: 'trackBy';
+    readonly trackBy: string;
+}> | Readonly<{
+    readonly mode: 'store';
+}> | Readonly<{
+    readonly mode: 'index';
+}>;
+type FieldDecl<Input, Ctx = unknown> = Readonly<{
+    readonly kind: 'field';
+    readonly valuePath: string;
+    readonly rule: RuleInput<Input, Ctx>;
+    readonly errorTarget?: ErrorTarget;
+}>;
+type RootDecl<Input, Ctx = unknown> = Readonly<{
+    readonly kind: 'root';
+    readonly rule: RuleInput<Input, Ctx>;
+}>;
+type ListDecl<Item, Ctx = unknown> = Readonly<{
+    readonly kind: 'list';
+    readonly listPath: string;
+    readonly identity: ListIdentityPolicy;
+    readonly item?: RuleInput<Item, Ctx>;
+    readonly list?: RuleInput<ReadonlyArray<Item>, Ctx>;
+}>;
+type RulesDecl<TValues extends object = any> = FieldDecl<any> | RootDecl<TValues> | ListDecl<any>;
+declare const field: <Input, Ctx = unknown>(valuePath: string, rule: RuleInput<Input, Ctx>, options?: {
+    readonly errorTarget?: ErrorTarget;
+}) => FieldDecl<Input, Ctx>;
+declare const root: <Input, Ctx = unknown>(rule: RuleInput<Input, Ctx>) => RootDecl<Input, Ctx>;
+declare const list: <Item, Ctx = unknown>(listPath: string, spec: {
+    readonly identity: ListIdentityPolicy;
+    readonly item?: RuleInput<Item, Ctx>;
+    readonly list?: RuleInput<ReadonlyArray<Item>, Ctx>;
+}) => ListDecl<Item, Ctx>;
+declare const fields: <Input, Ctx = unknown>(...decls: ReadonlyArray<FieldDecl<Input, Ctx> | ReadonlyArray<FieldDecl<Input, Ctx>>>) => Readonly<Record<string, RuleInput<Input, Ctx>>>;
+
+type Rule$1_AutoValidateOn = AutoValidateOn;
+declare const Rule$1_ERROR_VALUE_MAX_BYTES: typeof ERROR_VALUE_MAX_BYTES;
+type Rule$1_ErrorTarget = ErrorTarget;
+type Rule$1_FieldDecl<Input, Ctx = unknown> = FieldDecl<Input, Ctx>;
+type Rule$1_ListDecl<Item, Ctx = unknown> = ListDecl<Item, Ctx>;
+type Rule$1_ListIdentityPolicy = ListIdentityPolicy;
+type Rule$1_RootDecl<Input, Ctx = unknown> = RootDecl<Input, Ctx>;
+type Rule$1_Rule<Input, Ctx = unknown> = Rule<Input, Ctx>;
+type Rule$1_RuleConfig<Input, Ctx = unknown> = RuleConfig<Input, Ctx>;
+type Rule$1_RuleEntry<Input, Ctx = unknown> = RuleEntry<Input, Ctx>;
+type Rule$1_RuleFn<Input, Ctx = unknown> = RuleFn<Input, Ctx>;
+type Rule$1_RuleGroup<Input, Ctx = unknown> = RuleGroup<Input, Ctx>;
+type Rule$1_RuleInput<Input, Ctx = unknown> = RuleInput<Input, Ctx>;
+type Rule$1_RuleSet<Input, Ctx = unknown> = RuleSet<Input, Ctx>;
+type Rule$1_RuleValidateOn = RuleValidateOn;
+type Rule$1_RulesDecl<TValues extends object = any> = RulesDecl<TValues>;
+declare const Rule$1_assertErrorValueBudget: typeof assertErrorValueBudget;
+declare const Rule$1_field: typeof field;
+declare const Rule$1_fields: typeof fields;
+declare const Rule$1_list: typeof list;
+declare const Rule$1_make: typeof make;
+declare const Rule$1_max: typeof max;
+declare const Rule$1_maxLength: typeof maxLength;
+declare const Rule$1_merge: typeof merge;
+declare const Rule$1_min: typeof min;
+declare const Rule$1_minLength: typeof minLength;
+declare const Rule$1_pattern: typeof pattern;
+declare const Rule$1_required: typeof required;
+declare const Rule$1_root: typeof root;
+declare namespace Rule$1 {
+  export { type Rule$1_AutoValidateOn as AutoValidateOn, Rule$1_ERROR_VALUE_MAX_BYTES as ERROR_VALUE_MAX_BYTES, type Rule$1_ErrorTarget as ErrorTarget, type Rule$1_FieldDecl as FieldDecl, type Rule$1_ListDecl as ListDecl, type Rule$1_ListIdentityPolicy as ListIdentityPolicy, type Rule$1_RootDecl as RootDecl, type Rule$1_Rule as Rule, type Rule$1_RuleConfig as RuleConfig, type Rule$1_RuleEntry as RuleEntry, type Rule$1_RuleFn as RuleFn, type Rule$1_RuleGroup as RuleGroup, type Rule$1_RuleInput as RuleInput, type Rule$1_RuleSet as RuleSet, type Rule$1_RuleValidateOn as RuleValidateOn, type Rule$1_RulesDecl as RulesDecl, Rule$1_assertErrorValueBudget as assertErrorValueBudget, Rule$1_field as field, Rule$1_fields as fields, Rule$1_list as list, Rule$1_make as make, Rule$1_max as max, Rule$1_maxLength as maxLength, Rule$1_merge as merge, Rule$1_min as min, Rule$1_minLength as minLength, Rule$1_pattern as pattern, Rule$1_required as required, Rule$1_root as root };
+}
+
+export { type AutoValidateOn as A, maxLength as B, type CanonicalPath as C, min as D, type ErrorTarget as E, type FieldPath as F, max as G, pattern as H, type ListIdentityPolicy as L, Rule$1 as R, type FieldValue as a, type CanonicalValue as b, type CanonicalListPath as c, type CanonicalListItem as d, type RulesDecl as e, type RuleInput as f, type RootDecl as g, type ListDecl as h, type FieldDecl as i, type RuleEntry as j, type RuleValidateOn as k, type RuleFn as l, type Rule as m, type RuleSet as n, type RuleGroup as o, type RuleConfig as p, make as q, merge as r, field as s, root as t, list as u, fields as v, ERROR_VALUE_MAX_BYTES as w, assertErrorValueBudget as x, required as y, minLength as z };

package/dist/Rule-BOAiSVz9.d.ts

@@ -0,0 +1,202 @@
+import * as Logix from '@logixjs/core';
+
+declare const ERROR_VALUE_MAX_BYTES = 256;
+declare const assertErrorValueBudget: (value: unknown, label: string) => unknown;
+type RequiredDecl = boolean | string | Readonly<{
+    readonly message?: string;
+    readonly trim?: boolean;
+}>;
+declare const required: (decl: RequiredDecl) => ((value: unknown) => unknown | undefined);
+type MinLengthDecl = number | Readonly<{
+    readonly min: number;
+    readonly message?: string;
+}>;
+declare const minLength: (decl: MinLengthDecl) => ((value: unknown) => unknown | undefined);
+type MaxLengthDecl = number | Readonly<{
+    readonly max: number;
+    readonly message?: string;
+}>;
+declare const maxLength: (decl: MaxLengthDecl) => ((value: unknown) => unknown | undefined);
+type MinDecl = number | Readonly<{
+    readonly min: number;
+    readonly message?: string;
+}>;
+declare const min: (decl: MinDecl) => ((value: unknown) => unknown | undefined);
+type MaxDecl = number | Readonly<{
+    readonly max: number;
+    readonly message?: string;
+}>;
+declare const max: (decl: MaxDecl) => ((value: unknown) => unknown | undefined);
+type PatternDecl = RegExp | Readonly<{
+    readonly re: RegExp;
+    readonly message?: string;
+}>;
+declare const pattern: (decl: PatternDecl) => ((value: unknown) => unknown | undefined);
+
+type Primitive = string | number | boolean | bigint | symbol | null | undefined | Date | RegExp | Function;
+type NonNull<T> = Exclude<T, null | undefined>;
+type IsPlainObject<T> = [NonNull<T>] extends [Primitive] ? false : [NonNull<T>] extends [readonly any[]] ? false : [NonNull<T>] extends [Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any>] ? false : [NonNull<T>] extends [object] ? true : false;
+type Join<K, P> = K extends string ? (P extends string ? `${K}.${P}` : never) : never;
+type PrevDepth<D extends number> = D extends 5 ? 4 : D extends 4 ? 3 : D extends 3 ? 2 : D extends 2 ? 1 : D extends 1 ? 0 : 0;
+type IndexSegment = `${number}`;
+type FieldPathInner<T, Depth extends number> = Depth extends 0 ? never : [NonNull<T>] extends [Primitive] ? never : [NonNull<T>] extends [readonly (infer Item)[]] ? IndexSegment | (FieldPathInner<Item, PrevDepth<Depth>> extends infer P ? P extends string ? `${IndexSegment}.${P}` : never : never) : [NonNull<T>] extends [object] ? {
+    [K in keyof NonNull<T> & string]: K | ([NonNull<T>[K]] extends [readonly (infer Item)[]] ? `${K}.${IndexSegment}` | (FieldPathInner<Item, PrevDepth<Depth>> extends infer P ? P extends string ? `${K}.${IndexSegment}.${P}` : never : never) : IsPlainObject<NonNull<T>[K]> extends true ? Join<K, FieldPathInner<NonNull<T>[K], PrevDepth<Depth>>> : never);
+}[keyof NonNull<T> & string] : never;
+/**
+ * FieldPath<TValues>：
+ * - A typed version of valuePath strings (aligned with the "ValuePath" mental model from 010).
+ *   Array indices are represented as `${number}`; examples:
+ *   - "profile.name"
+ *   - "items.${number}.warehouseId"
+ * - Uses a max recursion depth of 5 to avoid TS Server performance issues.
+ */
+type FieldPath<TValues extends object> = FieldPathInner<TValues, 5>;
+type AtIndex<T> = NonNull<T> extends readonly (infer Item)[] ? Item : never;
+type FieldValueInner<TValues, P> = P extends `${infer Head}.${infer Rest}` ? Head extends IndexSegment ? FieldValueInner<AtIndex<TValues>, Rest> : Head extends keyof NonNull<TValues> ? FieldValueInner<NonNull<TValues>[Head], Rest> : never : P extends IndexSegment ? AtIndex<TValues> : P extends keyof NonNull<TValues> ? NonNull<TValues>[P] : never;
+/**
+ * FieldValue<TValues, P>：
+ * - Given a values type and a FieldPath, infers the value type at that path.
+ */
+type FieldValue<TValues extends object, P extends FieldPath<TValues>> = FieldValueInner<TValues, P>;
+type UnwrapArray<T> = [NonNull<T>] extends [readonly (infer Item)[]] ? Item : NonNull<T>;
+type CanonicalPathInner<T, Depth extends number> = Depth extends 0 ? never : [NonNull<T>] extends [Primitive] ? never : [NonNull<T>] extends [readonly (infer Item)[]] ? CanonicalPathInner<Item, PrevDepth<Depth>> : [NonNull<T>] extends [object] ? {
+    [K in keyof NonNull<T> & string]: K | ([NonNull<T>[K]] extends [readonly (infer Item)[]] ? CanonicalPathInner<Item, PrevDepth<Depth>> extends infer P ? P extends string ? `${K}.${P}` : never : never : IsPlainObject<NonNull<T>[K]> extends true ? Join<K, CanonicalPathInner<NonNull<T>[K], PrevDepth<Depth>>> : never);
+}[keyof NonNull<T> & string] : never;
+/**
+ * CanonicalPath<TValues>：
+ * - The "canonical value path" aligned with Form.rules / Form.Rule.field/list:
+ *   - No numeric segments (`${number}`) and no bracket/[] syntax.
+ *   - For arrays: uses implicit pattern semantics to "pierce through array items"
+ *     (e.g. `items.title`, `items.allocations.amount`).
+ * - Uses a max recursion depth of 5 to avoid TS Server performance issues.
+ */
+type CanonicalPath<TValues extends object> = CanonicalPathInner<TValues, 5>;
+type CanonicalValueInner<TValues, P> = P extends `${infer Head}.${infer Rest}` ? Head extends keyof UnwrapArray<TValues> & string ? CanonicalValueInner<[
+    NonNull<UnwrapArray<TValues>[Head]>
+] extends [readonly (infer Item)[]] ? Item : UnwrapArray<TValues>[Head], Rest> : never : P extends keyof UnwrapArray<TValues> & string ? UnwrapArray<TValues>[P] : never;
+/**
+ * CanonicalValue<TValues, P>：
+ * - Given a values type and a CanonicalPath, infers the value type at that path.
+ */
+type CanonicalValue<TValues extends object, P extends CanonicalPath<TValues>> = CanonicalValueInner<TValues, P>;
+/**
+ * CanonicalListPath<TValues>：
+ * - The subset of CanonicalPath whose endpoints are arrays; used as listPath hints for Form.Rule.list.
+ */
+type CanonicalListPath<TValues extends object> = {
+    [P in CanonicalPath<TValues>]: CanonicalValue<TValues, P> extends readonly any[] ? P : never;
+}[CanonicalPath<TValues>];
+type CanonicalListItem<TValues extends object, P extends CanonicalListPath<TValues>> = CanonicalValue<TValues, P> extends readonly (infer Item)[] ? Item : never;
+
+type AutoValidateOn = 'onChange' | 'onBlur';
+type RuleValidateOn = ReadonlyArray<AutoValidateOn>;
+type RuleFn<Input, Ctx = unknown> = (input: Input, ctx: Ctx) => unknown | undefined;
+type RuleDeps<Input> = Input extends object ? CanonicalPath<Input> extends never ? string : CanonicalPath<Input> : string;
+type Rule<Input, Ctx = unknown> = Logix.StateTrait.CheckRule<Input, Ctx> & {
+    /**
+     * validateOn：
+     * - Only affects the auto-validation phase (onChange/onBlur); submit/manual always runs.
+     * - If an empty array, auto-validation is disabled (only submit/manual runs).
+     */
+    readonly validateOn?: RuleValidateOn;
+};
+type RuleSet<Input, Ctx = unknown> = Readonly<Record<string, Rule<Input, Ctx>>>;
+type RuleEntry<Input, Ctx = unknown> = RuleFn<Input, Ctx> | (Omit<Rule<Input, Ctx>, 'deps'> & {
+    readonly deps?: ReadonlyArray<RuleDeps<Input>>;
+});
+type RuleGroup<Input, Ctx = unknown> = Readonly<{
+    readonly deps?: ReadonlyArray<RuleDeps<Input>>;
+    readonly validateOn?: RuleValidateOn;
+    readonly validate: Readonly<Record<string, RuleEntry<Input, Ctx>>>;
+}>;
+type RuleConfig<Input, Ctx = unknown> = Readonly<{
+    readonly deps?: ReadonlyArray<RuleDeps<Input>>;
+    readonly validateOn?: RuleValidateOn;
+    readonly required?: RequiredDecl;
+    readonly minLength?: MinLengthDecl;
+    readonly maxLength?: MaxLengthDecl;
+    readonly min?: MinDecl;
+    readonly max?: MaxDecl;
+    readonly pattern?: PatternDecl;
+    readonly validate?: RuleFn<Input, Ctx> | Readonly<Record<string, RuleEntry<Input, Ctx>>>;
+}>;
+type RuleInput<Input, Ctx = unknown> = RuleFn<Input, Ctx> | RuleGroup<Input, Ctx> | RuleConfig<Input, Ctx>;
+/**
+ * make：
+ * - The result must be directly attachable to `StateTrait.node({ check })`.
+ * - Does not introduce an extra wrapper (e.g. `{ rules: ... }`).
+ */
+declare const make: <Input, Ctx = unknown>(input: RuleInput<Input, Ctx>) => RuleSet<Input, Ctx>;
+declare const merge: <Input, Ctx = unknown>(...rules: ReadonlyArray<RuleSet<Input, Ctx>>) => RuleSet<Input, Ctx>;
+type ErrorTarget = '$value' | '$self';
+type ListIdentityPolicy = Readonly<{
+    readonly mode: 'trackBy';
+    readonly trackBy: string;
+}> | Readonly<{
+    readonly mode: 'store';
+}> | Readonly<{
+    readonly mode: 'index';
+}>;
+type FieldDecl<Input, Ctx = unknown> = Readonly<{
+    readonly kind: 'field';
+    readonly valuePath: string;
+    readonly rule: RuleInput<Input, Ctx>;
+    readonly errorTarget?: ErrorTarget;
+}>;
+type RootDecl<Input, Ctx = unknown> = Readonly<{
+    readonly kind: 'root';
+    readonly rule: RuleInput<Input, Ctx>;
+}>;
+type ListDecl<Item, Ctx = unknown> = Readonly<{
+    readonly kind: 'list';
+    readonly listPath: string;
+    readonly identity: ListIdentityPolicy;
+    readonly item?: RuleInput<Item, Ctx>;
+    readonly list?: RuleInput<ReadonlyArray<Item>, Ctx>;
+}>;
+type RulesDecl<TValues extends object = any> = FieldDecl<any> | RootDecl<TValues> | ListDecl<any>;
+declare const field: <Input, Ctx = unknown>(valuePath: string, rule: RuleInput<Input, Ctx>, options?: {
+    readonly errorTarget?: ErrorTarget;
+}) => FieldDecl<Input, Ctx>;
+declare const root: <Input, Ctx = unknown>(rule: RuleInput<Input, Ctx>) => RootDecl<Input, Ctx>;
+declare const list: <Item, Ctx = unknown>(listPath: string, spec: {
+    readonly identity: ListIdentityPolicy;
+    readonly item?: RuleInput<Item, Ctx>;
+    readonly list?: RuleInput<ReadonlyArray<Item>, Ctx>;
+}) => ListDecl<Item, Ctx>;
+declare const fields: <Input, Ctx = unknown>(...decls: ReadonlyArray<FieldDecl<Input, Ctx> | ReadonlyArray<FieldDecl<Input, Ctx>>>) => Readonly<Record<string, RuleInput<Input, Ctx>>>;
+
+type Rule$1_AutoValidateOn = AutoValidateOn;
+declare const Rule$1_ERROR_VALUE_MAX_BYTES: typeof ERROR_VALUE_MAX_BYTES;
+type Rule$1_ErrorTarget = ErrorTarget;
+type Rule$1_FieldDecl<Input, Ctx = unknown> = FieldDecl<Input, Ctx>;
+type Rule$1_ListDecl<Item, Ctx = unknown> = ListDecl<Item, Ctx>;
+type Rule$1_ListIdentityPolicy = ListIdentityPolicy;
+type Rule$1_RootDecl<Input, Ctx = unknown> = RootDecl<Input, Ctx>;
+type Rule$1_Rule<Input, Ctx = unknown> = Rule<Input, Ctx>;
+type Rule$1_RuleConfig<Input, Ctx = unknown> = RuleConfig<Input, Ctx>;
+type Rule$1_RuleEntry<Input, Ctx = unknown> = RuleEntry<Input, Ctx>;
+type Rule$1_RuleFn<Input, Ctx = unknown> = RuleFn<Input, Ctx>;
+type Rule$1_RuleGroup<Input, Ctx = unknown> = RuleGroup<Input, Ctx>;
+type Rule$1_RuleInput<Input, Ctx = unknown> = RuleInput<Input, Ctx>;
+type Rule$1_RuleSet<Input, Ctx = unknown> = RuleSet<Input, Ctx>;
+type Rule$1_RuleValidateOn = RuleValidateOn;
+type Rule$1_RulesDecl<TValues extends object = any> = RulesDecl<TValues>;
+declare const Rule$1_assertErrorValueBudget: typeof assertErrorValueBudget;
+declare const Rule$1_field: typeof field;
+declare const Rule$1_fields: typeof fields;
+declare const Rule$1_list: typeof list;
+declare const Rule$1_make: typeof make;
+declare const Rule$1_max: typeof max;
+declare const Rule$1_maxLength: typeof maxLength;
+declare const Rule$1_merge: typeof merge;
+declare const Rule$1_min: typeof min;
+declare const Rule$1_minLength: typeof minLength;
+declare const Rule$1_pattern: typeof pattern;
+declare const Rule$1_required: typeof required;
+declare const Rule$1_root: typeof root;
+declare namespace Rule$1 {
+  export { type Rule$1_AutoValidateOn as AutoValidateOn, Rule$1_ERROR_VALUE_MAX_BYTES as ERROR_VALUE_MAX_BYTES, type Rule$1_ErrorTarget as ErrorTarget, type Rule$1_FieldDecl as FieldDecl, type Rule$1_ListDecl as ListDecl, type Rule$1_ListIdentityPolicy as ListIdentityPolicy, type Rule$1_RootDecl as RootDecl, type Rule$1_Rule as Rule, type Rule$1_RuleConfig as RuleConfig, type Rule$1_RuleEntry as RuleEntry, type Rule$1_RuleFn as RuleFn, type Rule$1_RuleGroup as RuleGroup, type Rule$1_RuleInput as RuleInput, type Rule$1_RuleSet as RuleSet, type Rule$1_RuleValidateOn as RuleValidateOn, type Rule$1_RulesDecl as RulesDecl, Rule$1_assertErrorValueBudget as assertErrorValueBudget, Rule$1_field as field, Rule$1_fields as fields, Rule$1_list as list, Rule$1_make as make, Rule$1_max as max, Rule$1_maxLength as maxLength, Rule$1_merge as merge, Rule$1_min as min, Rule$1_minLength as minLength, Rule$1_pattern as pattern, Rule$1_required as required, Rule$1_root as root };
+}
+
+export { type AutoValidateOn as A, maxLength as B, type CanonicalPath as C, min as D, type ErrorTarget as E, type FieldPath as F, max as G, pattern as H, type ListIdentityPolicy as L, Rule$1 as R, type FieldValue as a, type CanonicalValue as b, type CanonicalListPath as c, type CanonicalListItem as d, type RulesDecl as e, type RuleInput as f, type RootDecl as g, type ListDecl as h, type FieldDecl as i, type RuleEntry as j, type RuleValidateOn as k, type RuleFn as l, type Rule as m, type RuleSet as n, type RuleGroup as o, type RuleConfig as p, make as q, merge as r, field as s, root as t, list as u, fields as v, ERROR_VALUE_MAX_BYTES as w, assertErrorValueBudget as x, required as y, minLength as z };