@regle/rules 1.17.4 → 1.18.0-beta.2

package/dist/regle-rules.d.ts

@@ -1,12 +1,12 @@
 /**
- * @regle/rules v1.17.4
+ * @regle/rules v1.18.0-beta.2
  * (c) 2026 Victor Garcia
  * @license MIT
  */
 
-import { CommonAlphaOptions, CommonComparisonOptions, ExtendedRulesDeclarations, FormRuleDeclaration, InlineRuleDeclaration, Maybe, MaybeInput, MaybeReadonly, NonEmptyTuple, RegleRuleDecl, RegleRuleDefinition, RegleRuleDefinitionWithMetadataProcessor, RegleRuleMetadataConsumer, RegleRuleMetadataDefinition, RegleRuleWithParamsDefinition, RegleRuleWithParamsDefinitionInput, UnwrapRegleUniversalParams } from "@regle/core";
+import { CommonAlphaOptions, CommonComparisonOptions, ExtendedRulesDeclarations, FormRuleDeclaration, InlineRuleDeclaration, Maybe, MaybeInput, MaybeReadonly, NonEmptyTuple, Prettify, RegleRuleDecl, RegleRuleDefinition, RegleRuleDefinitionWithMetadataProcessor, RegleRuleMetadataConsumer, RegleRuleMetadataDefinition, RegleRuleWithParamsDefinition, RegleRuleWithParamsDefinitionInput, UnwrapRegleUniversalParams } from "@regle/core";
 import { ComputedRef, MaybeRef, MaybeRefOrGetter, Ref } from "vue";
-import { EmptyObject } from "type-fest";
+import { EmptyObject, IsTuple, IsUnknown } from "type-fest";
 /**
  * The `withMessage` wrapper lets you associate an error message with a rule.
  * Pass your rule as the first argument and the error message as the second.
@@ -33,10 +33,10 @@ import { EmptyObject } from "type-fest";
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/rule-wrappers#withmessage Documentation}
  */
-declare function withMessage<TValue$1 extends any, TParams$1 extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: RegleRuleWithParamsDefinition<TValue$1, TParams$1, TAsync$1, TMetadata$1>, newMessage: RegleRuleDefinitionWithMetadataProcessor<TValue$1, RegleRuleMetadataConsumer<TValue$1, TParams$1, TMetadata$1>, string | string[]>): RegleRuleWithParamsDefinition<TValue$1, TParams$1, TAsync$1, TMetadata$1>;
-declare function withMessage<TValue$1 extends any, TParams$1 extends unknown[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: RegleRuleDefinition<TValue$1, TParams$1, TAsync$1, TMetadata$1>, newMessage: RegleRuleDefinitionWithMetadataProcessor<TValue$1, RegleRuleMetadataConsumer<TValue$1, TParams$1, TMetadata$1>, string | string[]>): RegleRuleDefinition<TValue$1, TParams$1, TAsync$1, TMetadata$1>;
-declare function withMessage<TValue$1 extends any, TParams$1 extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: InlineRuleDeclaration<TValue$1, TParams$1, TReturn>, newMessage: RegleRuleDefinitionWithMetadataProcessor<TValue$1, RegleRuleMetadataConsumer<TValue$1, TParams$1, TReturn extends Promise<infer M> ? M : TReturn>, string | string[]>): RegleRuleDefinition<TValue$1, TParams$1, TAsync$1, TReturn extends Promise<infer M> ? M : TReturn>;
-declare function withMessage<TValue$1 extends any, TParams$1 extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: (...args: any[]) => RegleRuleDefinition<TValue$1, TParams$1, TAsync$1, TMetadata$1>, newMessage: RegleRuleDefinitionWithMetadataProcessor<TValue$1, RegleRuleMetadataConsumer<TValue$1, TParams$1, TMetadata$1>, string | string[]>): RegleRuleWithParamsDefinition<TValue$1, TParams$1, TAsync$1, TMetadata$1>;
+declare function withMessage<TType$1 extends string | unknown, TValue$1 extends any, TParams$1 extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: RegleRuleWithParamsDefinition<TType$1, TValue$1, TParams$1, TAsync$1, TMetadata$1>, newMessage: RegleRuleDefinitionWithMetadataProcessor<TValue$1, RegleRuleMetadataConsumer<TValue$1, TParams$1, TMetadata$1>, string | string[]>): RegleRuleWithParamsDefinition<TType$1, TValue$1, TParams$1, TAsync$1, TMetadata$1>;
+declare function withMessage<TType$1 extends string | unknown, TValue$1 extends any, TParams$1 extends unknown[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: RegleRuleDefinition<TType$1, TValue$1, TParams$1, TAsync$1, TMetadata$1>, newMessage: RegleRuleDefinitionWithMetadataProcessor<TValue$1, RegleRuleMetadataConsumer<TValue$1, TParams$1, TMetadata$1>, string | string[]>): RegleRuleDefinition<TType$1, TValue$1, TParams$1, TAsync$1, TMetadata$1>;
+declare function withMessage<TValue$1 extends any, TParams$1 extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: InlineRuleDeclaration<TValue$1, TParams$1, TReturn>, newMessage: RegleRuleDefinitionWithMetadataProcessor<TValue$1, RegleRuleMetadataConsumer<TValue$1, TParams$1, TReturn extends Promise<infer M> ? M : TReturn>, string | string[]>): RegleRuleDefinition<unknown, TValue$1, TParams$1, TAsync$1, TReturn extends Promise<infer M> ? M : TReturn>;
+declare function withMessage<TType$1 extends string | unknown, TValue$1 extends any, TParams$1 extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: (...args: any[]) => RegleRuleDefinition<TType$1, TValue$1, TParams$1, TAsync$1, TMetadata$1>, newMessage: RegleRuleDefinitionWithMetadataProcessor<TValue$1, RegleRuleMetadataConsumer<TValue$1, TParams$1, TMetadata$1>, string | string[]>): RegleRuleWithParamsDefinition<TType$1, TValue$1, TParams$1, TAsync$1, TMetadata$1>;
 /**
  * The `withTooltip` wrapper allows you to display additional messages for your field that aren't necessarily errors.
  * Tooltips are aggregated and accessible via `$tooltips` property.
@@ -63,9 +63,9 @@ declare function withMessage<TValue$1 extends any, TParams$1 extends any[], TRet
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/rule-wrappers#withtooltip Documentation}
  */
-declare function withTooltip<TValue$1 extends any, TParams$1 extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: RegleRuleWithParamsDefinition<TValue$1, TParams$1, TAsync$1, TMetadata$1>, newTooltip: RegleRuleDefinitionWithMetadataProcessor<TValue$1, RegleRuleMetadataConsumer<TValue$1, TParams$1, TMetadata$1>, string | string[]>): RegleRuleWithParamsDefinition<TValue$1, TParams$1, TAsync$1, TMetadata$1>;
-declare function withTooltip<TValue$1 extends any, TParams$1 extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: RegleRuleDefinition<TValue$1, TParams$1, TAsync$1, TMetadata$1>, newTooltip: RegleRuleDefinitionWithMetadataProcessor<TValue$1, RegleRuleMetadataConsumer<TValue$1, TParams$1, TMetadata$1>, string | string[]>): RegleRuleDefinition<TValue$1, TParams$1, TAsync$1, TMetadata$1>;
-declare function withTooltip<TValue$1 extends any, TParams$1 extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: InlineRuleDeclaration<TValue$1, TParams$1, TReturn>, newTooltip: RegleRuleDefinitionWithMetadataProcessor<TValue$1, RegleRuleMetadataConsumer<TValue$1, TParams$1, TReturn extends Promise<infer M> ? M : TReturn>, string | string[]>): RegleRuleDefinition<TValue$1, TParams$1, TAsync$1, TReturn extends Promise<infer M> ? M : TReturn>;
+declare function withTooltip<TType$1 extends string | unknown, TValue$1 extends any, TParams$1 extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: RegleRuleWithParamsDefinition<TType$1, TValue$1, TParams$1, TAsync$1, TMetadata$1>, newTooltip: RegleRuleDefinitionWithMetadataProcessor<TValue$1, RegleRuleMetadataConsumer<TValue$1, TParams$1, TMetadata$1>, string | string[]>): RegleRuleWithParamsDefinition<TType$1, TValue$1, TParams$1, TAsync$1, TMetadata$1>;
+declare function withTooltip<TType$1 extends string | unknown, TValue$1 extends any, TParams$1 extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: RegleRuleDefinition<TType$1, TValue$1, TParams$1, TAsync$1, TMetadata$1>, newTooltip: RegleRuleDefinitionWithMetadataProcessor<TValue$1, RegleRuleMetadataConsumer<TValue$1, TParams$1, TMetadata$1>, string | string[]>): RegleRuleDefinition<TType$1, TValue$1, TParams$1, TAsync$1, TMetadata$1>;
+declare function withTooltip<TValue$1 extends any, TParams$1 extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: InlineRuleDeclaration<TValue$1, TParams$1, TReturn>, newTooltip: RegleRuleDefinitionWithMetadataProcessor<TValue$1, RegleRuleMetadataConsumer<TValue$1, TParams$1, TReturn extends Promise<infer M> ? M : TReturn>, string | string[]>): RegleRuleDefinition<unknown, TValue$1, TParams$1, TAsync$1, TReturn extends Promise<infer M> ? M : TReturn>;
 /**
  * `withAsync` works like `withParams`, but is specifically designed for async rules that depend on external values.
  *
@@ -89,8 +89,8 @@ declare function withTooltip<TValue$1 extends any, TParams$1 extends any[], TRet
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/rule-wrappers#withasync Documentation}
  */
-declare function withAsync<TValue$1, TParams$1 extends (Ref<unknown> | (() => unknown))[] = [], TReturn extends Promise<RegleRuleMetadataDefinition> = Promise<RegleRuleMetadataDefinition>, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn)>(rule: InlineRuleDeclaration<TValue$1, TParams$1, TReturn>, depsArray?: [...TParams$1]): RegleRuleDefinition<TValue$1, UnwrapRegleUniversalParams<TParams$1>, true, TMetadata$1>;
-declare function withAsync<TValue$1 extends any, TParams$1 extends any[], TMetadata$1 extends RegleRuleMetadataDefinition>(rule: RegleRuleWithParamsDefinition<TValue$1, TParams$1, true, TMetadata$1>, depsArray?: [...TParams$1]): RegleRuleWithParamsDefinition<TValue$1, TParams$1, true, TMetadata$1>;
+declare function withAsync<TValue$1, TParams$1 extends (Ref<unknown> | (() => unknown))[] = [], TReturn extends Promise<RegleRuleMetadataDefinition> = Promise<RegleRuleMetadataDefinition>, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn)>(rule: InlineRuleDeclaration<TValue$1, TParams$1, TReturn>, depsArray?: [...TParams$1]): RegleRuleDefinition<unknown, TValue$1, UnwrapRegleUniversalParams<TParams$1>, true, TMetadata$1>;
+declare function withAsync<TType$1 extends string | unknown, TValue$1 extends any, TParams$1 extends any[], TMetadata$1 extends RegleRuleMetadataDefinition>(rule: RegleRuleWithParamsDefinition<TType$1, TValue$1, TParams$1, true, TMetadata$1>, depsArray?: [...TParams$1]): RegleRuleWithParamsDefinition<TType$1, TValue$1, TParams$1, true, TMetadata$1>;
 /**
  * The `withParams` wrapper allows your rule to depend on external parameters,
  * such as a reactive property in your component or store.
@@ -118,8 +118,14 @@ declare function withAsync<TValue$1 extends any, TParams$1 extends any[], TMetad
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/rule-wrappers#withparams Documentation}
  */
-declare function withParams<TValue$1, TParams$1 extends (Ref<unknown> | (() => unknown))[] = [], TReturn extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: InlineRuleDeclaration<TValue$1, TParams$1, TReturn> | RegleRuleDefinition<TValue$1, any[], TAsync$1, TMetadata$1>, depsArray: [...TParams$1]): RegleRuleDefinition<TValue$1, UnwrapRegleUniversalParams<TParams$1>, TAsync$1, TMetadata$1>;
-declare function withParams<TValue$1 extends any, TParams$1 extends any[], TReturn extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: RegleRuleWithParamsDefinition<TValue$1, TParams$1, TAsync$1, TMetadata$1>, depsArray: [...TParams$1]): RegleRuleWithParamsDefinition<TValue$1, TParams$1, TAsync$1, TMetadata$1>;
+declare function withParams<TType$1 extends string | unknown, TValue$1, TParams$1 extends (Ref<unknown> | (() => unknown))[] = [], TReturn extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: InlineRuleDeclaration<TValue$1, TParams$1, TReturn> | RegleRuleDefinition<TType$1, TValue$1, any[], TAsync$1, TMetadata$1>, depsArray: [...TParams$1]): RegleRuleDefinition<TType$1, TValue$1, UnwrapRegleUniversalParams<TParams$1>, TAsync$1, TMetadata$1>;
+declare function withParams<TType$1 extends string | unknown, TValue$1 extends any, TParams$1 extends any[], TReturn extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: RegleRuleWithParamsDefinition<TType$1, TValue$1, TParams$1, TAsync$1, TMetadata$1>, depsArray: [...TParams$1]): RegleRuleWithParamsDefinition<TType$1, TValue$1, TParams$1, TAsync$1, TMetadata$1>;
+interface ApplyIfOptions {
+  /**
+   * ⚠️ Internal use for the `pipe` operator.
+   */
+  hideParams?: boolean;
+}
 /**
  * The `applyIf` operator is similar to `requiredIf`, but it can be used with **any rule**.
  * It simplifies conditional rule declarations.
@@ -143,7 +149,7 @@ declare function withParams<TValue$1 extends any, TParams$1 extends any[], TRetu
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/rules-operators#applyif Documentation}
  */
-declare function applyIf<TRule extends FormRuleDeclaration<any>>(_condition: MaybeRefOrGetter<Maybe<boolean>>, rule: TRule): TRule extends InlineRuleDeclaration<infer TValue, infer TParams, infer TReturn> ? RegleRuleDefinition<TValue, [...TParams, condition: boolean], TReturn extends Promise<any> ? true : false, TReturn extends Promise<infer M> ? M : TReturn> : TRule extends RegleRuleWithParamsDefinitionInput<infer TValue, infer TParams, infer TAsync, infer TMetadata> ? RegleRuleDefinition<TValue, [...TParams, condition: boolean], TAsync, TMetadata> : TRule extends RegleRuleDefinition<infer TValue, any[], infer TAsync, infer TMetadata> ? RegleRuleDefinition<TValue, [condition: boolean], TAsync, TMetadata> : TRule;
+declare function applyIf<TRule extends FormRuleDeclaration<any>>(_condition: MaybeRefOrGetter<Maybe<boolean>>, rule: TRule, options?: ApplyIfOptions): TRule extends InlineRuleDeclaration<infer TValue, infer TParams, infer TReturn> ? RegleRuleDefinition<'applyIf', TValue, [...TParams, condition: boolean], TReturn extends Promise<any> ? true : false, TReturn extends Promise<infer M> ? M : TReturn> : TRule extends RegleRuleWithParamsDefinitionInput<infer TType, infer TValue, infer TParams, infer TAsync, infer TMetadata> ? RegleRuleDefinition<TType, TValue, [...TParams, condition: boolean], TAsync, TMetadata> : TRule extends RegleRuleDefinition<infer TType, infer TValue, any[], infer TAsync, infer TMetadata> ? RegleRuleDefinition<TType, TValue, [condition: boolean], TAsync, TMetadata> : TRule;
 /**
  * Checks if any value you provide is defined (including arrays and objects).
  * This is almost a must-have for optional fields when writing custom rules.
@@ -174,7 +180,7 @@ declare function applyIf<TRule extends FormRuleDeclaration<any>>(_condition: May
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/validations-helpers#isfilled Documentation}
  */
-declare function isFilled<T extends unknown>(value: T, considerEmptyArrayInvalid?: boolean): value is NonNullable<T>;
+declare function isFilled<T extends unknown>(value: T, considerEmptyArrayInvalid?: boolean, considerEmptyObjectInvalid?: boolean): value is NonNullable<T>;
 /**
  * Type guard that checks if the passed value is a real `Number`.
  * Returns `false` for `NaN`, making it safer than `typeof value === "number"`.
@@ -305,7 +311,7 @@ declare function toNumber<T extends number | string | undefined>(argument: T): n
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/validations-helpers#isempty Documentation}
  */
-declare function isEmpty(value: unknown, considerEmptyArrayInvalid?: boolean): value is null | undefined | [] | EmptyObject;
+declare function isEmpty(value: unknown, considerEmptyArrayInvalid?: boolean, considerEmptyObjectInvalid?: boolean): value is null | undefined | [] | EmptyObject;
 /**
  * Checks if the provided value is a valid Date. Used internally for date rules.
  * Can also validate date strings.
@@ -350,16 +356,18 @@ declare function isDate(value: unknown): value is Date | string;
  * @see {@link https://reglejs.dev/core-concepts/rules/validations-helpers#todate Documentation}
  */
 declare function toDate(argument: Date | number | string | null | undefined): Date;
-type ExtractValueFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<infer V, any, any, any> ? [V, ...ExtractValueFromRules<R>] : F extends InlineRuleDeclaration<infer V, any> ? [V, ...ExtractValueFromRules<R>] : [F, ...ExtractValueFromRules<R>] : [];
-type ExtractAsyncStatesFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<any, any, infer A, any> ? [A, ...ExtractValueFromRules<R>] : F extends InlineRuleDeclaration<any, any> ? [ReturnType<F> extends Promise<any> ? true : false, ...ExtractValueFromRules<R>] : [F, ...ExtractValueFromRules<R>] : [];
-type ExtractAsync<T extends [...any[]]> = T extends [infer F, ...infer R] ? F extends true ? true : F extends false ? ExtractAsync<R> : false : false;
-type GuessAsyncFromRules<T extends any[]> = ExtractAsync<ExtractAsyncStatesFromRules<T>>;
-type ExtractParamsFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<any, infer P, any, any> ? [P, ...ExtractParamsFromRules<R>] : [F, ...ExtractParamsFromRules<R>] : [];
+type ExtractBoolean<T extends [...any[]]> = T extends [infer F, ...infer R] ? F extends true ? true : F extends false ? ExtractBoolean<R> : false : false;
+type ExtractValueFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<unknown, infer V, any, any, any> ? [V, ...ExtractValueFromRules<R>] : F extends InlineRuleDeclaration<infer V, any> ? [V, ...ExtractValueFromRules<R>] : [F, ...ExtractValueFromRules<R>] : [];
+type ExtractAsyncStatesFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<unknown, any, any, infer A, any> ? [A, ...ExtractValueFromRules<R>] : F extends InlineRuleDeclaration<any, any> ? [ReturnType<F> extends Promise<any> ? true : false, ...ExtractValueFromRules<R>] : [F, ...ExtractValueFromRules<R>] : [];
+type GuessAsyncFromRules<T extends any[]> = ExtractBoolean<ExtractAsyncStatesFromRules<T>>;
+type ExtractNoEmptyStatesFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<unknown, any, any, any, any, any, any, infer NonEmpty extends boolean> ? [NonEmpty, ...ExtractNoEmptyStatesFromRules<R>] : [false, ...ExtractNoEmptyStatesFromRules<R>] : [];
+type GuessNoEmptyFromRules<T extends any[]> = ExtractBoolean<ExtractNoEmptyStatesFromRules<T>>;
+type ExtractParamsFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<unknown, any, infer P, any, any> ? [P, ...ExtractParamsFromRules<R>] : [F, ...ExtractParamsFromRules<R>] : [];
 type MetadataBase = {
   $valid: boolean;
   [x: string]: any;
 };
-type ExtractMetaDataFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<any, any, any, infer M extends MetadataBase> ? [M, ...ExtractMetaDataFromRules<R>] : F extends InlineRuleDeclaration<any, any[], infer M extends MetadataBase | Promise<MetadataBase>> ? [M, ...ExtractMetaDataFromRules<R>] : [...ExtractMetaDataFromRules<R>] : [];
+type ExtractMetaDataFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<unknown, any, any, any, infer M extends MetadataBase> ? [M, ...ExtractMetaDataFromRules<R>] : F extends InlineRuleDeclaration<any, any[], infer M extends MetadataBase | Promise<MetadataBase>> ? [M, ...ExtractMetaDataFromRules<R>] : [...ExtractMetaDataFromRules<R>] : [];
 type ExtractMetadata<T extends [...any[]]> = T extends [infer F, ...infer R] ? F & ExtractMetadata<R> : {};
 type GuessMetadataFromRules<T extends any[], TMeta = ExtractMetadata<ExtractMetaDataFromRules<T>>> = TMeta extends EmptyObject ? boolean : TMeta;
 type FilterTuple<T extends any[]> = T extends [infer F, ...infer R] ? [F] extends [[]] ? [...FilterTuple<R>] : [F, ...FilterTuple<R>] : [];
@@ -391,7 +399,7 @@ type UnwrapTuples<T extends any[]> = FilterTuple<T> extends [infer U extends any
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/rules-operators#and Documentation}
  */
-declare function and<const TRules extends [FormRuleDeclaration<any, any>, ...FormRuleDeclaration<any, any>[]]>(...rules: [...TRules]): RegleRuleDefinition<ExtractValueFromRules<TRules>[number], UnwrapTuples<ExtractParamsFromRules<TRules>>, GuessAsyncFromRules<TRules>, GuessMetadataFromRules<TRules>>;
+declare function and<const TRules extends [FormRuleDeclaration<any, any>, ...FormRuleDeclaration<any, any>[]]>(...rules: [...TRules]): RegleRuleDefinition<'and', ExtractValueFromRules<TRules>[number], UnwrapTuples<ExtractParamsFromRules<TRules>>, GuessAsyncFromRules<TRules>, GuessMetadataFromRules<TRules>, ExtractValueFromRules<TRules>[number], ExtractValueFromRules<TRules>[number], GuessNoEmptyFromRules<TRules>>;
 /**
  * The `or` operator validates successfully if **at least one** of the provided rules is valid.
  *
@@ -419,7 +427,35 @@ declare function and<const TRules extends [FormRuleDeclaration<any, any>, ...For
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/rules-operators#or Documentation}
  */
-declare function or<TRules extends [FormRuleDeclaration<any, any>, ...FormRuleDeclaration<any, any>[]]>(...rules: [...TRules]): RegleRuleDefinition<ExtractValueFromRules<TRules>[number], UnwrapTuples<ExtractParamsFromRules<TRules>>, GuessAsyncFromRules<TRules>, GuessMetadataFromRules<TRules>>;
+declare function or<TRules extends [FormRuleDeclaration<any, any>, ...FormRuleDeclaration<any, any>[]]>(...rules: [...TRules]): RegleRuleDefinition<'or', ExtractValueFromRules<TRules>[number], UnwrapTuples<ExtractParamsFromRules<TRules>>, GuessAsyncFromRules<TRules>, GuessMetadataFromRules<TRules>>;
+/**
+ * The `xor` operator validates successfully if **exactly one** of the provided rules is valid (exclusive or).
+ *
+ * @param rules - Two or more rules to combine
+ * @returns A combined rule that passes when exactly one of the provided rules passes
+ *
+ * @example
+ * ```ts
+ * import { useRegle } from '@regle/core';
+ * import { xor, contains, withMessage } from '@regle/rules';
+ *
+ * const { r$ } = useRegle(
+ *   { code: '' },
+ *   {
+ *     code: {
+ *       myError: withMessage(
+ *         xor(contains('A'), contains('B')),
+ *         ({ $params: [charA, charB] }) =>
+ *           `Field should contain either "${charA}" or "${charB}", but not both`
+ *       ),
+ *     },
+ *   }
+ * );
+ * ```
+ *
+ * @see {@link https://reglejs.dev/core-concepts/rules/rules-operators#xor Documentation}
+ */
+declare function xor<TRules extends [FormRuleDeclaration<any, any>, ...FormRuleDeclaration<any, any>[]]>(...rules: [...TRules]): RegleRuleDefinition<'xor', ExtractValueFromRules<TRules>[number], UnwrapTuples<ExtractParamsFromRules<TRules>>, GuessAsyncFromRules<TRules>, GuessMetadataFromRules<TRules>>;
 /**
  * The `not` operator passes when the provided rule **fails** and fails when the rule **passes**.
  * It can be combined with other rules.
@@ -449,7 +485,7 @@ declare function or<TRules extends [FormRuleDeclaration<any, any>, ...FormRuleDe
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/rules-operators#not Documentation}
  */
-declare function not<TValue$1, TParams$1 extends any[] = [], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: RegleRuleDefinition<TValue$1, TParams$1, TAsync$1, TMetadata$1> | InlineRuleDeclaration<TValue$1, TParams$1, TReturn>, message?: RegleRuleDefinitionWithMetadataProcessor<TValue$1, RegleRuleMetadataConsumer<TValue$1, TParams$1, TMetadata$1>, string | string[]>): RegleRuleDefinition<TValue$1, TParams$1, TAsync$1, TMetadata$1>;
+declare function not<TType$1 extends string | unknown = unknown, TValue$1 = unknown, TParams$1 extends any[] = [], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: RegleRuleDefinition<TType$1, TValue$1, TParams$1, TAsync$1, TMetadata$1> | InlineRuleDeclaration<TValue$1, TParams$1, TReturn>, message?: RegleRuleDefinitionWithMetadataProcessor<TValue$1, RegleRuleMetadataConsumer<TValue$1, TParams$1, TMetadata$1>, string | string[]>): RegleRuleDefinition<IsUnknown<TType$1> extends true ? 'not' : `not:${TType$1 & string}`, TValue$1, TParams$1, TAsync$1, TMetadata$1>;
 /**
  * The `assignIf` is a shorthand for conditional destructuring assignment.
  * It allows applying **multiple rules** to a field conditionally.
@@ -473,6 +509,37 @@ declare function not<TValue$1, TParams$1 extends any[] = [], TReturn extends Reg
  * @see {@link https://reglejs.dev/core-concepts/rules/rules-operators#assignif Documentation}
  */
 declare function assignIf<TValue$1 extends unknown = any, TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>, TRulesDelc extends RegleRuleDecl<TValue$1, TCustomRules> = RegleRuleDecl<TValue$1, TCustomRules>>(_condition: MaybeRefOrGetter<Maybe<boolean>>, rules: MaybeRefOrGetter<TRulesDelc>, otherwiseRules?: MaybeRefOrGetter<TRulesDelc>): ComputedRef<TRulesDelc>;
+type PipeTupleToObject<TArray extends unknown[]> = { [Key in keyof TArray as TArray[Key] extends RegleRuleDefinition<infer TType extends string, any, any> ? `${TType & string}` : `anonymous${Key & (`${number}` | (IsTuple<TArray> extends true ? never : number))}`]: TArray[Key] };
+interface PipeOptions {
+  debounce?: number;
+}
+/**
+ * The `pipe` operator chains multiple rules together, where each rule only runs
+ * if all previous rules have passed. This is useful for sequential validation
+ * where later rules depend on earlier ones passing.
+ *
+ * @param rules - Two or more rules to chain together
+ * @returns An object of rules that execute sequentially
+ *
+ * @example
+ * ```ts
+ * import { useRegle } from '@regle/core';
+ * import { pipe, required, minLength, email } from '@regle/rules';
+ *
+ * const { r$ } = useRegle(
+ *   { email: '' },
+ *   {
+ *     email: pipe(required, minLength(5), email),
+ *   }
+ * );
+ * // minLength only runs if required passes
+ * // email only runs if both required and minLength pass
+ * ```
+ *
+ * @see {@link https://reglejs.dev/core-concepts/rules/rules-operators#pipe Documentation}
+ */
+declare function pipe<const TRulesDelc extends [FormRuleDeclaration<any>, ...FormRuleDeclaration<any>[]]>(...rules: TRulesDelc): Prettify<PipeTupleToObject<TRulesDelc>>;
+declare function pipe<const TRulesDelc extends [FormRuleDeclaration<any>, ...FormRuleDeclaration<any>[]]>(rules: TRulesDelc, options?: PipeOptions): Prettify<PipeTupleToObject<TRulesDelc>>;
 /**
  * Allows only alphabetic characters.
  *
@@ -494,7 +561,7 @@ declare function assignIf<TValue$1 extends unknown = any, TCustomRules extends P
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#alpha Documentation}
  */
-declare const alpha: RegleRuleWithParamsDefinition<string, [options?: CommonAlphaOptions | undefined], false, boolean, MaybeInput<string>, string>;
+declare const alpha: RegleRuleWithParamsDefinition<'alpha', string, [options?: CommonAlphaOptions | undefined], false, boolean, MaybeInput<string>, string>;
 /**
  * Allows only alphanumeric characters.
  *
@@ -516,7 +583,31 @@ declare const alpha: RegleRuleWithParamsDefinition<string, [options?: CommonAlph
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#alphanum Documentation}
  */
-declare const alphaNum: RegleRuleWithParamsDefinition<string | number, [options?: CommonAlphaOptions | undefined], false, boolean, MaybeInput<string>>;
+declare const alphaNum: RegleRuleWithParamsDefinition<'alphaNum', string | number, [options?: CommonAlphaOptions | undefined], false, boolean, MaybeInput<string>>;
+interface AtLeastOneFn extends RegleRuleWithParamsDefinition<'atLeastOne', Record<string, unknown> | object, [keys?: string[] | undefined], false, boolean, false, Record<string, unknown> | object> {
+  <T extends Maybe<Record<string, unknown> | object> = Record<string, unknown>>(keys?: MaybeRefOrGetter<(keyof NoInfer<T> & string)[]>): RegleRuleDefinition<'atLeastOne', T, [keys?: (keyof NoInfer<T> & string)[] | undefined], false, boolean, false, T>;
+}
+/**
+ * Checks if at least one key is filled in the object.
+ *
+ * @example
+ * ```ts
+ * import { atLeastOne } from '@regle/rules';
+ *
+ * const { r$ } = useRegle({ user: { firstName: '', lastName: '' } }, {
+ *   user: {
+ *    atLeastOne,
+ *    // or
+ *    atLeastOne: atLeastOne(['firstName', 'lastName'])
+ *    // or
+ *    atLeastOne: atLeastOne<{ firstName: string; lastName: string }>(['firstName', 'lastName'])
+ *   },
+ * });
+ * ```
+ *
+ * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#atleastone Documentation}
+ */
+declare const atLeastOne: AtLeastOneFn;
 /**
  * Checks if a number is in specified bounds. `min` and `max` are both inclusive by default.
  *
@@ -544,7 +635,7 @@ declare const alphaNum: RegleRuleWithParamsDefinition<string | number, [options?
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#between Documentation}
  */
-declare const between: RegleRuleWithParamsDefinition<number, [min: number, max: number, options?: CommonComparisonOptions], false, boolean, MaybeInput<number>>;
+declare const between: RegleRuleWithParamsDefinition<'between', number, [min: number, max: number, options?: CommonComparisonOptions], false, boolean, MaybeInput<number>>;
 /**
  * Requires a value to be a native boolean type.
  *
@@ -564,7 +655,7 @@ declare const between: RegleRuleWithParamsDefinition<number, [min: number, max:
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#boolean Documentation}
  */
-declare const boolean: RegleRuleDefinition<unknown, [], false, boolean, MaybeInput<boolean>, unknown>;
+declare const boolean: RegleRuleDefinition<'boolean', unknown, [], false, boolean, MaybeInput<boolean>, unknown>;
 /**
  * Requires a boolean value to be `true`. This is useful for checkbox inputs like "accept terms".
  *
@@ -579,7 +670,7 @@ declare const boolean: RegleRuleDefinition<unknown, [], false, boolean, MaybeInp
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#checked Documentation}
  */
-declare const checked: RegleRuleDefinition<boolean, [], false, boolean, MaybeInput<boolean>>;
+declare const checked: RegleRuleDefinition<'checked', boolean, [], false, boolean, MaybeInput<boolean>, boolean, true>;
 /**
  * Checks if the string contains the specified substring.
  *
@@ -598,7 +689,7 @@ declare const checked: RegleRuleDefinition<boolean, [], false, boolean, MaybeInp
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#contains Documentation}
  */
-declare const contains: RegleRuleWithParamsDefinition<string, [part: MaybeInput<string>], false, boolean, MaybeInput<string>>;
+declare const contains: RegleRuleWithParamsDefinition<'contains', string, [part: MaybeInput<string>], false, boolean, MaybeInput<string>>;
 /**
  * Requires a value to be a native `Date` constructor.
  *
@@ -618,7 +709,7 @@ declare const contains: RegleRuleWithParamsDefinition<string, [part: MaybeInput<
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#date Documentation}
  */
-declare const date: RegleRuleDefinition<unknown, [], false, boolean, MaybeInput<Date>, unknown>;
+declare const date: RegleRuleDefinition<'date', unknown, [], false, boolean, MaybeInput<Date>, unknown>;
 /**
  * Checks if the date is after the given parameter.
  *
@@ -641,7 +732,7 @@ declare const date: RegleRuleDefinition<unknown, [], false, boolean, MaybeInput<
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#dateafter Documentation}
  */
-declare const dateAfter: RegleRuleWithParamsDefinition<string | Date, [after: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, true | {
+declare const dateAfter: RegleRuleWithParamsDefinition<'dateAfter', string | Date, [after: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, true | {
   $valid: false;
   error: 'date-not-after';
 } | {
@@ -670,7 +761,7 @@ declare const dateAfter: RegleRuleWithParamsDefinition<string | Date, [after: Ma
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#datebefore Documentation}
  */
-declare const dateBefore: RegleRuleWithParamsDefinition<string | Date, [before: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, true | {
+declare const dateBefore: RegleRuleWithParamsDefinition<'dateBefore', string | Date, [before: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, true | {
   $valid: false;
   error: 'date-not-before';
 } | {
@@ -700,7 +791,7 @@ declare const dateBefore: RegleRuleWithParamsDefinition<string | Date, [before:
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#datebetween Documentation}
  */
-declare const dateBetween: RegleRuleWithParamsDefinition<string | Date, [before: MaybeInput<string | Date>, after: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, boolean, MaybeInput<string | Date>>;
+declare const dateBetween: RegleRuleWithParamsDefinition<'dateBetween', string | Date, [before: MaybeInput<string | Date>, after: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, boolean, MaybeInput<string | Date>>;
 /**
  * Allows positive and negative decimal numbers.
  *
@@ -715,7 +806,7 @@ declare const dateBetween: RegleRuleWithParamsDefinition<string | Date, [before:
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#decimal Documentation}
  */
-declare const decimal: RegleRuleDefinition<string | number, [], false, boolean, MaybeInput<number | undefined>>;
+declare const decimal: RegleRuleDefinition<'decimal', string | number, [], false, boolean, MaybeInput<number | undefined>>;
 /**
  * Validates email addresses. Always verify on the server to ensure the address is real and not already in use.
  *
@@ -730,7 +821,7 @@ declare const decimal: RegleRuleDefinition<string | number, [], false, boolean,
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#email Documentation}
  */
-declare const email: RegleRuleDefinition<string, [], false, boolean, MaybeInput<string>>;
+declare const email: RegleRuleDefinition<'email', string, [], false, boolean, MaybeInput<string>>;
 /**
  * Validates if the value is a valid emoji.
  *
@@ -745,7 +836,7 @@ declare const email: RegleRuleDefinition<string, [], false, boolean, MaybeInput<
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#emoji Documentation}
  */
-declare const emoji: RegleRuleDefinition<string, [], false, boolean, unknown, string>;
+declare const emoji: RegleRuleDefinition<'emoji', string, [], false, boolean, unknown, string>;
 /**
  * Checks if the string ends with the specified substring.
  *
@@ -762,7 +853,7 @@ declare const emoji: RegleRuleDefinition<string, [], false, boolean, unknown, st
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#endswith Documentation}
  */
-declare const endsWith: RegleRuleWithParamsDefinition<string, [part: MaybeInput<string>], false, boolean, MaybeInput<string>>;
+declare const endsWith: RegleRuleWithParamsDefinition<'endsWith', string, [part: MaybeInput<string>], false, boolean, MaybeInput<string>>;
 /**
  * Requires the input value to have a strict specified length. Works with arrays, objects and strings.
  *
@@ -787,7 +878,7 @@ declare const endsWith: RegleRuleWithParamsDefinition<string, [part: MaybeInput<
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#exactdigits Documentation}
  */
-declare const exactDigits: RegleRuleWithParamsDefinition<string | number, [count: number], false, boolean>;
+declare const exactDigits: RegleRuleWithParamsDefinition<'exactDigits', string | number, [count: number], false, boolean>;
 /**
  * Requires the input value to have a strict specified length. Works with arrays, objects and strings.
  *
@@ -812,7 +903,7 @@ declare const exactDigits: RegleRuleWithParamsDefinition<string | number, [count
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#exactlength Documentation}
  */
-declare const exactLength: RegleRuleWithParamsDefinition<string | any[] | Record<PropertyKey, any>, [count: number], false, boolean>;
+declare const exactLength: RegleRuleWithParamsDefinition<'exactLength', string | any[] | Record<PropertyKey, any>, [count: number], false, boolean>;
 /**
  * Requires a field to have a strict numeric value.
  *
@@ -837,7 +928,7 @@ declare const exactLength: RegleRuleWithParamsDefinition<string | any[] | Record
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#exactvalue Documentation}
  */
-declare const exactValue: RegleRuleWithParamsDefinition<number, [count: number], false, boolean, MaybeInput<number>>;
+declare const exactValue: RegleRuleWithParamsDefinition<'exactValue', number, [count: number], false, boolean, MaybeInput<number>>;
 /**
  * Requires a value to be a native `File` constructor.
  *
@@ -857,7 +948,7 @@ declare const exactValue: RegleRuleWithParamsDefinition<number, [count: number],
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#file Documentation}
  */
-declare const file: RegleRuleDefinition<unknown, [], false, boolean, MaybeInput<File>, unknown>;
+declare const file: RegleRuleDefinition<'file', unknown, [], false, boolean, MaybeInput<File>, unknown>;
 /**
  * Requires a value to be a file with a specific type.
  *
@@ -876,7 +967,7 @@ declare const file: RegleRuleDefinition<unknown, [], false, boolean, MaybeInput<
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#filetype Documentation}
  */
-declare const fileType: RegleRuleWithParamsDefinition<File, [accept: readonly string[]], false, boolean, unknown, File>;
+declare const fileType: RegleRuleWithParamsDefinition<'fileType', File, [accept: readonly string[]], false, boolean, unknown, File>;
 /**
  * Validates hexadecimal values.
  *
@@ -891,7 +982,7 @@ declare const fileType: RegleRuleWithParamsDefinition<File, [accept: readonly st
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#hexadecimal Documentation}
  */
-declare const hexadecimal: RegleRuleDefinition<string, [], false, boolean, MaybeInput<string>>;
+declare const hexadecimal: RegleRuleDefinition<'hexadecimal', string, [], false, boolean, MaybeInput<string>>;
 /**
  * Validates hostnames.
  *
@@ -906,7 +997,7 @@ declare const hexadecimal: RegleRuleDefinition<string, [], false, boolean, Maybe
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#hostname Documentation}
  */
-declare const hostname: RegleRuleDefinition<string, [], false, boolean, unknown, string>;
+declare const hostname: RegleRuleDefinition<'hostname', string, [], false, boolean, unknown, string>;
 interface UrlOptions {
   protocol?: RegExp;
 }
@@ -929,7 +1020,7 @@ interface UrlOptions {
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#url Documentation}
  */
-declare const url: RegleRuleWithParamsDefinition<string, [options?: UrlOptions | undefined], false, boolean, unknown, string>;
+declare const url: RegleRuleWithParamsDefinition<'url', string, [options?: UrlOptions | undefined], false, boolean, unknown, string>;
 /**
  * Validates HTTP URLs.
  *
@@ -949,7 +1040,7 @@ declare const url: RegleRuleWithParamsDefinition<string, [options?: UrlOptions |
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#httpurl Documentation}
  */
-declare const httpUrl: RegleRuleWithParamsDefinition<string, [options?: UrlOptions | undefined], false, boolean, unknown, string>;
+declare const httpUrl: RegleRuleWithParamsDefinition<'httpUrl', string, [options?: UrlOptions | undefined], false, boolean, unknown, string>;
 /**
  * Allows only integers (positive and negative).
  *
@@ -964,7 +1055,7 @@ declare const httpUrl: RegleRuleWithParamsDefinition<string, [options?: UrlOptio
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#integer Documentation}
  */
-declare const integer: RegleRuleDefinition<string | number, [], false, boolean, MaybeInput<number>>;
+declare const integer: RegleRuleDefinition<'integer', string | number, [], false, boolean, MaybeInput<number>>;
 /**
  * Validates IPv4 addresses in dotted decimal notation (e.g., `127.0.0.1`).
  *
@@ -979,7 +1070,7 @@ declare const integer: RegleRuleDefinition<string | number, [], false, boolean,
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#ipv4address Documentation}
  */
-declare const ipv4Address: RegleRuleDefinition<string, [], false, boolean, MaybeInput<string>>;
+declare const ipv4Address: RegleRuleDefinition<'ipv4Address', string, [], false, boolean, MaybeInput<string>>;
 /**
  * Allow only one possible literal value.
  *
@@ -996,7 +1087,7 @@ declare const ipv4Address: RegleRuleDefinition<string, [], false, boolean, Maybe
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#literal Documentation}
  */
-declare function literal<const TValue$1 extends string | number>(literal: MaybeRefOrGetter<TValue$1>): RegleRuleDefinition<TValue$1, [literal: TValue$1], false, boolean, MaybeInput<TValue$1>, string | number>;
+declare function literal<const TValue$1 extends string | number>(literal: MaybeRefOrGetter<TValue$1>): RegleRuleDefinition<'literal', TValue$1, [literal: TValue$1], false, boolean, MaybeInput<TValue$1>, string | number, true>;
 /**
  * Validates lowercase strings.
  *
@@ -1011,7 +1102,7 @@ declare function literal<const TValue$1 extends string | number>(literal: MaybeR
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#lowercase Documentation}
  */
-declare const lowercase: RegleRuleDefinition<string, [], false, boolean, unknown, string>;
+declare const lowercase: RegleRuleDefinition<'lowercase', string, [], false, boolean, unknown, string>;
 /**
  * Validates MAC addresses. Call as a function to specify a custom separator (e.g., `':'` or an empty string for `00ff1122334455`).
  *
@@ -1032,7 +1123,7 @@ declare const lowercase: RegleRuleDefinition<string, [], false, boolean, unknown
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#macaddress Documentation}
  */
-declare const macAddress: RegleRuleWithParamsDefinition<string, [separator?: string | undefined], false, boolean, MaybeInput<string>>;
+declare const macAddress: RegleRuleWithParamsDefinition<'macAddress', string, [separator?: string | undefined], false, boolean, MaybeInput<string>>;
 /**
  * Requires a value to be a file with a maximum size.
  *
@@ -1051,7 +1142,7 @@ declare const macAddress: RegleRuleWithParamsDefinition<string, [separator?: str
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#maxfilesize Documentation}
  */
-declare const maxFileSize: RegleRuleWithParamsDefinition<File, [maxSize: number], false, true | {
+declare const maxFileSize: RegleRuleWithParamsDefinition<'maxFileSize', File, [maxSize: number], false, true | {
   $valid: boolean;
   fileSize: number;
 }, unknown, File>;
@@ -1081,7 +1172,7 @@ declare const maxFileSize: RegleRuleWithParamsDefinition<File, [maxSize: number]
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#maxlength Documentation}
  */
-declare const maxLength: RegleRuleWithParamsDefinition<string | any[] | Record<PropertyKey, any>, [max: number, options?: CommonComparisonOptions], false, boolean>;
+declare const maxLength: RegleRuleWithParamsDefinition<'maxLength', string | any[] | Record<PropertyKey, any>, [max: number, options?: CommonComparisonOptions], false, boolean>;
 /**
  * Requires a field to have a specified maximum numeric value.
  *
@@ -1108,7 +1199,7 @@ declare const maxLength: RegleRuleWithParamsDefinition<string | any[] | Record<P
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#maxvalue Documentation}
  */
-declare const maxValue: RegleRuleWithParamsDefinition<number | string, [max: number | string, options?: CommonComparisonOptions], false, boolean, MaybeInput<number | string>>;
+declare const maxValue: RegleRuleWithParamsDefinition<'maxValue', number | string, [max: number | string, options?: CommonComparisonOptions], false, boolean, MaybeInput<number | string>>;
 /**
  * Requires a value to be a file with a minimum size.
  *
@@ -1127,7 +1218,7 @@ declare const maxValue: RegleRuleWithParamsDefinition<number | string, [max: num
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#minfilesize Documentation}
  */
-declare const minFileSize: RegleRuleWithParamsDefinition<File, [minSize: number], false, true | {
+declare const minFileSize: RegleRuleWithParamsDefinition<'minFileSize', File, [minSize: number], false, true | {
   $valid: boolean;
   fileSize: number;
 }, unknown, File>;
@@ -1157,7 +1248,7 @@ declare const minFileSize: RegleRuleWithParamsDefinition<File, [minSize: number]
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#minlength Documentation}
  */
-declare const minLength: RegleRuleWithParamsDefinition<string | any[] | Record<PropertyKey, any>, [min: number, options?: CommonComparisonOptions], false, boolean>;
+declare const minLength: RegleRuleWithParamsDefinition<'minLength', string | any[] | Record<PropertyKey, any>, [min: number, options?: CommonComparisonOptions], false, boolean>;
 /**
  * Requires a field to have a specified minimum numeric value.
  *
@@ -1184,7 +1275,7 @@ declare const minLength: RegleRuleWithParamsDefinition<string | any[] | Record<P
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#minvalue Documentation}
  */
-declare const minValue: RegleRuleWithParamsDefinition<number | string, [min: number | string, options?: CommonComparisonOptions], false, boolean, MaybeInput<number | string>>;
+declare const minValue: RegleRuleWithParamsDefinition<'minValue', number | string, [min: number | string, options?: CommonComparisonOptions], false, boolean, MaybeInput<number | string>>;
 type EnumLike = {
   [k: string]: string | number;
   [nu: number]: string;
@@ -1209,7 +1300,7 @@ type EnumLike = {
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#nativeenum Documentation}
  */
-declare function nativeEnum<T extends EnumLike>(enumLike: T): RegleRuleDefinition<MaybeInput<T[keyof T]>, [enumLike: T], false, boolean, MaybeInput<T[keyof T]>, string | number>;
+declare function nativeEnum<T extends EnumLike>(enumLike: T): RegleRuleDefinition<'nativeEnum', MaybeInput<T[keyof T]>, [enumLike: T], false, boolean, MaybeInput<T[keyof T]>, string | number>;
 /**
  * Requires a value to be a native number type.
  *
@@ -1229,7 +1320,7 @@ declare function nativeEnum<T extends EnumLike>(enumLike: T): RegleRuleDefinitio
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#number Documentation}
  */
-declare const number: RegleRuleDefinition<unknown, [], false, boolean, MaybeInput<number>, unknown>;
+declare const number: RegleRuleDefinition<'number', unknown, [], false, boolean, MaybeInput<number>, unknown>;
 /**
  * Allows only numeric values (including numeric strings).
  *
@@ -1244,11 +1335,11 @@ declare const number: RegleRuleDefinition<unknown, [], false, boolean, MaybeInpu
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#numeric Documentation}
  */
-declare const numeric: RegleRuleDefinition<string | number, [], false, boolean, MaybeInput<string | number>>;
+declare const numeric: RegleRuleDefinition<'numeric', string | number, [], false, boolean, MaybeInput<string | number>>;
 interface OneOfFn {
-  <const TValues extends NonEmptyTuple<string | number> | NonEmptyTuple<string> | NonEmptyTuple<number>>(options: MaybeReadonly<MaybeRefOrGetter<[...TValues]>>): RegleRuleDefinition<TValues[number], [options: TValues], false, boolean, MaybeInput<TValues[number]>, string | number>;
+  <const TValues extends NonEmptyTuple<string | number> | NonEmptyTuple<string> | NonEmptyTuple<number>>(options: MaybeReadonly<MaybeRefOrGetter<[...TValues]>>): RegleRuleDefinition<'oneOf', TValues[number], [options: TValues], false, boolean, MaybeInput<TValues[number]>, string | number>;
   /** Keep this definition without generics for inference */
-  (options: MaybeReadonly<MaybeRefOrGetter<[...[string | number, ...(string | number)[]]]>>): RegleRuleDefinition<string | number, [options: readonly [string | number, ...(string | number)[]]], false, boolean, MaybeInput<string | number>, string | number>;
+  (options: MaybeReadonly<MaybeRefOrGetter<[...[string | number, ...(string | number)[]]]>>): RegleRuleDefinition<'oneOf', string | number, [options: readonly [string | number, ...(string | number)[]]], false, boolean, MaybeInput<string | number>, string | number>;
 }
 /**
  * Allow only one of the values from a fixed Array of possible entries.
@@ -1289,7 +1380,7 @@ declare const oneOf: OneOfFn;
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#regex Documentation}
  */
-declare const regex: RegleRuleWithParamsDefinition<string | number, [regexp: RegExp | RegExp[]], false, boolean, MaybeInput<string | number>>;
+declare const regex: RegleRuleWithParamsDefinition<'regex', string | number, [regexp: RegExp | RegExp[]], false, boolean, MaybeInput<string | number>>;
 /**
  * Requires non-empty data. Checks for empty arrays and strings containing only whitespaces.
  *
@@ -1304,7 +1395,7 @@ declare const regex: RegleRuleWithParamsDefinition<string | number, [regexp: Reg
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#required Documentation}
  */
-declare const required: RegleRuleDefinition<unknown, [], false, boolean, unknown>;
+declare const required: RegleRuleDefinition<'required', unknown, [], false, boolean, unknown, unknown, true>;
 /**
  * Requires non-empty data, only if provided data property, ref, or a function resolves to `true`.
  *
@@ -1328,7 +1419,7 @@ declare const required: RegleRuleDefinition<unknown, [], false, boolean, unknown
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#requiredif Documentation}
  */
-declare const requiredIf: RegleRuleWithParamsDefinition<unknown, [condition: boolean], false, boolean>;
+declare const requiredIf: RegleRuleWithParamsDefinition<'required', unknown, [condition: boolean], false, boolean>;
 /**
  * Requires non-empty data, only if provided data property, ref, or a function resolves to `false`.
  *
@@ -1352,11 +1443,11 @@ declare const requiredIf: RegleRuleWithParamsDefinition<unknown, [condition: boo
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#requiredunless Documentation}
  */
-declare const requiredUnless: RegleRuleWithParamsDefinition<unknown, [condition: boolean], false, boolean>;
+declare const requiredUnless: RegleRuleWithParamsDefinition<'required', unknown, [condition: boolean], false, boolean>;
 interface SameAsFn {
-  <TTarget extends unknown = unknown>(target: MaybeRefOrGetter<TTarget>, otherName?: MaybeRefOrGetter<string>): RegleRuleDefinition<TTarget, [target: TTarget, otherName?: string], false, boolean, TTarget extends MaybeInput<infer M> ? M : MaybeInput<TTarget>>;
+  <TTarget extends unknown = unknown>(target: MaybeRefOrGetter<TTarget>, otherName?: MaybeRefOrGetter<string>): RegleRuleDefinition<'sameAs', TTarget, [target: TTarget, otherName?: string], false, boolean, TTarget extends MaybeInput<infer M> ? M : MaybeInput<TTarget>>;
   /** Keep this definition without generics for inference */
-  (target: MaybeRefOrGetter<unknown>, otherName?: MaybeRefOrGetter<string>): RegleRuleDefinition<unknown, [target: any, otherName?: string], false, boolean, unknown extends MaybeInput<infer M> ? M : MaybeInput<unknown>>;
+  (target: MaybeRefOrGetter<unknown>, otherName?: MaybeRefOrGetter<string>): RegleRuleDefinition<'sameAs', unknown, [target: any, otherName?: string], false, boolean, unknown extends MaybeInput<infer M> ? M : MaybeInput<unknown>>;
 }
 /**
  * Checks if the value matches the specified property or ref. Useful for password confirmation fields.
@@ -1401,7 +1492,7 @@ declare const sameAs: SameAsFn;
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#startswith Documentation}
  */
-declare const startsWith: RegleRuleWithParamsDefinition<string, [part: MaybeInput<string>], false, boolean, MaybeInput<string>>;
+declare const startsWith: RegleRuleWithParamsDefinition<'startsWith', string, [part: MaybeInput<string>], false, boolean, MaybeInput<string>>;
 /**
  * Requires a value to be a native string type.
  *
@@ -1421,7 +1512,7 @@ declare const startsWith: RegleRuleWithParamsDefinition<string, [part: MaybeInpu
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#string Documentation}
  */
-declare const string: RegleRuleDefinition<unknown, [], false, boolean, MaybeInput<string>, unknown>;
+declare const string: RegleRuleDefinition<'string', unknown, [], false, boolean, MaybeInput<string>, unknown>;
 /**
  * Define the input type of a rule. No runtime validation.
  *
@@ -1442,7 +1533,7 @@ declare const string: RegleRuleDefinition<unknown, [], false, boolean, MaybeInpu
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#type Documentation}
  */
-declare function type$1<T>(): RegleRuleDefinition<unknown, [], false, boolean, MaybeInput<T>>;
+declare function type<T>(): RegleRuleDefinition<'type', unknown, [], false, boolean, MaybeInput<T>>;
 /**
  * Validates uppercase strings.
  *
@@ -1457,5 +1548,5 @@ declare function type$1<T>(): RegleRuleDefinition<unknown, [], false, boolean, M
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/built-in-rules#uppercase Documentation}
  */
-declare const uppercase: RegleRuleDefinition<string, [], false, boolean, unknown, string>;
-export { EnumLike, UrlOptions, alpha, alphaNum, and, applyIf, assignIf, between, boolean, checked, contains, date, dateAfter, dateBefore, dateBetween, decimal, email, emoji, endsWith, exactDigits, exactLength, exactValue, file, fileType, getSize, hexadecimal, hostname, httpUrl, integer, ipv4Address, isDate, isEmpty, isFilled, isNumber, literal, lowercase, macAddress, matchRegex, maxFileSize, maxLength, maxValue, minFileSize, minLength, minValue, nativeEnum, not, number, numeric, oneOf, or, regex, required, requiredIf, requiredUnless, sameAs, startsWith, string, toDate, toNumber, type$1 as type, uppercase, url, withAsync, withMessage, withParams, withTooltip };
+declare const uppercase: RegleRuleDefinition<'uppercase', string, [], false, boolean, unknown, string>;
+export { EnumLike, UrlOptions, alpha, alphaNum, and, applyIf, assignIf, atLeastOne, between, boolean, checked, contains, date, dateAfter, dateBefore, dateBetween, decimal, email, emoji, endsWith, exactDigits, exactLength, exactValue, file, fileType, getSize, hexadecimal, hostname, httpUrl, integer, ipv4Address, isDate, isEmpty, isFilled, isNumber, literal, lowercase, macAddress, matchRegex, maxFileSize, maxLength, maxValue, minFileSize, minLength, minValue, nativeEnum, not, number, numeric, oneOf, or, pipe, regex, required, requiredIf, requiredUnless, sameAs, startsWith, string, toDate, toNumber, type, uppercase, url, withAsync, withMessage, withParams, withTooltip, xor };