@regle/core 1.18.0-beta.3 → 1.18.0

package/dist/regle-core.d.ts

@@ -1,11 +1,11 @@
 /**
- * @regle/core v1.18.0-beta.3
+ * @regle/core v1.18.0
  * (c) 2026 Victor Garcia
  * @license MIT
  */
 
 import { ComputedRef, MaybeRef, MaybeRefOrGetter, Plugin, Raw, Ref, UnwrapNestedRefs, UnwrapRef } from "vue";
-import { EmptyObject, IsAny, IsEmptyObject, IsUnion, IsUnknown, Merge, Or, RequireAtLeastOne, RequireOneOrNone, RequiredDeep, UnionToIntersection, UnionToTuple } from "type-fest";
+import { EmptyObject, Get, IsAny, IsEmptyObject, IsNullable, IsOptional, IsStringLiteral, IsUnion, IsUnknown, Merge, Or, Paths, RequireAtLeastOne, RequireOneOrNone, RequiredDeep, UnionToIntersection, UnionToTuple } from "type-fest";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 declare const RegleStaticSymbol: unique symbol;
 type RegleStatic<T> = T extends (new (...args: infer Args) => infer U) ? RegleStaticImpl<new (...args: Args) => RegleStaticImpl<U>> : RegleStaticImpl<T>;
@@ -15,13 +15,13 @@ type RegleStaticImpl<T> = Raw<T & {
 type IsRegleStatic<T> = T extends RegleStaticImpl<T> ? true : false;
 type UnwrapStatic<T> = IsUnknown<T> extends true ? any : NonNullable<T> extends RegleStaticImpl<infer U> ? Raw<U> : UnwrapStaticSimple<T>;
 type UnwrapStaticSimple<T> = NonNullable<T> extends Array<infer U> ? Array<UnwrapStatic<U>> : isRecordLiteral<NonNullable<T>> extends true ? { [K in keyof T]: UnwrapStatic<T[K]> } : T;
-interface GlobalConfigOverrides<TValue$1 extends unknown = unknown> {
+interface GlobalConfigOverrides<TValue extends unknown = unknown> {
   /**
    * Override the default $edited handler.
    */
-  isEdited?: isEditedHandlerFn<TValue$1>;
+  isEdited?: isEditedHandlerFn<TValue>;
 }
-type isEditedHandlerFn<TValue$1 extends unknown = unknown> = (currentValue: MaybeInput<TValue$1>, initialValue: MaybeInput<TValue$1>, defaultHandlerFn: (currentValue: unknown, initialValue: unknown) => boolean) => boolean;
+type isEditedHandlerFn<TValue extends unknown = unknown> = (currentValue: MaybeInput<TValue>, initialValue: MaybeInput<TValue>, defaultHandlerFn: (currentValue: unknown, initialValue: unknown) => boolean) => boolean;
 interface RegleBehaviourOptions {
   /**
    * Does not run rules until the field is dirty.
@@ -62,7 +62,7 @@ interface RegleBehaviourOptions {
    */
   immediateDirty?: boolean | undefined;
 }
-interface LocalRegleBehaviourOptions<TState$1 extends Record<string, any>, TRules$1 extends ReglePartialRuleTree<TState$1>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = {}> {
+interface LocalRegleBehaviourOptions<TState extends Record<string, any>, TRules extends ReglePartialRuleTree<TState>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = {}> {
   /**
    * A dictionary of external errors to be injected into the field statuses.
    *
@@ -71,7 +71,7 @@ interface LocalRegleBehaviourOptions<TState$1 extends Record<string, any>, TRule
    *
    * More details: https://reglejs.dev/advanced-usage/external-errors
    */
-  externalErrors?: Ref<RegleExternalErrorTree<Unwrap<TState$1>> | Record<string, string[]>>;
+  externalErrors?: Ref<RegleExternalErrorTree<Unwrap<TState>> | Record<string, string[]>>;
   /**
    * Allows you to group fields for custom collective validation logic.
    *
@@ -83,7 +83,7 @@ interface LocalRegleBehaviourOptions<TState$1 extends Record<string, any>, TRule
    *
    * More details: https://reglejs.dev/core-concepts/modifiers#validationgroups
    */
-  validationGroups?: (fields: RegleStatus<TState$1, TRules$1>['$fields']) => TValidationGroups;
+  validationGroups?: (fields: RegleStatus<TState, TRules>['$fields']) => TValidationGroups;
   /**
    * A unique identifier for the Regle instance in the devtools.
    * @default undefined
@@ -107,7 +107,7 @@ interface RegleValidationGroupOutput {
   /** Collection of all error messages from fields in the group, regardless of $dirty state. */
   $silentErrors: string[];
 }
-type FieldRegleBehaviourOptions<TValue$1 extends unknown = unknown> = AddDollarToOptions<RegleBehaviourOptions> & {
+type FieldRegleBehaviourOptions<TValue extends unknown = unknown> = AddDollarToOptions<RegleBehaviourOptions> & {
   /**
    * Let you declare the number of milliseconds the rule needs to wait before executing. Useful for async or heavy computations.
    */
@@ -115,9 +115,9 @@ type FieldRegleBehaviourOptions<TValue$1 extends unknown = unknown> = AddDollarT
   /**
    * Override the default `$edited` handler.
    */
-  $isEdited?: isEditedHandlerFn<TValue$1>;
+  $isEdited?: isEditedHandlerFn<TValue>;
 };
-type CollectionRegleBehaviourOptions<TValue$1 extends unknown = unknown> = FieldRegleBehaviourOptions<TValue$1> & {
+type CollectionRegleBehaviourOptions<TValue extends unknown = unknown> = FieldRegleBehaviourOptions<TValue> & {
   /**
    * Allow deep compare of array children to compute the `$edited` property
    *
@@ -156,13 +156,13 @@ type AddDollarToOptions<T extends Record<string, any>> = { [K in keyof T as `$${
  * @template TAdditionalReturnProperties - Additional properties to extend the return type
  *
  */
-type Regle<TState$1 extends Record<string, any> = EmptyObject, TRules$1 extends ReglePartialRuleTree<TState$1, CustomRulesDeclarationTree> = EmptyObject, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = {}, TShortcuts extends RegleShortcutDefinition = {}, TAdditionalReturnProperties extends Record<string, any> = {}> = {
+type Regle<TState extends Record<string, any> = EmptyObject, TRules extends ReglePartialRuleTree<TState, CustomRulesDeclarationTree> = EmptyObject, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = {}, TShortcuts extends RegleShortcutDefinition = {}, TAdditionalReturnProperties extends Record<string, any> = {}> = {
   /**
    * r$ is a reactive object containing the values, errors, dirty state and all the necessary validations properties you'll need to display information.
    *
    * To see the list of properties: {@link https://reglejs.dev/core-concepts/validation-properties}
    */
-  r$: Raw<RegleRoot<TState$1, TRules$1, TValidationGroups, TShortcuts>>;
+  r$: Raw<RegleRoot<TState, TRules, TValidationGroups, TShortcuts>>;
 } & TAdditionalReturnProperties;
 /**
  * The type for a single field validation instance.
@@ -172,17 +172,17 @@ type Regle<TState$1 extends Record<string, any> = EmptyObject, TRules$1 extends
  * @template TShortcuts - Custom shortcut definitions for common validation patterns
  * @template TAdditionalReturnProperties - Additional properties to extend the return type
  */
-type RegleSingleField<TState$1 extends Maybe<PrimitiveTypes> = any, TRules$1 extends RegleRuleDecl<NonNullable<TState$1>> = EmptyObject, TShortcuts extends RegleShortcutDefinition = {}, TAdditionalReturnProperties extends Record<string, any> = {}> = {
+type RegleSingleField<TState extends Maybe<PrimitiveTypes> = any, TRules extends RegleRuleDecl<NonNullable<TState>> = EmptyObject, TShortcuts extends RegleShortcutDefinition = {}, TAdditionalReturnProperties extends Record<string, any> = {}> = {
   /**
    * r$ is a reactive object containing the values, errors, dirty state and all the necessary validations properties you'll need to display information.
    *
    * To see the list of properties: {@link https://reglejs.dev/core-concepts/validation-properties}
    */
-  r$: Raw<RegleFieldStatus<TState$1, TRules$1, TShortcuts>>;
+  r$: Raw<RegleFieldStatus<TState, TRules, TShortcuts>>;
 } & TAdditionalReturnProperties;
 type DeepReactiveState<T extends Record<string, any> | unknown | undefined> = ExtendOnlyRealRecord<T> extends true ? { [K in keyof T]: InferDeepReactiveState<T[K]> } : never;
-type InferDeepReactiveState<TState$1> = NonNullable<TState$1> extends Array<infer U extends Record<string, any>> ? DeepReactiveState<U[]> : NonNullable<TState$1> extends Date | File ? MaybeRef<TState$1> : NonNullable<TState$1> extends Record<string, any> ? DeepReactiveState<TState$1> : MaybeRef<TState$1>;
-type ResetOptions<TState$1 extends unknown> = RequireOneOrNone<{
+type InferDeepReactiveState<TState> = NonNullable<TState> extends Array<infer U extends Record<string, any>> ? DeepReactiveState<U[]> : NonNullable<TState> extends Date | File ? MaybeRef<TState> : NonNullable<TState> extends Record<string, any> ? DeepReactiveState<TState> : MaybeRef<TState>;
+type ResetOptions<TState extends unknown> = RequireOneOrNone<{
   /**
    * Reset validation status and reset form state to its initial state.
    *
@@ -203,7 +203,7 @@ type ResetOptions<TState$1 extends unknown> = RequireOneOrNone<{
    * Reset validation status and reset form state to the given state
    * Also set the new state as the initial state.
    */
-  toState?: TState$1 | (() => TState$1);
+  toState?: TState | (() => TState);
   /**
    * Clears the $externalErrors state back to an empty object.
    *
@@ -222,18 +222,16 @@ type ScopedInstancesRecord = Record<string, Record<string, SuperCompatibleRegleR
   '~~global': Record<string, SuperCompatibleRegleRoot>;
 };
 type ScopedInstancesRecordLike = Partial<ScopedInstancesRecord>;
-type PartialFormState<TState$1 extends Record<string, any>> = [unknown] extends [TState$1] ? {} : Prettify<{ [K in keyof TState$1 as ExtendOnlyRealRecord<TState$1[K]> extends true ? never : TState$1[K] extends Array<any> ? never : K]?: MaybeOutput<TState$1[K]> } & { [K in keyof TState$1 as ExtendOnlyRealRecord<TState$1[K]> extends true ? K : TState$1[K] extends Array<any> ? K : never]: NonNullable<TState$1[K]> extends Array<infer U extends Record<string, any>> ? PartialFormState<U>[] : PartialFormState<TState$1[K]> }>;
-type RegleResult<Data extends Record<string, any> | any[] | unknown, TRules$1 extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = {
-  /** The result of the validation */
-  valid: false;
-  /** Output data, filter the result by checking the `valid` property */
-  data: IsUnknown<Data> extends true ? unknown : IsAny<Data> extends true ? unknown : IsEmptyObject<TRules$1> extends true ? MaybeOutput<Data> : HasNamedKeys<Data> extends true ? NonNullable<Data> extends Date | File ? MaybeOutput<Raw<Data>> : NonNullable<Data> extends Array<infer U extends Record<string, any>> ? PartialFormState<U>[] : NonNullable<Data> extends Record<string, any> ? PartialFormState<NonNullable<Data>> : MaybeOutput<Data> : unknown;
+type PartialFormState<TState extends Record<string, any>> = [unknown] extends [TState] ? {} : Prettify<{ [K in keyof TState as ExtendOnlyRealRecord<TState[K]> extends true ? never : TState[K] extends Array<any> ? never : K]?: MaybeOutput<TState[K]> } & { [K in keyof TState as ExtendOnlyRealRecord<TState[K]> extends true ? K : TState[K] extends Array<any> ? K : never]: NonNullable<TState[K]> extends Array<infer U extends Record<string, any>> ? PartialFormState<U>[] : PartialFormState<TState[K]> }>;
+type RegleResult<Data extends Record<string, any> | any[] | unknown, TRules extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = {
+  /** The result of the validation */valid: false; /** Output data, filter the result by checking the `valid` property */
+  data: IsUnknown<Data> extends true ? unknown : IsAny<Data> extends true ? unknown : IsEmptyObject<TRules> extends true ? MaybeOutput<Data> : HasNamedKeys<Data> extends true ? NonNullable<Data> extends Date | File ? MaybeOutput<Raw<Data>> : NonNullable<Data> extends Array<infer U extends Record<string, any>> ? PartialFormState<U>[] : NonNullable<Data> extends Record<string, any> ? PartialFormState<NonNullable<Data>> : MaybeOutput<Data> : unknown;
   /**
    * Collection of all the error messages, collected for all children properties and nested forms.
    *
    * Only contains errors from properties where $dirty equals true.
    * */
-  issues: DataTypeRegleIssues<Data, TRules$1>;
+  issues: DataTypeRegleIssues<Data, TRules>;
   /**
    * Collection of all the issues, collected for all children properties and nested forms.
    *
@@ -242,13 +240,13 @@ type RegleResult<Data extends Record<string, any> | any[] | unknown, TRules$1 ex
   errors: DataTypeRegleErrors<Data>;
 } | {
   valid: true;
-  data: IsUnknown<Data> extends true ? unknown : IsAny<Data> extends true ? unknown : IsEmptyObject<TRules$1> extends true ? MaybeOutput<Data> : HasNamedKeys<Data> extends true ? NonNullable<Data> extends Array<infer U extends Record<string, any>> ? DeepSafeFormState<U, TRules$1 extends ReglePartialRuleTree<any> ? TRules$1 : {}>[] : NonNullable<Data> extends Date | File ? SafeFieldProperty<Raw<NonNullable<Data>>, TRules$1 extends ReglePartialRuleTree<any> ? TRules$1 : {}> : NonNullable<Data> extends Record<string, any> ? DeepSafeFormState<NonNullable<Data>, TRules$1 extends ReglePartialRuleTree<any> ? TRules$1 : {}> : SafeFieldProperty<Data, TRules$1 extends ReglePartialRuleTree<any> ? TRules$1 : {}> : unknown;
+  data: IsUnknown<Data> extends true ? unknown : IsAny<Data> extends true ? unknown : IsEmptyObject<TRules> extends true ? MaybeOutput<Data> : HasNamedKeys<Data> extends true ? NonNullable<Data> extends Array<infer U extends Record<string, any>> ? DeepSafeFormState<U, TRules extends ReglePartialRuleTree<any> ? TRules : {}>[] : NonNullable<Data> extends Date | File ? SafeFieldProperty<Raw<NonNullable<Data>>, TRules extends ReglePartialRuleTree<any> ? TRules : {}> : NonNullable<Data> extends Record<string, any> ? DeepSafeFormState<NonNullable<Data>, TRules extends ReglePartialRuleTree<any> ? TRules : {}> : SafeFieldProperty<Data, TRules extends ReglePartialRuleTree<any> ? TRules : {}> : unknown;
   issues: EmptyObject;
   errors: EmptyObject;
 };
-type DataTypeRegleIssues<TData extends Record<string, any> | any[] | unknown, TRules$1 extends ReglePartialRuleTree<any> | RegleFormPropertyType<any> = never> = HasNamedKeys<TData> extends true ? NonNullable<TData> extends Array<infer U> ? isRecordLiteral<U> extends true ? RegleFieldIssue<TRules$1>[] : RegleCollectionErrors<TData, true> : isRecordLiteral<TData> extends true ? RegleIssuesTree<TData> : RegleFieldIssue<TRules$1>[] : RegleFieldIssue | RegleCollectionErrors<TData, true> | RegleIssuesTree<TData>;
+type DataTypeRegleIssues<TData extends Record<string, any> | any[] | unknown, TRules extends ReglePartialRuleTree<any> | RegleFormPropertyType<any> = never> = HasNamedKeys<TData> extends true ? NonNullable<TData> extends Array<infer U> ? isRecordLiteral<U> extends true ? RegleFieldIssue<TRules>[] : RegleCollectionErrors<TData, true> : isRecordLiteral<TData> extends true ? RegleIssuesTree<TData> : RegleFieldIssue<TRules>[] : RegleFieldIssue | RegleCollectionErrors<TData, true> | RegleIssuesTree<TData>;
 type DataTypeRegleErrors<TData extends Record<string, any> | any[] | unknown> = HasNamedKeys<TData> extends true ? NonNullable<TData> extends Array<infer U> ? isRecordLiteral<U> extends true ? string[] : RegleCollectionErrors<TData> : isRecordLiteral<TData> extends true ? RegleErrorTree<TData> : string[] : string[] | RegleErrorTree<TData> | RegleCollectionErrors<TData>;
-type RegleCollectionResult<Data extends any[], TRules$1 extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = RegleResult<Data, TRules$1> & ({
+type RegleCollectionResult<Data extends any[], TRules extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = RegleResult<Data, TRules> & ({
   valid: false;
   issues: RegleCollectionErrors<Data, true>;
   errors: RegleCollectionErrors<Data>;
@@ -257,9 +255,9 @@ type RegleCollectionResult<Data extends any[], TRules$1 extends ReglePartialRule
   issues: EmptyObject;
   errors: EmptyObject;
 });
-type RegleFieldResult<Data extends any, TRules$1 extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = RegleResult<Data, TRules$1> & ({
+type RegleFieldResult<Data extends any, TRules extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = RegleResult<Data, TRules> & ({
   valid: false;
-  issues: RegleFieldIssue<TRules$1>[];
+  issues: RegleFieldIssue<TRules>[];
   errors: string[];
 } | {
   valid: true;
@@ -272,15 +270,15 @@ type $InternalRegleResult = {
   errors: $InternalRegleErrorTree | $InternalRegleCollectionErrors | string[];
   issues: $InternalRegleIssuesTree | $InternalRegleCollectionIssues | RegleFieldIssue[];
 };
-type DeepSafeFormState<TState$1 extends Record<string, any>, TRules$1 extends ReglePartialRuleTree<Record<string, any>, CustomRulesDeclarationTree> | undefined> = [unknown] extends [TState$1] ? {} : TRules$1 extends undefined ? TState$1 : TRules$1 extends ReglePartialRuleTree<TState$1, CustomRulesDeclarationTree> ? Prettify<{ [K in keyof TState$1 as IsPropertyOutputRequired<TState$1[K], TRules$1[K]> extends false ? K : never]?: SafeProperty<TState$1[K], TRules$1[K]> extends MaybeInput<infer M> ? MaybeOutput<M> : SafeProperty<TState$1[K], TRules$1[K]> } & { [K in keyof TState$1 as IsPropertyOutputRequired<TState$1[K], TRules$1[K]> extends false ? never : K]-?: unknown extends SafeProperty<TState$1[K], TRules$1[K]> ? unknown : NonNullable<SafeProperty<TState$1[K], TRules$1[K]>> }> : TState$1;
+type DeepSafeFormState<TState extends Record<string, any>, TRules extends ReglePartialRuleTree<Record<string, any>, CustomRulesDeclarationTree> | undefined> = [unknown] extends [TState] ? {} : TRules extends undefined ? TState : TRules extends ReglePartialRuleTree<TState, CustomRulesDeclarationTree> ? Prettify<{ [K in keyof TState as IsPropertyOutputRequired<TState[K], TRules[K]> extends false ? K : never]?: SafeProperty<TState[K], TRules[K]> extends MaybeInput<infer M> ? MaybeOutput<M> : SafeProperty<TState[K], TRules[K]> } & { [K in keyof TState as IsPropertyOutputRequired<TState[K], TRules[K]> extends false ? never : K]-?: unknown extends SafeProperty<TState[K], TRules[K]> ? unknown : NonNullable<SafeProperty<TState[K], TRules[K]>> }> : TState;
 type FieldHaveRequiredRule<TRule extends RegleFormPropertyType<any, any> | undefined = never> = TRule extends MaybeRefOrComputedRef<RegleRuleDecl<any, any>> ? { [K in keyof UnwrapRef<TRule>]-?: UnwrapRef<TRule>[K] extends RegleRuleDefinition<unknown, any, any[], any, any, any, any, true> ? true : false }[keyof UnwrapRef<TRule>] extends false ? false : true : false;
-type ObjectHaveAtLeastOneRequiredField<TState$1 extends Record<string, any>, TRules$1 extends ReglePartialRuleTree<TState$1, any>> = TState$1 extends Maybe<TState$1> ? ({ [K in keyof NonNullable<TState$1>]-?: IsPropertyOutputRequired<NonNullable<TState$1>[K], TRules$1[K] extends RegleFormPropertyType<any, any> ? TRules$1[K] : {}> } & {
-  $self: IsPropertyOutputRequired<string, TRules$1['$self']>;
-})[keyof TState$1 | '$self'] extends false ? false : true : true;
-type ArrayHaveAtLeastOneRequiredField<TState$1 extends Maybe<any[]>, TRule extends RegleCollectionRuleDecl<TState$1>> = TState$1 extends Maybe<TState$1> ? FieldHaveRequiredRule<Omit<TRule, '$each'> extends MaybeRef<RegleRuleDecl> ? Omit<UnwrapRef<TRule>, '$each'> : {}> | ObjectHaveAtLeastOneRequiredField<ArrayElement<NonNullable<TState$1>>, ExtractFromGetter<TRule['$each']> extends undefined ? {} : NonNullable<ExtractFromGetter<TRule['$each']>>> extends false ? false : true : true;
-type SafeProperty<TState$1, TRule extends RegleFormPropertyType<any, any> | undefined> = unknown extends TState$1 ? unknown : TRule extends RegleCollectionRuleDecl<any, any> ? TState$1 extends Array<infer U extends Record<string, any>> ? DeepSafeFormState<U, ExtractFromGetter<TRule['$each']>>[] : TState$1 : TRule extends ReglePartialRuleTree<any, any> ? ExtendOnlyRealRecord<TState$1> extends true ? DeepSafeFormState<NonNullable<TState$1> extends Record<string, any> ? JoinDiscriminatedUnions<NonNullable<TState$1>> : {}, TRule> : TRule extends MaybeRef<RegleRuleDecl<any, any>> ? FieldHaveRequiredRule<UnwrapRef<TRule>> extends true ? TState$1 : MaybeOutput<TState$1> : TState$1 : TState$1;
-type IsPropertyOutputRequired<TState$1, TRule extends RegleFormPropertyType<any, any> | undefined> = [unknown] extends [TState$1] ? unknown : NonNullable<TState$1> extends Array<any> ? TRule extends RegleCollectionRuleDecl<any, any> ? ArrayHaveAtLeastOneRequiredField<NonNullable<TState$1>, TRule> extends false ? false : true : false : TRule extends ReglePartialRuleTree<any, any> ? ExtendOnlyRealRecord<TState$1> extends true ? ObjectHaveAtLeastOneRequiredField<NonNullable<TState$1> extends Record<string, any> ? NonNullable<TState$1> : {}, TRule extends ReglePartialRuleTree<NonNullable<TState$1> extends Record<string, any> ? NonNullable<TState$1> : {}, any> ? TRule : {}> extends false ? false : true : TRule extends MaybeRef<RegleRuleDecl<any, any>> ? FieldHaveRequiredRule<UnwrapRef<TRule>> extends false ? false : true : false : false;
-type SafeFieldProperty<TState$1, TRule extends RegleFormPropertyType<any, any> | undefined = never> = FieldHaveRequiredRule<TRule> extends true ? NonNullable<TState$1> : MaybeOutput<TState$1>;
+type ObjectHaveAtLeastOneRequiredField<TState extends Record<string, any>, TRules extends ReglePartialRuleTree<TState, any>> = TState extends Maybe<TState> ? ({ [K in keyof NonNullable<TState>]-?: IsPropertyOutputRequired<NonNullable<TState>[K], TRules[K] extends RegleFormPropertyType<any, any> ? TRules[K] : {}> } & {
+  $self: IsPropertyOutputRequired<string, TRules['$self']>;
+})[keyof TState | '$self'] extends false ? false : true : true;
+type ArrayHaveAtLeastOneRequiredField<TState extends Maybe<any[]>, TRule extends RegleCollectionRuleDecl<TState>> = TState extends Maybe<TState> ? FieldHaveRequiredRule<Omit<TRule, '$each'> extends MaybeRef<RegleRuleDecl> ? Omit<UnwrapRef<TRule>, '$each'> : {}> | ObjectHaveAtLeastOneRequiredField<ArrayElement<NonNullable<TState>>, ExtractFromGetter<TRule['$each']> extends undefined ? {} : NonNullable<ExtractFromGetter<TRule['$each']>>> extends false ? false : true : true;
+type SafeProperty<TState, TRule extends RegleFormPropertyType<any, any> | undefined> = unknown extends TState ? unknown : TRule extends RegleCollectionRuleDecl<any, any> ? TState extends Array<infer U extends Record<string, any>> ? DeepSafeFormState<U, ExtractFromGetter<TRule['$each']>>[] : TState : TRule extends ReglePartialRuleTree<any, any> ? ExtendOnlyRealRecord<TState> extends true ? DeepSafeFormState<NonNullable<TState> extends Record<string, any> ? JoinDiscriminatedUnions<NonNullable<TState>> : {}, TRule> : TRule extends MaybeRef<RegleRuleDecl<any, any>> ? FieldHaveRequiredRule<UnwrapRef<TRule>> extends true ? TState : MaybeOutput<TState> : TState : TState;
+type IsPropertyOutputRequired<TState, TRule extends RegleFormPropertyType<any, any> | undefined> = [unknown] extends [TState] ? unknown : NonNullable<TState> extends Array<any> ? TRule extends RegleCollectionRuleDecl<any, any> ? ArrayHaveAtLeastOneRequiredField<NonNullable<TState>, TRule> extends false ? false : true : false : TRule extends ReglePartialRuleTree<any, any> ? ExtendOnlyRealRecord<TState> extends true ? ObjectHaveAtLeastOneRequiredField<NonNullable<TState> extends Record<string, any> ? NonNullable<TState> : {}, TRule extends ReglePartialRuleTree<NonNullable<TState> extends Record<string, any> ? NonNullable<TState> : {}, any> ? TRule : {}> extends false ? false : true : TRule extends MaybeRef<RegleRuleDecl<any, any>> ? FieldHaveRequiredRule<UnwrapRef<TRule>> extends false ? false : true : false : false;
+type SafeFieldProperty<TState, TRule extends RegleFormPropertyType<any, any> | undefined = never> = FieldHaveRequiredRule<TRule> extends true ? NonNullable<TState> : MaybeOutput<TState>;
 /** Types to be augmented by @regle/schemas */
 interface NarrowVariantExtracts {}
 interface NarrowVariantFieldExtracts<T extends unknown> {}
@@ -290,31 +288,31 @@ type NarrowVariant<TRoot extends {
     [x: string]: unknown;
   };
   $value: unknown;
-}, TKey$1 extends keyof TRoot, TValue$1 extends (LazyJoinDiscriminatedUnions<Exclude<TRoot[TKey$1], RegleCollectionStatus<any, any, any> | RegleStatus<any, any, any> | NarrowVariantExtracts[keyof NarrowVariantExtracts]>> extends {
+}, TKey extends keyof TRoot, TValue extends (LazyJoinDiscriminatedUnions<Exclude<TRoot[TKey], RegleCollectionStatus<any, any, any> | RegleStatus<any, any, any> | NarrowVariantExtracts[keyof NarrowVariantExtracts]>> extends {
   $value: infer V;
-} ? V : unknown)> = Extract<TRoot, { [K in TKey$1]: RegleFieldStatus<TValue$1, any, any> | RegleFieldStatus<MaybeInput<TValue$1>, any, any> | (IsEmptyObject<NarrowVariantFieldExtracts<TValue$1>> extends true ? EmptyObject : NarrowVariantFieldExtracts<TValue$1>[keyof NarrowVariantFieldExtracts<TValue$1>]) }> & {
-  $fields: Extract<TRoot['$fields'], { [K in TKey$1]: RegleFieldStatus<TValue$1, any, any> | RegleFieldStatus<MaybeInput<TValue$1>, any, any> | (IsEmptyObject<NarrowVariantFieldExtracts<TValue$1>> extends true ? EmptyObject : NarrowVariantFieldExtracts<TValue$1>[keyof NarrowVariantFieldExtracts<TValue$1>]) }> & { [K in TKey$1]: TRoot[K] & {
-    $value: TValue$1;
+} ? V : unknown)> = Extract<TRoot, { [K in TKey]: RegleFieldStatus<TValue, any, any> | RegleFieldStatus<MaybeInput<TValue>, any, any> | (IsEmptyObject<NarrowVariantFieldExtracts<TValue>> extends true ? EmptyObject : NarrowVariantFieldExtracts<TValue>[keyof NarrowVariantFieldExtracts<TValue>]) }> & {
+  $fields: Extract<TRoot['$fields'], { [K in TKey]: RegleFieldStatus<TValue, any, any> | RegleFieldStatus<MaybeInput<TValue>, any, any> | (IsEmptyObject<NarrowVariantFieldExtracts<TValue>> extends true ? EmptyObject : NarrowVariantFieldExtracts<TValue>[keyof NarrowVariantFieldExtracts<TValue>]) }> & { [K in TKey]: TRoot[K] & {
+    $value: TValue;
   } };
 } & {
-  $value: Omit<TRoot['$value'], TKey$1> & { [K in TKey$1]: TValue$1 };
-} & { [K in TKey$1]: TRoot[K] & {
-  $value: TValue$1;
+  $value: Omit<TRoot['$value'], TKey> & { [K in TKey]: TValue };
+} & { [K in TKey]: TRoot[K] & {
+  $value: TValue;
 } };
-type MaybeVariantStatus<TState$1 extends Record<string, any> | undefined = Record<string, any>, TRules$1 extends ReglePartialRuleTree<NonNullable<TState$1>> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = {}> = IsUnion<NonNullable<TState$1>> extends true ? IsUnion<TRules$1> extends true ? Omit<RegleStatus<TState$1, TRules$1, TShortcuts>, '$fields'> & {
-  $fields: ProcessChildrenFields<TState$1, TRules$1, TShortcuts>[keyof ProcessChildrenFields<TState$1, TRules$1, TShortcuts>];
-} & (HasNamedKeys<TState$1> extends true ? ProcessChildrenFields<TState$1, TRules$1, TShortcuts>[keyof ProcessChildrenFields<TState$1, TRules$1, TShortcuts>] : {}) : RegleStatus<JoinDiscriminatedUnions<TState$1>, TRules$1 extends ReglePartialRuleTree<NonNullable<JoinDiscriminatedUnions<TState$1>>> ? TRules$1 : EmptyObject, TShortcuts> : RegleStatus<TState$1, TRules$1, TShortcuts>;
-type ProcessChildrenFields<TState$1 extends Record<string, any> | undefined, TRules$1 extends ReglePartialRuleTree<NonNullable<TState$1>>, TShortcuts extends RegleShortcutDefinition = {}> = { [TIndex in keyof TupleToPlainObj<UnionToTuple<TState$1>>]: TIndex extends `${infer TIndexInt extends number}` ? { [TKey in keyof UnionToTuple<TState$1>[TIndexInt] as IsEmptyObject<FindCorrespondingVariant<UnionToTuple<TState$1>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState$1>[TIndexInt] : never, UnionToTuple<TRules$1>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject> extends true ? TKey extends keyof TState$1 ? TState$1[TKey] extends NonNullable<TState$1[TKey]> ? TKey : never : never : TKey]-?: InferRegleStatusType<FindCorrespondingVariant<UnionToTuple<TState$1>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState$1>[TIndexInt] : never, UnionToTuple<TRules$1>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject, NonNullable<UnionToTuple<TState$1>[TIndexInt]>, TKey, TShortcuts> } & { [TKey in keyof UnionToTuple<TState$1>[TIndexInt] as IsEmptyObject<FindCorrespondingVariant<UnionToTuple<TState$1>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState$1>[TIndexInt] : never, UnionToTuple<TRules$1>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject> extends true ? TKey extends keyof TState$1 ? TState$1[TKey] extends NonNullable<TState$1[TKey]> ? never : TKey : TKey : never]?: InferRegleStatusType<FindCorrespondingVariant<UnionToTuple<TState$1>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState$1>[TIndexInt] : never, UnionToTuple<TRules$1>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject, NonNullable<UnionToTuple<TState$1>[TIndexInt]>, TKey, TShortcuts> } : {} };
-type FindCorrespondingVariant<TState$1 extends Record<string, any>, TRules$1 extends any[]> = TRules$1 extends [infer F, ...infer R] ? F extends ReglePartialRuleTree<TState$1> ? [F] : FindCorrespondingVariant<TState$1, R> : [];
-type PossibleLiteralTypes<T extends Record<string, any>, TKey$1 extends keyof T> = unknown extends T[TKey$1] ? {
-  [x: string]: { [K in TKey$1]-?: Omit<RegleRuleDecl<any, Partial<ExtendedRulesDeclarations>>, 'literal'> & {
+type MaybeVariantStatus<TState extends Record<string, any> | undefined = Record<string, any>, TRules extends ReglePartialRuleTree<NonNullable<TState>> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = {}> = IsUnion<NonNullable<TState>> extends true ? IsUnion<TRules> extends true ? Omit<RegleStatus<TState, TRules, TShortcuts>, '$fields'> & {
+  $fields: ProcessChildrenFields<TState, TRules, TShortcuts>[keyof ProcessChildrenFields<TState, TRules, TShortcuts>];
+} & (HasNamedKeys<TState> extends true ? ProcessChildrenFields<TState, TRules, TShortcuts>[keyof ProcessChildrenFields<TState, TRules, TShortcuts>] : {}) : RegleStatus<JoinDiscriminatedUnions<TState>, TRules extends ReglePartialRuleTree<NonNullable<JoinDiscriminatedUnions<TState>>> ? TRules : EmptyObject, TShortcuts> : RegleStatus<TState, TRules, TShortcuts>;
+type ProcessChildrenFields<TState extends Record<string, any> | undefined, TRules extends ReglePartialRuleTree<NonNullable<TState>>, TShortcuts extends RegleShortcutDefinition = {}> = { [TIndex in keyof TupleToPlainObj<UnionToTuple<TState>>]: TIndex extends `${infer TIndexInt extends number}` ? { [TKey in keyof UnionToTuple<TState>[TIndexInt] as IsEmptyObject<FindCorrespondingVariant<UnionToTuple<TState>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState>[TIndexInt] : never, UnionToTuple<TRules>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject> extends true ? TKey extends keyof TState ? TState[TKey] extends NonNullable<TState[TKey]> ? TKey : never : never : TKey]-?: InferRegleStatusType<FindCorrespondingVariant<UnionToTuple<TState>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState>[TIndexInt] : never, UnionToTuple<TRules>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject, NonNullable<UnionToTuple<TState>[TIndexInt]>, TKey, TShortcuts> } & { [TKey in keyof UnionToTuple<TState>[TIndexInt] as IsEmptyObject<FindCorrespondingVariant<UnionToTuple<TState>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState>[TIndexInt] : never, UnionToTuple<TRules>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject> extends true ? TKey extends keyof TState ? TState[TKey] extends NonNullable<TState[TKey]> ? never : TKey : TKey : never]?: InferRegleStatusType<FindCorrespondingVariant<UnionToTuple<TState>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState>[TIndexInt] : never, UnionToTuple<TRules>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject, NonNullable<UnionToTuple<TState>[TIndexInt]>, TKey, TShortcuts> } : {} };
+type FindCorrespondingVariant<TState extends Record<string, any>, TRules extends any[]> = TRules extends [infer F, ...infer R] ? F extends ReglePartialRuleTree<TState> ? [F] : FindCorrespondingVariant<TState, R> : [];
+type PossibleLiteralTypes<T extends Record<string, any>, TKey extends keyof T> = unknown extends T[TKey] ? {
+  [x: string]: { [K in TKey]-?: Omit<RegleRuleDecl<any, Partial<ExtendedRulesDeclarations>>, 'literal'> & {
     literal?: RegleRuleDefinition<'literal', any, [literal: any], false, boolean, any, string | number, true>;
   } };
-} : { [TVal in NonNullable<T[TKey$1]>]: { [K in TKey$1]-?: Omit<RegleRuleDecl<TVal, Partial<ExtendedRulesDeclarations>>, 'literal'> & {
+} : { [TVal in NonNullable<T[TKey]>]: { [K in TKey]-?: Omit<RegleRuleDecl<TVal, Partial<ExtendedRulesDeclarations>>, 'literal'> & {
   literal?: RegleRuleDefinition<'literal', MaybeInput<TVal>, [literal: TVal], false, boolean, MaybeInput<TVal>, string | number, true>;
 } } };
-type RequiredForm<T extends Record<string, any>, TKey$1 extends keyof T> = Omit<ReglePartialRuleTree<T>, TKey$1> & PossibleLiteralTypes<T, TKey$1>[keyof PossibleLiteralTypes<T, TKey$1>];
-type VariantTuple<T extends Record<string, any>, TKey$1 extends keyof T> = [RequiredForm<T, TKey$1>, ...RequiredForm<T, TKey$1>[]];
+type RequiredForm<T extends Record<string, any>, TKey extends keyof T> = Omit<ReglePartialRuleTree<T>, TKey> & PossibleLiteralTypes<T, TKey>[keyof PossibleLiteralTypes<T, TKey>];
+type VariantTuple<T extends Record<string, any>, TKey extends keyof T> = [RequiredForm<T, TKey>, ...RequiredForm<T, TKey>[]];
 /**
  * Combine all members of a union type, merging types for each key, and keeping loose types
  */
@@ -325,8 +323,8 @@ type ResolveKeys<TUnion extends unknown> = Partial<UnionToIntersection<RemoveCom
  */
 type LazyJoinDiscriminatedUnions<TUnion extends unknown> = isRecordLiteral<TUnion> extends true ? Prettify<Partial<UnionToIntersection<RemoveCommonKey<UnionToTuple<TUnion>, keyof NonNullable<TUnion>>[number]>> & Pick<NonNullable<TUnion>, keyof NonNullable<TUnion>>> : TUnion;
 type DumbJoinDiscriminatedUnions<TUnion extends unknown> = isRecordLiteral<TUnion> extends true ? Prettify<Partial<UnionToIntersection<TUnion>> & Pick<NonNullable<TUnion>, keyof NonNullable<TUnion>>> : TUnion;
-type RemoveCommonKey<T extends readonly any[], K$1 extends PropertyKey> = T extends [infer F, ...infer R] ? [Prettify<Omit<F, K$1>>, ...RemoveCommonKey<R, K$1>] : [];
-type HasCommonKey<T extends readonly any[], K$1 extends PropertyKey> = T extends [infer F, ...infer R] ? K$1 extends keyof F ? true : HasCommonKey<R, K$1> : false;
+type RemoveCommonKey<T extends readonly any[], K extends PropertyKey> = T extends [infer F, ...infer R] ? [Prettify<Omit<F, K>>, ...RemoveCommonKey<R, K>] : [];
+type HasCommonKey<T extends readonly any[], K extends PropertyKey> = T extends [infer F, ...infer R] ? K extends keyof F ? true : HasCommonKey<R, K> : false;
 /**
  * Transforms a union and apply undefined values to non-present keys to support intersection
  */
@@ -342,7 +340,7 @@ type RetrieveUnionUnknownKeysOf<T extends readonly any[]> = T extends [infer F,
 /**
  * Get item value from object, otherwise fallback to undefined. Avoid TS to not be able to infer keys not present on all unions
  */
-type GetMaybeObjectValue<O extends Record<string, any>, K$1 extends string> = K$1 extends keyof O ? O[K$1] : undefined;
+type GetMaybeObjectValue<O extends Record<string, any>, K extends string> = K extends keyof O ? O[K] : undefined;
 type RemoveIndexSignature<T> = { [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: T[K] };
 /**
  * Merge every boolean property into a single boolean.
@@ -372,19 +370,20 @@ type MaybeInput<T = any> = T | null | undefined;
 type MaybeOutput<T = any> = T | undefined;
 type MaybeReadonly<T> = T | Readonly<T>;
 type NonUndefined<T> = Exclude<T, undefined>;
+type MaybeNullable<T> = Or<IsNullable<T>, IsOptional<T>>;
 type PromiseReturn<T> = T extends Promise<infer U> ? U : T;
-type MaybeGetter<T, V$1 = any, TAdd extends Record<string, any> = {}, TSelf extends Record<string, any> = {}> = (T & TSelf) | ((value: Ref<V$1>, index: number) => T & TAdd & TSelf);
+type MaybeGetter<T, V = any, TAdd extends Record<string, any> = {}, TSelf extends Record<string, any> = {}> = (T & TSelf) | ((value: Ref<V>, index: number) => T & TAdd & TSelf);
 type MaybeComputedOrGetter<T> = MaybeRefOrComputedRef<T> | ((...args: any[]) => T);
 type Unwrap<T extends MaybeRef<unknown>> = T extends Ref ? UnwrapRef<T> : UnwrapNestedRefs<T>;
 type UnwrapSimple<T extends MaybeRef<Record<string, any>>> = T extends MaybeComputedOrGetter<infer U> ? U : T extends Ref<infer U> ? U : T extends ((...args: any[]) => infer U) ? U : T;
 type ExtractFromGetter<T extends MaybeGetter<any, any, any>> = T extends ((value: Ref<any>, index: number) => infer U extends Record<string, any>) ? U : T;
 type ExtendOnlyRealRecord<T extends unknown> = NonNullable<T> extends File | Date | RegleStatic<{}> | RegleStaticImpl<{}> ? false : NonNullable<T> extends Record<string, any> ? true : false;
-type OmitByType<T extends Record<string, any>, U$1> = { [K in keyof T as T[K] extends U$1 ? never : K]: T[K] };
+type OmitByType<T extends Record<string, any>, U> = { [K in keyof T as T[K] extends U ? never : K]: T[K] };
 type DeepMaybeRef<T extends Record<string, any>> = { [K in keyof T]: MaybeRef<T[K]> };
-type ExcludeByType<T, U$1> = { [K in keyof T as T[K] extends U$1 ? never : K]: T[K] extends U$1 ? never : T[K] };
+type ExcludeByType<T, U> = { [K in keyof T as T[K] extends U ? never : K]: T[K] extends U ? never : T[K] };
 type PrimitiveTypes = string | number | boolean | bigint | Date | File;
 type isRecordLiteral<T extends unknown> = NonNullable<T> extends Date | File | RegleStatic<unknown> | RegleStaticImpl<unknown> ? false : NonNullable<T> extends Record<string, any> ? true : false;
-type NoInferLegacy<A$1 extends any> = [A$1][A$1 extends any ? 0 : never];
+type NoInferLegacy<A extends any> = [A][A extends any ? 0 : never];
 /**
  * Extract the element type from an array.
  *
@@ -399,7 +398,7 @@ type ArrayElement<T> = T extends Array<infer U> ? U : never;
  */
 type NonEmptyTuple<T> = [T, ...T[]] | T[];
 interface inferRulesFn<TCustomRules extends Partial<ExtendedRulesDeclarations>> {
-  <TState$1 extends MaybeRef<Record<string, any> | MaybeInput<PrimitiveTypes>>, TRules$1 extends ReglePartialRuleTree<Unwrap<TState$1 extends Record<string, any> ? TState$1 : {}>, Partial<DefaultValidatorsTree> & TCustomRules>, TDecl extends RegleRuleDecl<NonNullable<TState$1>, Partial<DefaultValidatorsTree> & TCustomRules>>(state: Maybe<TState$1> | DeepReactiveState<TState$1>, rulesFactory: Unwrap<TState$1> extends MaybeInput<PrimitiveTypes> ? TDecl : Unwrap<TState$1> extends Record<string, any> ? TRules$1 : {}): NonNullable<Unwrap<TState$1>> extends PrimitiveTypes ? TDecl : TRules$1;
+  <TState extends MaybeRef<Record<string, any> | MaybeInput<PrimitiveTypes>>, TRules extends ReglePartialRuleTree<Unwrap<TState extends Record<string, any> ? TState : {}>, Partial<DefaultValidatorsTree> & TCustomRules>, TDecl extends RegleRuleDecl<NonNullable<TState>, Partial<DefaultValidatorsTree> & TCustomRules>>(state: Maybe<TState> | DeepReactiveState<TState>, rulesFactory: Unwrap<TState> extends MaybeInput<PrimitiveTypes> ? TDecl : Unwrap<TState> extends Record<string, any> ? TRules : {}): NonNullable<Unwrap<TState>> extends PrimitiveTypes ? TDecl : TRules;
 }
 /**
  * Type helper to provide autocomplete and type-checking for your form rules.
@@ -567,9 +566,9 @@ declare function extendRegleConfig<TRootCustomRules extends Partial<ExtendedRule
   useRegle: useRegleFn<Merge<TRootCustomRules, TCustomRules>, TRootShortcuts & TShortcuts>;
   inferRules: inferRulesFn<Merge<TRootCustomRules, TCustomRules>>;
 };
-type useRegleFnOptions<TState$1 extends Record<string, any> | MaybeInput<PrimitiveTypes>, TRules$1 extends ReglePartialRuleTree<NonNullable<JoinDiscriminatedUnions<TState$1>>, Partial<ExtendedRulesDeclarations>>, TAdditionalOptions extends Record<string, any>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>> = TState$1 extends Record<string, any> ? Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<JoinDiscriminatedUnions<TState$1>, TRules$1, TValidationGroups> & TAdditionalOptions : Partial<DeepMaybeRef<RegleBehaviourOptions>> & TAdditionalOptions;
+type useRegleFnOptions<TState extends Record<string, any> | MaybeInput<PrimitiveTypes>, TRules extends ReglePartialRuleTree<NonNullable<JoinDiscriminatedUnions<TState>>, Partial<ExtendedRulesDeclarations>>, TAdditionalOptions extends Record<string, any>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>> = TState extends Record<string, any> ? Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<JoinDiscriminatedUnions<TState>, TRules, TValidationGroups> & TAdditionalOptions : Partial<DeepMaybeRef<RegleBehaviourOptions>> & TAdditionalOptions;
 interface useRegleFn<TCustomRules extends Partial<ExtendedRulesDeclarations>, TShortcuts extends RegleShortcutDefinition<any> = never, TAdditionalReturnProperties extends Record<string, any> = {}, TAdditionalOptions extends Record<string, any> = {}> {
-  <TState$1 extends MaybeRef<Record<string, any> | MaybeInput<PrimitiveTypes>>, TRules$1 extends ReglePartialRuleTree<JoinDiscriminatedUnions<Unwrap<TState$1>>, Partial<ExtendedRulesDeclarations> & Partial<TCustomRules>>, TDecl extends RegleRuleDecl<NonNullable<Unwrap<TState$1>>, Partial<ExtendedRulesDeclarations> & Partial<TCustomRules>>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>>(...params: [state: Maybe<TState$1> | DeepReactiveState<TState$1>, rulesFactory: Unwrap<TState$1> extends MaybeInput<PrimitiveTypes> ? MaybeRefOrGetter<TDecl> : Unwrap<TState$1> extends Record<string, any> ? MaybeComputedOrGetter<TRules$1> : {}, ...(HaveAnyRequiredProps<useRegleFnOptions<Unwrap<TState$1>, TRules$1, TAdditionalOptions, TValidationGroups>> extends true ? [options: useRegleFnOptions<Unwrap<TState$1>, TRules$1, TAdditionalOptions, TValidationGroups>] : [options?: useRegleFnOptions<Unwrap<TState$1>, TRules$1, TAdditionalOptions, TValidationGroups>])]): NonNullable<Unwrap<TState$1>> extends PrimitiveTypes ? RegleSingleField<NonNullable<Unwrap<TState$1>>, TDecl, TShortcuts, TAdditionalReturnProperties> : Regle<Unwrap<TState$1> extends Record<string, any> ? Unwrap<TState$1> : {}, UnwrapSimple<TRules$1> extends Record<string, any> ? UnwrapSimple<TRules$1> : {}, TValidationGroups, TShortcuts, TAdditionalReturnProperties>;
+  <TState extends MaybeRef<Record<string, any> | MaybeInput<PrimitiveTypes>>, TRules extends ReglePartialRuleTree<JoinDiscriminatedUnions<Unwrap<TState>>, Partial<ExtendedRulesDeclarations> & Partial<TCustomRules>>, TDecl extends RegleRuleDecl<NonNullable<Unwrap<TState>>, Partial<ExtendedRulesDeclarations> & Partial<TCustomRules>>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>>(...params: [state: Maybe<TState> | DeepReactiveState<TState>, rulesFactory: Unwrap<TState> extends MaybeInput<PrimitiveTypes> ? MaybeRefOrGetter<TDecl> : Unwrap<TState> extends Record<string, any> ? MaybeComputedOrGetter<TRules> : {}, ...(HaveAnyRequiredProps<useRegleFnOptions<Unwrap<TState>, TRules, TAdditionalOptions, TValidationGroups>> extends true ? [options: useRegleFnOptions<Unwrap<TState>, TRules, TAdditionalOptions, TValidationGroups>] : [options?: useRegleFnOptions<Unwrap<TState>, TRules, TAdditionalOptions, TValidationGroups>])]): NonNullable<Unwrap<TState>> extends PrimitiveTypes ? RegleSingleField<NonNullable<Unwrap<TState>>, TDecl, TShortcuts, TAdditionalReturnProperties> : Regle<Unwrap<TState> extends Record<string, any> ? Unwrap<TState> : {}, UnwrapSimple<TRules> extends Record<string, any> ? UnwrapSimple<TRules> : {}, TValidationGroups, TShortcuts, TAdditionalReturnProperties>;
   __config?: GlobalConfigOptions<TCustomRules, TShortcuts>;
 }
 /**
@@ -679,9 +678,81 @@ declare function flatErrors(errors: $InternalRegleErrors, options: {
 declare function flatErrors(errors: $InternalRegleErrors, options?: {
   includePath?: false;
 }): string[];
-type useRulesFnOptions<TRules$1 extends RegleUnknownRulesTree | RegleRuleDecl, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TState$1 = InferInput<TRules$1>> = Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<JoinDiscriminatedUnions<TState$1 extends Record<string, any> ? Unwrap<TState$1> : {}>, TState$1 extends Record<string, any> ? (TRules$1 extends Record<string, any> ? TRules$1 : {}) : {}, TValidationGroups>;
+/**
+ * Retrieves error messages for a specific field using a dot-notation path.
+ * Provides type-safe access to nested error arrays in a Regle instance.
+ *
+ * @typeParam TRegle - The Regle instance type (root or status)
+ * @typeParam TPath - The dot-notation path type, validated at compile-time
+ *
+ * @param r$ - The Regle instance (e.g., from `useRegle()`)
+ * @param path - Dot-notation path to the field (e.g., `'user.email'` or `'items.0.name'`)
+ * @returns Array of error strings for the field, or `undefined` if path doesn't exist
+ *
+ * @example
+ * ```ts
+ * import { getErrors, useRegle } from '@regle/core';
+ * import { required, email } from '@regle/rules';
+ *
+ * const { r$ } = useRegle(
+ *   { user: { email: '' } },
+ *   { user: { email: { required, email } } }
+ * );
+ *
+ * await r$.$validate();
+ *
+ * // Type-safe access to nested errors
+ * const emailErrors = getErrors(r$, 'user.email');
+ * // ['This field is required']
+ *
+ * // Works with collections too
+ * const itemErrors = getErrors(r$, 'items.0.name');
+ * ```
+ *
+ * @see {@link https://reglejs.dev/core-concepts/displaying-errors#get-errors-by-path Documentation}
+ */
+declare function getErrors<TRegle extends SuperCompatibleRegleRoot | SuperCompatibleRegleStatus, TPath extends Paths<TRegle['$errors']> | (string & {})>(r$: MaybeRef<TRegle>, path: TPath): IsStringLiteral<TPath> extends true ? Get<TRegle['$errors'], TPath & string> : string[] | undefined;
+/**
+ * Retrieves detailed validation issues for a specific field using a dot-notation path.
+ * Issues contain more information than errors, including the rule name, property, and metadata.
+ *
+ * @typeParam TRegle - The Regle instance type (root or status)
+ * @typeParam TPath - The dot-notation path type, validated at compile-time
+ *
+ * @param r$ - The Regle instance (e.g., from `useRegle()`)
+ * @param path - Dot-notation path to the field (e.g., `'user.email'` or `'items.0.name'`)
+ * @returns Array of `RegleFieldIssue` objects for the field, or `undefined` if path doesn't exist
+ *
+ * @example
+ * ```ts
+ * import { getIssues, useRegle } from '@regle/core';
+ * import { required, email } from '@regle/rules';
+ *
+ * const { r$ } = useRegle(
+ *   { user: { email: '' } },
+ *   { user: { email: { required, email } } }
+ * );
+ *
+ * await r$.$validate();
+ *
+ * // Type-safe access to nested issues with full metadata
+ * const emailIssues = getIssues(r$, 'user.email');
+ * // [{
+ * //   $message: 'This field is required',
+ * //   $property: 'email',
+ * //   $rule: 'required'
+ * // }]
+ *
+ * // Works with collections too
+ * const itemIssues = getIssues(r$, 'items.0.name');
+ * ```
+ *
+ * @see {@link https://reglejs.dev/core-concepts/displaying-errors#get-issues-by-path Documentation}
+ */
+declare function getIssues<TRegle extends SuperCompatibleRegleRoot | SuperCompatibleRegleStatus, TPath extends Paths<TRegle['$issues']>>(r$: MaybeRef<TRegle>, path: TPath | (string & {})): IsStringLiteral<TPath> extends true ? Get<TRegle['$issues'], TPath & string> : RegleFieldIssue[] | undefined;
+type useRulesFnOptions<TRules extends RegleUnknownRulesTree | RegleRuleDecl, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TState = InferInput<TRules>> = Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<JoinDiscriminatedUnions<TState extends Record<string, any> ? Unwrap<TState> : {}>, TState extends Record<string, any> ? (TRules extends Record<string, any> ? TRules : {}) : {}, TValidationGroups>;
 interface useRulesFn<TCustomRules extends Partial<ExtendedRulesDeclarations>, TShortcuts extends RegleShortcutDefinition<any> = never> {
-  <TRules$1 extends RegleUnknownRulesTree | RegleRuleDecl, TDecl extends RegleRuleDecl<NonNullable<TState$1>, Partial<ExtendedRulesDeclarations> & TCustomRules>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TState$1 extends Record<string, any> = InferInput<TRules$1>>(rulesFactory: TState$1 extends Record<string, any> ? MaybeRef<TRules$1> | ((...args: any[]) => TRules$1) : {}, options?: useRulesFnOptions<TRules$1, TValidationGroups, TState$1>): NonNullable<TState$1> extends PrimitiveTypes ? Raw<RegleFieldStatus<NonNullable<TState$1>, TDecl, TShortcuts>> & StandardSchemaV1<TState$1> : Raw<RegleRoot<TState$1 extends Record<string, any> ? Unwrap<TState$1> : {}, TRules$1 extends Record<string, any> ? TRules$1 : {}, TValidationGroups, TShortcuts>> & StandardSchemaV1<TState$1>;
+  <TRules extends RegleUnknownRulesTree | RegleRuleDecl, TDecl extends RegleRuleDecl<NonNullable<TState>, Partial<ExtendedRulesDeclarations> & TCustomRules>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TState extends Record<string, any> = InferInput<TRules>>(rulesFactory: TState extends Record<string, any> ? MaybeRef<TRules> | ((...args: any[]) => TRules) : {}, options?: useRulesFnOptions<TRules, TValidationGroups, TState>): NonNullable<TState> extends PrimitiveTypes ? Raw<RegleFieldStatus<NonNullable<TState>, TDecl, TShortcuts>> & StandardSchemaV1<TState> : Raw<RegleRoot<TState extends Record<string, any> ? Unwrap<TState> : {}, TRules extends Record<string, any> ? TRules : {}, TValidationGroups, TShortcuts>> & StandardSchemaV1<TState>;
   __config?: GlobalConfigOptions<TCustomRules, TShortcuts>;
 }
 /**
@@ -741,16 +812,16 @@ type InferRegleShortcuts<T extends useRegleFn<any, any>> = T extends useRegleFn<
 /**
  * Extract a set rules and setting them as required
  */
-type RegleEnforceRequiredRules<TRules$1 extends keyof DefaultValidators> = Omit<Partial<DefaultValidatorsTree>, TRules$1> & { [K in TRules$1]-?: UnwrapRuleWithParams<DefaultValidators[K]> };
+type RegleEnforceRequiredRules<TRules extends keyof DefaultValidators> = Omit<Partial<DefaultValidatorsTree>, TRules> & { [K in TRules]-?: UnwrapRuleWithParams<DefaultValidators[K]> };
 /**
  * Extract a set of custom rules from a global configuration and setting them as required
 
  */
-type RegleEnforceCustomRequiredRules<T extends useRegleFn<any, any>, TRules$1 extends keyof InferRegleRules<T>> = Omit<Partial<DefaultValidatorsTree>, TRules$1> & { [K in TRules$1]-?: T extends useRegleFn<any, any> ? K extends keyof InferRegleRules<T> ? NonNullable<UnwrapRuleWithParams<InferRegleRules<T>[K]>> : never : K extends keyof T ? NonNullable<T[K]> : never };
+type RegleEnforceCustomRequiredRules<T extends useRegleFn<any, any>, TRules extends keyof InferRegleRules<T>> = Omit<Partial<DefaultValidatorsTree>, TRules> & { [K in TRules]-?: T extends useRegleFn<any, any> ? K extends keyof InferRegleRules<T> ? NonNullable<UnwrapRuleWithParams<InferRegleRules<T>[K]>> : never : K extends keyof T ? NonNullable<T[K]> : never };
 /**
  * Extract custom rules and custom shortcuts and apply them to a RegleFieldStatus type
  */
-type RegleCustomFieldStatus<T extends useRegleFn<any, any>, TState$1 extends unknown = any, TRules$1 extends keyof InferRegleRules<T> = never> = RegleFieldStatus<TState$1, [TRules$1] extends [never] ? Partial<InferRegleRules<T>> : RegleEnforceCustomRequiredRules<T, TRules$1>, InferRegleShortcuts<T>>;
+type RegleCustomFieldStatus<T extends useRegleFn<any, any>, TState extends unknown = any, TRules extends keyof InferRegleRules<T> = never> = RegleFieldStatus<TState, [TRules] extends [never] ? Partial<InferRegleRules<T>> : RegleEnforceCustomRequiredRules<T, TRules>, InferRegleShortcuts<T>>;
 /**
  * Infer safe output type from a rules object and it's original state type
  *
@@ -758,7 +829,7 @@ type RegleCustomFieldStatus<T extends useRegleFn<any, any>, TState$1 extends unk
  * type FormRequest = InferOutput<typeof rules, typeof formState>;
  * ```
  */
-type InferOutput<TRules$1 extends MaybeRef<ReglePartialRuleTree<Record<string, any>, any>> | ((state: any) => ReglePartialRuleTree<Record<string, any>, any>) | MaybeRef<StandardSchemaV1<any>>, TState$1 extends MaybeRef<unknown> = InferInput<TRules$1>> = isRecordLiteral<TState$1> extends true ? TRules$1 extends MaybeRef<StandardSchemaV1<infer State>> ? State : DeepSafeFormState<JoinDiscriminatedUnions<Unwrap<NonNullable<TState$1>>>, TRules$1 extends MaybeRef<ReglePartialRuleTree<Record<string, any>, any>> ? UnwrapRef<TRules$1> : {}> : TState$1 extends any[] ? TState$1[] : TState$1;
+type InferOutput<TRules extends MaybeRef<ReglePartialRuleTree<Record<string, any>, any>> | ((state: any) => ReglePartialRuleTree<Record<string, any>, any>) | MaybeRef<StandardSchemaV1<any>>, TState extends MaybeRef<unknown> = InferInput<TRules>> = isRecordLiteral<TState> extends true ? TRules extends MaybeRef<StandardSchemaV1<infer State>> ? State : DeepSafeFormState<JoinDiscriminatedUnions<Unwrap<NonNullable<TState>>>, TRules extends MaybeRef<ReglePartialRuleTree<Record<string, any>, any>> ? UnwrapRef<TRules> : {}> : TState extends any[] ? TState[] : TState;
 /**
  * Infer input type from a rules object
  *
@@ -766,15 +837,15 @@ type InferOutput<TRules$1 extends MaybeRef<ReglePartialRuleTree<Record<string, a
  * type FormRequest = InferInput<typeof rules>;
  * ```
  */
-type InferInput<TRules$1 extends MaybeRef<ReglePartialRuleTree<Record<string, any>, any>> | ((state: any) => ReglePartialRuleTree<Record<string, any>, any>) | MaybeRef<StandardSchemaV1<any>>, TMarkMaybe extends boolean = true> = TRules$1 extends MaybeRef<StandardSchemaV1<infer State>> ? State : IsUnion<UnwrapSimple<TRules$1>> extends true ? InferTupleUnionInput<UnionToTuple<UnwrapSimple<TRules$1>>>[number] : TMarkMaybe extends true ? Prettify<{ [K in keyof UnwrapSimple<TRules$1> as UnwrapSimple<TRules$1>[K] extends MaybeRef<RegleRuleDecl<any, any>> ? K : never]?: ProcessInputChildren<UnwrapSimple<TRules$1>[K], TMarkMaybe> } & { [K in keyof UnwrapSimple<TRules$1> as UnwrapSimple<TRules$1>[K] extends MaybeRef<RegleRuleDecl<any, any>> ? never : K]: ProcessInputChildren<UnwrapSimple<TRules$1>[K], TMarkMaybe> }> : Prettify<{ [K in keyof UnwrapSimple<TRules$1>]: ProcessInputChildren<UnwrapSimple<TRules$1>[K], TMarkMaybe> }>;
+type InferInput<TRules extends MaybeRef<ReglePartialRuleTree<Record<string, any>, any>> | ((state: any) => ReglePartialRuleTree<Record<string, any>, any>) | MaybeRef<StandardSchemaV1<any>>, TMarkMaybe extends boolean = true> = TRules extends MaybeRef<StandardSchemaV1<infer State>> ? State : IsUnion<UnwrapSimple<TRules>> extends true ? InferTupleUnionInput<UnionToTuple<UnwrapSimple<TRules>>>[number] : TMarkMaybe extends true ? Prettify<{ [K in keyof UnwrapSimple<TRules> as UnwrapSimple<TRules>[K] extends MaybeRef<RegleRuleDecl<any, any>> ? K : never]?: ProcessInputChildren<UnwrapSimple<TRules>[K], TMarkMaybe> } & { [K in keyof UnwrapSimple<TRules> as UnwrapSimple<TRules>[K] extends MaybeRef<RegleRuleDecl<any, any>> ? never : K]: ProcessInputChildren<UnwrapSimple<TRules>[K], TMarkMaybe> }> : Prettify<{ [K in keyof UnwrapSimple<TRules>]: ProcessInputChildren<UnwrapSimple<TRules>[K], TMarkMaybe> }>;
 type ProcessInputChildren<TRule extends unknown, TMarkMaybe extends boolean> = TRule extends {
   $each: RegleCollectionEachRules<any, any>;
 } ? ExtractFromGetter<TRule['$each']> extends ReglePartialRuleTree<any, any> ? InferInput<ExtractFromGetter<TRule['$each']>, TMarkMaybe>[] : any[] : TRule extends MaybeRef<RegleRuleDecl<any, any>> ? [ExtractTypeFromRules<UnwrapRef<TRule>>] extends [never] ? unknown : ExtractTypeFromRules<UnwrapRef<TRule>> : TRule extends ReglePartialRuleTree<any, any> ? InferInput<TRule, TMarkMaybe> : string;
-type ExtractTypeFromRules<TRules$1 extends RegleRuleDecl<any, any>> = FilterRulesWithInput<TRules$1> extends {
+type ExtractTypeFromRules<TRules extends RegleRuleDecl<any, any>> = FilterRulesWithInput<TRules> extends {
   type: infer Input;
-} ? Input : [FilterRulesWithSingleType<TRules$1>[keyof FilterRulesWithSingleType<TRules$1>]] extends [never] ? FilterRulesWithInput<TRules$1>[keyof FilterRulesWithInput<TRules$1>] : FilterRulesWithSingleType<TRules$1>[keyof FilterRulesWithSingleType<TRules$1>];
-type FilterRulesWithInput<TRules$1 extends RegleRuleDecl<any, any>> = { [K in keyof TRules$1 as TRules$1[K] extends RegleRuleDefinition<unknown, any, any, any, any, infer Input> ? unknown extends Input ? never : K : never]: TRules$1[K] extends RegleRuleDefinition<unknown, any, any, any, any, infer Input> ? Input : unknown };
-type FilterRulesWithSingleType<TRules$1 extends RegleRuleDecl<any, any>> = { [K in keyof TRules$1 as TRules$1[K] extends RegleRuleDefinition<unknown, any, any, any, any, infer Input> ? unknown extends Input ? never : IsUnion<NonNullable<Input>> extends true ? never : K : never]: TRules$1[K] extends RegleRuleDefinition<unknown, any, any, any, any, infer Input> ? IsUnion<NonNullable<Input>> extends true ? unknown : Input : unknown };
+} ? Input : [FilterRulesWithSingleType<TRules>[keyof FilterRulesWithSingleType<TRules>]] extends [never] ? FilterRulesWithInput<TRules>[keyof FilterRulesWithInput<TRules>] : FilterRulesWithSingleType<TRules>[keyof FilterRulesWithSingleType<TRules>];
+type FilterRulesWithInput<TRules extends RegleRuleDecl<any, any>> = { [K in keyof TRules as TRules[K] extends RegleRuleDefinition<unknown, any, any, any, any, infer Input> ? unknown extends Input ? never : K : never]: TRules[K] extends RegleRuleDefinition<unknown, any, any, any, any, infer Input> ? Input : unknown };
+type FilterRulesWithSingleType<TRules extends RegleRuleDecl<any, any>> = { [K in keyof TRules as TRules[K] extends RegleRuleDefinition<unknown, any, any, any, any, infer Input> ? unknown extends Input ? never : IsUnion<NonNullable<Input>> extends true ? never : K : never]: TRules[K] extends RegleRuleDefinition<unknown, any, any, any, any, infer Input> ? IsUnion<NonNullable<Input>> extends true ? unknown : Input : unknown };
 type InferTupleUnionInput<T extends any[]> = T extends [infer F extends ReglePartialRuleTree, ...infer R] ? [InferInput<F, true>, ...InferTupleUnionInput<R>] : [];
 /**
  * Infer safe output from any `r$` instance
@@ -832,21 +903,21 @@ type CreateFn<T extends any[]> = (...args: T) => any;
  *
  * [foo: string, bar?: number] => [foo: MaybeRef<string> | (() => string), bar?: MaybeRef<number | undefined> | (() => number) | undefined]
  */
-type RegleUniversalParams<T extends any[] = [], F$1 = CreateFn<T>> = [T] extends [[]] ? [] : Parameters<F$1 extends ((...args: infer Args) => any) ? (...args: { [K in keyof Args]: MaybeRefOrGetter<Maybe<Args[K]>> }) => any : never>;
-type UnwrapRegleUniversalParams<T extends MaybeRefOrGetter[] = [], F$1 = CreateFn<T>> = [T] extends [[]] ? [] : Parameters<F$1 extends ((...args: infer Args) => any) ? (...args: { [K in keyof Args]: Args[K] extends MaybeRefOrGetter<Maybe<infer U>> ? U : Args[K] }) => any : never>;
+type RegleUniversalParams<T extends any[] = [], F = CreateFn<T>> = [T] extends [[]] ? [] : Parameters<F extends ((...args: infer Args) => any) ? (...args: { [K in keyof Args]: MaybeRefOrGetter<Maybe<Args[K]>> }) => any : never>;
+type UnwrapRegleUniversalParams<T extends MaybeRefOrGetter[] = [], F = CreateFn<T>> = [T] extends [[]] ? [] : Parameters<F extends ((...args: infer Args) => any) ? (...args: { [K in keyof Args]: Args[K] extends MaybeRefOrGetter<Maybe<infer U>> ? U : Args[K] }) => any : never>;
 /**
  * Internal definition of the rule, this can be used to reset or patch the rule
  */
-type RegleInternalRuleDefs<TValue$1 extends any = any, TParams$1 extends any[] = [], TAsync$1 extends boolean = false, TMetadata$1 extends RegleRuleMetadataDefinition = boolean> = Raw<{
-  _validator: (value: Maybe<TValue$1>, ...args: TParams$1) => TAsync$1 extends false ? TMetadata$1 : Promise<TMetadata$1>;
-  _message: string | string[] | ((metadata: PossibleRegleRuleMetadataConsumer<TValue$1>) => string | string[]);
-  _active?: boolean | ((metadata: PossibleRegleRuleMetadataConsumer<TValue$1>) => boolean);
-  _tooltip?: string | string[] | ((metadata: PossibleRegleRuleMetadataConsumer<TValue$1>) => string | string[]);
+type RegleInternalRuleDefs<TValue extends any = any, TParams extends any[] = [], TAsync extends boolean = false, TMetadata extends RegleRuleMetadataDefinition = boolean> = Raw<{
+  _validator: (value: Maybe<TValue>, ...args: TParams) => TAsync extends false ? TMetadata : Promise<TMetadata>;
+  _message: string | string[] | ((metadata: PossibleRegleRuleMetadataConsumer<TValue>) => string | string[]);
+  _active?: boolean | ((metadata: PossibleRegleRuleMetadataConsumer<TValue>) => boolean);
+  _tooltip?: string | string[] | ((metadata: PossibleRegleRuleMetadataConsumer<TValue>) => string | string[]);
   _type?: string;
   _message_patched: boolean;
   _tooltip_patched: boolean;
-  _params?: RegleUniversalParams<TParams$1>;
-  _async: TAsync$1;
+  _params?: RegleUniversalParams<TParams>;
+  _async: TAsync;
   readonly _brand: symbol;
 }>;
 declare const InternalRuleType: {
@@ -858,26 +929,26 @@ type IsLiteral<T> = string extends T ? false : true;
 /**
  * Returned typed of rules created with `createRule`
  * */
-interface RegleRuleDefinition<TType$1 extends string | unknown = unknown, TValue$1 extends unknown = unknown, TParams$1 extends any[] = [], TAsync$1 extends boolean = boolean, TMetaData extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, _TInput = unknown, TFilteredValue extends any = (TValue$1 extends Date & File & (infer M) ? M : TValue$1), TNonEmpty extends boolean = boolean> extends RegleInternalRuleDefs<TFilteredValue, TParams$1, TAsync$1, TMetaData> {
-  validator: RegleRuleDefinitionProcessor<TFilteredValue, TParams$1, TAsync$1 extends false ? TMetaData : Promise<TMetaData>>;
+interface RegleRuleDefinition<TType extends string | unknown = unknown, TValue extends unknown = unknown, TParams extends any[] = [], TAsync extends boolean = boolean, TMetaData extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, _TInput = unknown, TFilteredValue extends any = (TValue extends Date & File & (infer M) ? M : TValue), TNonEmpty extends boolean = boolean> extends RegleInternalRuleDefs<TFilteredValue, TParams, TAsync, TMetaData> {
+  validator: RegleRuleDefinitionProcessor<TFilteredValue, TParams, TAsync extends false ? TMetaData : Promise<TMetaData>>;
   message: (metadata: PossibleRegleRuleMetadataConsumer<TFilteredValue>) => string | string[];
   active: (metadata: PossibleRegleRuleMetadataConsumer<TFilteredValue>) => boolean;
   tooltip: (metadata: PossibleRegleRuleMetadataConsumer<TFilteredValue>) => string | string[];
-  type?: TType$1;
-  _value?: IsLiteral<TValue$1> extends true ? TValue$1 : any;
-  exec: (value: Maybe<TFilteredValue>) => TAsync$1 extends false ? TMetaData : Promise<TMetaData>;
+  type?: TType;
+  _value?: IsLiteral<TValue> extends true ? TValue : any;
+  exec: (value: Maybe<TFilteredValue>) => TAsync extends false ? TMetaData : Promise<TMetaData>;
   required: TNonEmpty;
 }
 /**
  * Rules with params created with `createRules` are callable while being customizable
  */
-type RegleRuleWithParamsDefinition<TType$1 extends string | unknown = unknown, TValue$1 extends unknown = unknown, TParams$1 extends any[] = never, TAsync$1 extends boolean = false, TMetadata$1 extends RegleRuleMetadataDefinition = boolean, TInput = unknown, TFilteredValue extends any = (TValue$1 extends Date & File & (infer M) ? M : TValue$1)> = RegleRuleCore<TType$1, TFilteredValue, TParams$1, TAsync$1, TMetadata$1> & RegleInternalRuleDefs<TFilteredValue, TParams$1, TAsync$1, TMetadata$1> & {
-  (...params: RegleUniversalParams<TParams$1>): RegleRuleDefinition<TType$1, TFilteredValue, TParams$1, TAsync$1, TMetadata$1, TInput>;
-} & (TParams$1 extends [param?: any, ...any[]] ? {
-  exec: (value: Maybe<TFilteredValue>) => TAsync$1 extends false ? TMetadata$1 : Promise<TMetadata$1>;
+type RegleRuleWithParamsDefinition<TType extends string | unknown = unknown, TValue extends unknown = unknown, TParams extends any[] = never, TAsync extends boolean = false, TMetadata extends RegleRuleMetadataDefinition = boolean, TInput = unknown, TFilteredValue extends any = (TValue extends Date & File & (infer M) ? M : TValue)> = RegleRuleCore<TType, TFilteredValue, TParams, TAsync, TMetadata> & RegleInternalRuleDefs<TFilteredValue, TParams, TAsync, TMetadata> & {
+  (...params: RegleUniversalParams<TParams>): RegleRuleDefinition<TType, TFilteredValue, TParams, TAsync, TMetadata, TInput>;
+} & (TParams extends [param?: any, ...any[]] ? {
+  exec: (value: Maybe<TFilteredValue>) => TAsync extends false ? TMetadata : Promise<TMetadata>;
 } : {});
-type RegleRuleWithParamsDefinitionInput<TType$1 extends string | unknown = unknown, TValue$1 extends any = any, TParams$1 extends any[] = never, TAsync$1 extends boolean = false, TMetadata$1 extends RegleRuleMetadataDefinition = boolean, TFilteredValue extends any = (TValue$1 extends Date & File & (infer M) ? M : TValue$1)> = RegleRuleCore<TType$1, TFilteredValue, TParams$1, TAsync$1, TMetadata$1> & RegleInternalRuleDefs<TFilteredValue, TParams$1, TAsync$1, TMetadata$1> & (TParams$1 extends [param?: any, ...any[]] ? {
-  exec: (value: Maybe<TFilteredValue>) => TAsync$1 extends false ? TMetadata$1 : Promise<TMetadata$1>;
+type RegleRuleWithParamsDefinitionInput<TType extends string | unknown = unknown, TValue extends any = any, TParams extends any[] = never, TAsync extends boolean = false, TMetadata extends RegleRuleMetadataDefinition = boolean, TFilteredValue extends any = (TValue extends Date & File & (infer M) ? M : TValue)> = RegleRuleCore<TType, TFilteredValue, TParams, TAsync, TMetadata> & RegleInternalRuleDefs<TFilteredValue, TParams, TAsync, TMetadata> & (TParams extends [param?: any, ...any[]] ? {
+  exec: (value: Maybe<TFilteredValue>) => TAsync extends false ? TMetadata : Promise<TMetadata>;
 } : {});
 type RegleRuleMetadataExtended = {
   $valid: boolean;
@@ -898,24 +969,24 @@ type DefaultMetadataProperties = DefaultMetadataPropertiesCommon & {
 /**
  * Will be used to consume metadata on related helpers and rule status
  */
-type RegleRuleMetadataConsumer<TValue$1 extends any, TParams$1 extends [...any[]] = never, TMetadata$1 extends RegleRuleMetadataDefinition = boolean> = {
-  $value: Maybe<TValue$1>;
-} & DefaultMetadataProperties & (TParams$1 extends never ? {} : {
-  $params: [...TParams$1];
-}) & (Exclude<TMetadata$1, boolean> extends RegleRuleMetadataExtended ? TMetadata$1 extends boolean ? Partial<Omit<Exclude<TMetadata$1, boolean>, '$valid'>> : Omit<Exclude<TMetadata$1, boolean>, '$valid'> : {});
+type RegleRuleMetadataConsumer<TValue extends any, TParams extends [...any[]] = never, TMetadata extends RegleRuleMetadataDefinition = boolean> = {
+  $value: Maybe<TValue>;
+} & DefaultMetadataProperties & (TParams extends never ? {} : {
+  $params: [...TParams];
+}) & (Exclude<TMetadata, boolean> extends RegleRuleMetadataExtended ? TMetadata extends boolean ? Partial<Omit<Exclude<TMetadata, boolean>, '$valid'>> : Omit<Exclude<TMetadata, boolean>, '$valid'> : {});
 /**
  * Will be used to consume metadata on related helpers and rule status
  */
-type PossibleRegleRuleMetadataConsumer<TValue$1> = {
-  $value: Maybe<TValue$1>;
+type PossibleRegleRuleMetadataConsumer<TValue> = {
+  $value: Maybe<TValue>;
 } & DefaultMetadataProperties & {
   $params?: [...any[]];
 };
 /**
  * Generic types for a created RegleRule
  */
-type RegleRuleRaw<TType$1 extends string | unknown = unknown, TValue$1 extends any = any, TParams$1 extends [...any[]] = [...any[]], TAsync$1 extends boolean = boolean, TMetaData extends RegleRuleMetadataDefinition = boolean> = RegleRuleDefinition<TType$1, TValue$1, TParams$1, TAsync$1, TMetaData> | RegleRuleWithParamsDefinition<TType$1, TValue$1, TParams$1, TAsync$1, TMetaData>;
-type RegleRuleRawInput<TValue$1 extends any = any, TParams$1 extends [...any[]] = [...any[]], TAsync$1 extends boolean = boolean, TMetaData extends RegleRuleMetadataDefinition = boolean> = Omit<RegleRuleDefinition<unknown, TValue$1, TParams$1, TAsync$1, TMetaData> | RegleRuleWithParamsDefinition<unknown, TValue$1, TParams$1, TAsync$1, TMetaData>, 'message' | 'tooltip' | 'active'> & {
+type RegleRuleRaw<TType extends string | unknown = unknown, TValue extends any = any, TParams extends [...any[]] = [...any[]], TAsync extends boolean = boolean, TMetaData extends RegleRuleMetadataDefinition = boolean> = RegleRuleDefinition<TType, TValue, TParams, TAsync, TMetaData> | RegleRuleWithParamsDefinition<TType, TValue, TParams, TAsync, TMetaData>;
+type RegleRuleRawInput<TValue extends any = any, TParams extends [...any[]] = [...any[]], TAsync extends boolean = boolean, TMetaData extends RegleRuleMetadataDefinition = boolean> = Omit<RegleRuleDefinition<unknown, TValue, TParams, TAsync, TMetaData> | RegleRuleWithParamsDefinition<unknown, TValue, TParams, TAsync, TMetaData>, 'message' | 'tooltip' | 'active'> & {
   message: any;
   active?: any;
   tooltip?: any;
@@ -925,43 +996,43 @@ type RegleRuleRawInput<TValue$1 extends any = any, TParams$1 extends [...any[]]
  * For a rule with params it will return a function
  * Otherwise it will return the rule definition
  */
-type InferRegleRule<TType$1 extends string | unknown, TValue$1 extends any = any, TParams$1 extends any[] = [], TAsync$1 extends boolean = false, TMetaData extends RegleRuleMetadataDefinition = boolean, TNonEmpty extends boolean = false> = [TParams$1] extends [[]] ? RegleRuleDefinition<TType$1, TValue$1, TParams$1, TAsync$1, TMetaData, TValue$1, TValue$1, TNonEmpty> : RegleRuleWithParamsDefinition<TType$1, TValue$1, TParams$1, TAsync$1, TMetaData, TNonEmpty>;
-type RegleRuleDefinitionProcessor<TValue$1 extends any = any, TParams$1 extends any[] = [], TReturn = any> = (value: Maybe<TValue$1>, ...params: TParams$1) => TReturn;
-type RegleRuleDefinitionWithMetadataProcessor<TValue$1 extends any, TMetadata$1 extends RegleRuleMetadataConsumer<TValue$1, any[]>, TReturn = any> = ((metadata: TMetadata$1) => TReturn) | TReturn;
-type RegleCollectionRuleDefinition<TValue$1 = any[], TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>> = (RegleRuleDecl<NonNullable<TValue$1>, TCustomRules, CollectionRegleBehaviourOptions> & {
-  $each: MaybeGetter<RegleFormPropertyType<ArrayElement<NonNullable<TValue$1>>, TCustomRules>, ArrayElement<TValue$1>>;
+type InferRegleRule<TType extends string | unknown, TValue extends any = any, TParams extends any[] = [], TAsync extends boolean = false, TMetaData extends RegleRuleMetadataDefinition = boolean, TNonEmpty extends boolean = false> = [TParams] extends [[]] ? RegleRuleDefinition<TType, TValue, TParams, TAsync, TMetaData, TValue, TValue, TNonEmpty> : RegleRuleWithParamsDefinition<TType, TValue, TParams, TAsync, TMetaData, TNonEmpty>;
+type RegleRuleDefinitionProcessor<TValue extends any = any, TParams extends any[] = [], TReturn = any> = (value: Maybe<TValue>, ...params: TParams) => TReturn;
+type RegleRuleDefinitionWithMetadataProcessor<TValue extends any, TMetadata extends RegleRuleMetadataConsumer<TValue, any[]>, TReturn = any> = ((metadata: TMetadata) => TReturn) | TReturn;
+type RegleCollectionRuleDefinition<TValue = any[], TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>> = (RegleRuleDecl<NonNullable<TValue>, TCustomRules, CollectionRegleBehaviourOptions> & {
+  $each: MaybeGetter<RegleFormPropertyType<ArrayElement<NonNullable<TValue>>, TCustomRules>, ArrayElement<TValue>>;
 }) | ({
-  $each: MaybeGetter<RegleFormPropertyType<ArrayElement<NonNullable<TValue$1>>, TCustomRules>, ArrayElement<TValue$1>>;
+  $each: MaybeGetter<RegleFormPropertyType<ArrayElement<NonNullable<TValue>>, TCustomRules>, ArrayElement<TValue>>;
 } & CollectionRegleBehaviourOptions);
-type RegleInitPropertyGetter<TValue$1, TReturn, TParams$1 extends [...any[]], TMetadata$1 extends RegleRuleMetadataDefinition> = TReturn | ((metadata: RegleRuleMetadataConsumer<TValue$1, TParams$1, TMetadata$1>) => TReturn);
+type RegleInitPropertyGetter<TValue, TReturn, TParams extends [...any[]], TMetadata extends RegleRuleMetadataDefinition> = TReturn | ((metadata: RegleRuleMetadataConsumer<TValue, TParams, TMetadata>) => TReturn);
 /**
  * @argument
  * createRule arguments options
  */
-interface RegleRuleInit<TType$1 extends string | unknown = unknown, TValue$1 extends unknown = unknown, TParams$1 extends [...any[]] = [], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = boolean, TMetadata$1 extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, TAsync$1 extends boolean = (TReturn extends Promise<any> ? true : false), TNonEmpty extends boolean = false> {
-  validator: (value: Maybe<TValue$1>, ...args: TParams$1) => TReturn;
-  message: RegleInitPropertyGetter<TValue$1, string | string[], TParams$1, TMetadata$1>;
-  active?: RegleInitPropertyGetter<TValue$1, boolean, TParams$1, TMetadata$1>;
-  tooltip?: RegleInitPropertyGetter<TValue$1, string | string[], TParams$1, TMetadata$1>;
-  type?: TType$1;
-  async?: TAsync$1;
+interface RegleRuleInit<TType extends string | unknown = unknown, TValue extends unknown = unknown, TParams extends [...any[]] = [], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = boolean, TMetadata extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, TAsync extends boolean = (TReturn extends Promise<any> ? true : false), TNonEmpty extends boolean = false> {
+  validator: (value: Maybe<TValue>, ...args: TParams) => TReturn;
+  message: RegleInitPropertyGetter<TValue, string | string[], TParams, TMetadata>;
+  active?: RegleInitPropertyGetter<TValue, boolean, TParams, TMetadata>;
+  tooltip?: RegleInitPropertyGetter<TValue, string | string[], TParams, TMetadata>;
+  type?: TType;
+  async?: TAsync;
   required?: TNonEmpty;
 }
 /**
  * @argument
  * Rule core
  */
-interface RegleRuleCore<TType$1 extends string | unknown, TValue$1 extends any, TParams$1 extends any[] = [], TAsync$1 extends boolean = false, TMetadata$1 extends RegleRuleMetadataDefinition = boolean> {
-  validator: (value: Maybe<TValue$1>, ...args: TParams$1) => TAsync$1 extends false ? TMetadata$1 : Promise<TMetadata$1>;
-  message: RegleInitPropertyGetter<TValue$1, string | string[], TParams$1, TMetadata$1>;
-  active?: RegleInitPropertyGetter<TValue$1, string | string[], TParams$1, TMetadata$1>;
-  tooltip?: RegleInitPropertyGetter<TValue$1, string | string[], TParams$1, TMetadata$1>;
-  type?: TType$1;
+interface RegleRuleCore<TType extends string | unknown, TValue extends any, TParams extends any[] = [], TAsync extends boolean = false, TMetadata extends RegleRuleMetadataDefinition = boolean> {
+  validator: (value: Maybe<TValue>, ...args: TParams) => TAsync extends false ? TMetadata : Promise<TMetadata>;
+  message: RegleInitPropertyGetter<TValue, string | string[], TParams, TMetadata>;
+  active?: RegleInitPropertyGetter<TValue, string | string[], TParams, TMetadata>;
+  tooltip?: RegleInitPropertyGetter<TValue, string | string[], TParams, TMetadata>;
+  type?: TType;
   async?: boolean;
 }
-type RegleRuleTypeReturn<TValue$1, TParams$1 extends [...any[]]> = {
-  value: TValue$1;
-  params: [...TParams$1];
+type RegleRuleTypeReturn<TValue, TParams extends [...any[]]> = {
+  value: TValue;
+  params: [...TParams];
 };
 interface CommonComparisonOptions {
   /**
@@ -1041,40 +1112,35 @@ type AllRulesDeclarations = ExtendedRulesDeclarations;
 /**
  * @public
  */
-type RegleRoot<TState$1 extends object | Record<string, unknown> = {}, TRules$1 extends ReglePartialRuleTree<TState$1> = Record<string, any>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = never, TShortcuts extends RegleShortcutDefinition = {}> = MaybeVariantStatus<TState$1, TRules$1, TShortcuts> & ([TValidationGroups] extends [never] ? {} : {
+type RegleRoot<TState extends object | Record<string, unknown> = {}, TRules extends ReglePartialRuleTree<TState> = Record<string, any>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = never, TShortcuts extends RegleShortcutDefinition = {}> = MaybeVariantStatus<TState, TRules, TShortcuts> & ([TValidationGroups] extends [never] ? {} : {
   /**
    * Collection of validation groups used declared with the `validationGroups` modifier
    */
   $groups: { readonly [TKey in keyof TValidationGroups]: RegleValidationGroupOutput };
 });
-type ProcessNestedFields<TState$1 extends Record<string, any> | undefined, TRules$1 extends ReglePartialRuleTree<NonNullable<TState$1>>, TShortcuts extends RegleShortcutDefinition = {}, TIsFields extends boolean = false> = Or<HasNamedKeys<TState$1>, TIsFields> extends true ? { readonly [TKey in keyof TState$1 as TRules$1[TKey] extends NonNullable<TRules$1[TKey]> ? NonNullable<TRules$1[TKey]> extends MaybeRef<RegleRuleDecl> ? IsEmptyObject<TRules$1[TKey]> extends true ? TKey : never : never : TKey]: IsUnion<NonNullable<TRules$1[TKey]>> extends true ? ExtendOnlyRealRecord<TState$1[TKey]> extends true ? MaybeVariantStatus<NonNullable<TState$1>[TKey], NonNullable<TRules$1[TKey]>, TShortcuts> : InferRegleStatusType<NonNullable<TRules$1[TKey]>, NonNullable<TState$1>, TKey, TShortcuts> : InferRegleStatusType<NonNullable<TRules$1[TKey]>, NonNullable<TState$1>, TKey, TShortcuts> } & { readonly [TKey in keyof TState$1 as TRules$1[TKey] extends NonNullable<TRules$1[TKey]> ? NonNullable<TRules$1[TKey]> extends MaybeRef<RegleRuleDecl> ? IsEmptyObject<TRules$1[TKey]> extends true ? never : TKey : TKey : never]-?: IsUnion<NonNullable<TRules$1[TKey]>> extends true ? ExtendOnlyRealRecord<TState$1[TKey]> extends true ? MaybeVariantStatus<NonNullable<TState$1>[TKey], NonNullable<TRules$1[TKey]>, TShortcuts> : InferRegleStatusType<NonNullable<TRules$1[TKey]>, NonNullable<TState$1>, TKey, TShortcuts> : InferRegleStatusType<NonNullable<TRules$1[TKey]>, NonNullable<TState$1>, TKey, TShortcuts> } : {};
+type ProcessNestedFields<TState extends Record<string, any> | undefined, TRules extends ReglePartialRuleTree<NonNullable<TState>>, TShortcuts extends RegleShortcutDefinition = {}, TIsFields extends boolean = false> = Or<HasNamedKeys<TState>, TIsFields> extends true ? { readonly [TKey in keyof TState as TRules[TKey] extends NonNullable<TRules[TKey]> ? NonNullable<TRules[TKey]> extends MaybeRef<RegleRuleDecl> ? IsEmptyObject<TRules[TKey]> extends true ? TKey : never : never : TKey]: IsUnion<NonNullable<TRules[TKey]>> extends true ? ExtendOnlyRealRecord<TState[TKey]> extends true ? MaybeVariantStatus<NonNullable<TState>[TKey], NonNullable<TRules[TKey]>, TShortcuts> : InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts> : InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts> } & { readonly [TKey in keyof TState as TRules[TKey] extends NonNullable<TRules[TKey]> ? NonNullable<TRules[TKey]> extends MaybeRef<RegleRuleDecl> ? IsEmptyObject<TRules[TKey]> extends true ? never : TKey : TKey : never]-?: IsUnion<NonNullable<TRules[TKey]>> extends true ? ExtendOnlyRealRecord<TState[TKey]> extends true ? MaybeVariantStatus<NonNullable<TState>[TKey], NonNullable<TRules[TKey]>, TShortcuts> : InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts> : InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts> } : {};
 /**
  * @public
  */
-type RegleStatus<TState$1 extends object | Record<string, any> | undefined = Record<string, any>, TRules$1 extends ReglePartialRuleTree<NonNullable<TState$1>> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = {}> = RegleCommonStatus<TState$1, TRules$1> & {
-  /** Represents all the children of your object. You can access any nested child at any depth to get the relevant data you need for your form. */
-  readonly $fields: ProcessNestedFields<TState$1, TRules$1, TShortcuts, true>;
+type RegleStatus<TState extends object | Record<string, any> | undefined = Record<string, any>, TRules extends ReglePartialRuleTree<NonNullable<TState>> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = {}> = RegleCommonStatus<TState, TRules> & {
+  /** Represents all the children of your object. You can access any nested child at any depth to get the relevant data you need for your form. */readonly $fields: ProcessNestedFields<TState, TRules, TShortcuts, true>;
   /**
    * Collection of all the issues, collected for all children properties and nested forms.
    *
    * Only contains issues from properties where $dirty equals true.
    */
-  readonly $issues: RegleIssuesTree<TState$1>;
+  readonly $issues: RegleIssuesTree<TState, false, TRules>;
   /**
    * Collection of all the error messages, collected for all children properties and nested forms.
    *
    * Only contains errors from properties where $dirty equals true.
    * */
-  readonly $errors: RegleErrorTree<TState$1>;
-  /** Collection of all the error messages, collected for all children properties. */
-  readonly $silentErrors: RegleErrorTree<TState$1>;
-  /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
-  $extractDirtyFields: (filterNullishValues?: boolean) => DeepPartial<TState$1>;
-  /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
-  $validate: (forceValues?: JoinDiscriminatedUnions<TState$1> extends EmptyObject ? any : HasNamedKeys<JoinDiscriminatedUnions<TState$1>> extends true ? IsUnknown<JoinDiscriminatedUnions<TState$1>> extends true ? any : JoinDiscriminatedUnions<TState$1> : any) => Promise<RegleResult<JoinDiscriminatedUnions<TState$1>, TRules$1>>;
-} & ProcessNestedFields<TState$1, TRules$1, TShortcuts> & ([TShortcuts['nested']] extends [never] ? {} : { [K in keyof TShortcuts['nested']]: ReturnType<NonNullable<TShortcuts['nested']>[K]> }) & (TRules$1['$self'] extends RegleRuleDecl ? {
-  /** Represents the status of the parent object. Status only concern the object itself and not its children */
-  readonly $self: RegleFieldStatus<NonNullable<TRules$1['$self']>, NonNullable<TRules$1['$self']>, TShortcuts>;
+  readonly $errors: RegleErrorTree<TState, false>; /** Collection of all the error messages, collected for all children properties. */
+  readonly $silentErrors: RegleErrorTree<TState>; /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
+  $extractDirtyFields: (filterNullishValues?: boolean) => DeepPartial<TState>; /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
+  $validate: (forceValues?: JoinDiscriminatedUnions<TState> extends EmptyObject ? any : HasNamedKeys<JoinDiscriminatedUnions<TState>> extends true ? IsUnknown<JoinDiscriminatedUnions<TState>> extends true ? any : JoinDiscriminatedUnions<TState> : any) => Promise<RegleResult<JoinDiscriminatedUnions<TState>, TRules>>;
+} & ProcessNestedFields<TState, TRules, TShortcuts> & ([TShortcuts['nested']] extends [never] ? {} : { [K in keyof TShortcuts['nested']]: ReturnType<NonNullable<TShortcuts['nested']>[K]> }) & (TRules['$self'] extends RegleRuleDecl ? {
+  /** Represents the status of the parent object. Status only concern the object itself and not its children */readonly $self: RegleFieldStatus<NonNullable<TRules['$self']>, NonNullable<TRules['$self']>, TShortcuts>;
 } : {});
 /**
  * @internal
@@ -1096,75 +1162,46 @@ interface $InternalRegleStatus extends $InternalRegleCommonStatus {
 /**
  * @public
  */
-type InferRegleStatusType<TRule extends RegleCollectionRuleDecl | RegleRuleDecl | ReglePartialRuleTree<any>, TState$1 extends Record<PropertyKey, any> = any, TKey$1 extends PropertyKey = string, TShortcuts extends RegleShortcutDefinition = {}> = HasNamedKeys<TState$1> extends true ? [TState$1[TKey$1]] extends [undefined | null] ? RegleFieldStatus<TState$1[TKey$1], TRule, TShortcuts> : NonNullable<TState$1[TKey$1]> extends Array<infer U extends Record<string, any>> ? U extends Record<string, any> ? TRule extends RegleCollectionRuleDefinition<any, any> ? ExtractFromGetter<TRule['$each']> extends ReglePartialRuleTree<any> ? RegleCollectionStatus<TState$1[TKey$1], ExtractFromGetter<TRule['$each']>, TRule, TShortcuts> : RegleFieldStatus<TState$1[TKey$1], TRule, TShortcuts> : RegleCollectionStatus<TState$1[TKey$1], {}, TRule, TShortcuts> : RegleFieldStatus<TState$1[TKey$1], TRule, TShortcuts> : TRule extends ReglePartialRuleTree<any> ? NonNullable<TState$1[TKey$1]> extends Array<any> ? RegleFieldStatus<TState$1[TKey$1], TRule, TShortcuts> : NonNullable<TState$1[TKey$1]> extends Date | File ? RegleFieldStatus<Raw<TState$1[TKey$1]>, TRule, TShortcuts> : unknown extends TState$1[TKey$1] ? RegleFieldStatus<TState$1[TKey$1], TRule, TShortcuts> : NonNullable<TState$1[TKey$1]> extends Record<PropertyKey, any> ? NonNullable<TState$1[TKey$1]> extends RegleStaticImpl<infer U> ? RegleFieldStatus<Raw<U>, TRule, TShortcuts> : TRule extends ReglePartialRuleTree<TState$1[TKey$1]> ? MaybeVariantStatus<TState$1[TKey$1], TRule, TShortcuts> : MaybeVariantStatus<TState$1[TKey$1], {}, TShortcuts> : RegleFieldStatus<TState$1[TKey$1], TRule, TShortcuts> : NonNullable<TState$1[TKey$1]> extends Date | File ? RegleFieldStatus<Raw<NonNullable<TState$1[TKey$1]>>, TRule, TShortcuts> : unknown extends TState$1[TKey$1] ? RegleFieldStatus<TState$1[TKey$1], TRule, TShortcuts> : NonNullable<TState$1[TKey$1]> extends Record<PropertyKey, any> ? NonNullable<TState$1[TKey$1]> extends RegleStaticImpl<infer U> ? RegleFieldStatus<Raw<U>, TRule, TShortcuts> : MaybeVariantStatus<TState$1[TKey$1], ReglePartialRuleTree<TState$1[TKey$1]>, TShortcuts> : RegleFieldStatus<TState$1[TKey$1], TRule, TShortcuts> : RegleCommonStatus<unknown>;
+type InferRegleStatusType<TRule extends RegleCollectionRuleDecl | RegleRuleDecl | ReglePartialRuleTree<any>, TState extends Record<PropertyKey, any> = any, TKey extends PropertyKey = string, TShortcuts extends RegleShortcutDefinition = {}> = HasNamedKeys<TState> extends true ? [TState[TKey]] extends [undefined | null] ? RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Array<unknown> ? TRule extends RegleCollectionRuleDefinition<any, any> ? ExtractFromGetter<TRule['$each']> extends ReglePartialRuleTree<any> ? RegleCollectionStatus<TState[TKey], ExtractFromGetter<TRule['$each']>, TRule, TShortcuts> : RegleFieldStatus<TState[TKey], TRule, TShortcuts> : RegleCollectionStatus<TState[TKey], {}, TRule, TShortcuts> : TRule extends ReglePartialRuleTree<any> ? NonNullable<TState[TKey]> extends Array<any> ? RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Date | File ? RegleFieldStatus<Raw<TState[TKey]>, TRule, TShortcuts> : unknown extends TState[TKey] ? RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Record<PropertyKey, any> ? NonNullable<TState[TKey]> extends RegleStaticImpl<infer U> ? RegleFieldStatus<Raw<U>, TRule, TShortcuts> : TRule extends ReglePartialRuleTree<TState[TKey]> ? MaybeVariantStatus<TState[TKey], TRule, TShortcuts> : MaybeVariantStatus<TState[TKey], {}, TShortcuts> : RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Date | File ? RegleFieldStatus<Raw<NonNullable<TState[TKey]>>, TRule, TShortcuts> : unknown extends TState[TKey] ? RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Record<PropertyKey, any> ? NonNullable<TState[TKey]> extends RegleStaticImpl<infer U> ? RegleFieldStatus<Raw<U>, TRule, TShortcuts> : MaybeVariantStatus<TState[TKey], ReglePartialRuleTree<TState[TKey]>, TShortcuts> : RegleFieldStatus<TState[TKey], TRule, TShortcuts> : RegleCommonStatus<unknown>;
 /**
  * @internal
  * @reference {@link InferRegleStatusType}
  */
 type $InternalRegleStatusType = $InternalRegleCollectionStatus | $InternalRegleStatus | $InternalRegleFieldStatus;
-type RegleFieldIssue<TRules$1 extends RegleFormPropertyType<unknown, Partial<ExtendedRulesDeclarations>> = EmptyObject> = {
-  readonly $property: string;
-  readonly $type?: string;
-  readonly $message: string;
-} & (IsEmptyObject<TRules$1> extends true ? {
-  readonly $rule: string;
-} : { [K in keyof ComputeFieldRules<any, TRules$1>]: ComputeFieldRules<any, TRules$1>[K] extends {
-  $metadata: infer TMetadata;
-} ? K extends string ? {
-  readonly $rule: K;
-} & (TMetadata extends boolean ? {
-  readonly $rule: string;
-} : TMetadata) : {
-  readonly $rule: string;
-} : {
-  readonly $rule: string;
-} }[keyof ComputeFieldRules<any, TRules$1>]);
-type ComputeFieldRules<TState$1 extends any, TRules$1 extends MaybeRef<RegleFormPropertyType<unknown, Partial<ExtendedRulesDeclarations>>>> = IsEmptyObject<UnwrapRef<TRules$1>> extends true ? {
-  readonly [x: string]: RegleRuleStatus<TState$1, any[], any>;
-} : { readonly [TRuleKey in keyof Omit<UnwrapRef<TRules$1>, '$each' | keyof FieldRegleBehaviourOptions>]: RegleRuleStatus<TState$1, UnwrapRef<TRules$1>[TRuleKey] extends RegleRuleDefinition<unknown, any, infer TParams, any> ? TParams : [], UnwrapRef<TRules$1>[TRuleKey] extends RegleRuleDefinition<unknown, any, any, any, infer TMetadata> ? TMetadata : UnwrapRef<TRules$1>[TRuleKey] extends InlineRuleDeclaration<any, any[], infer TMetadata> ? TMetadata extends Promise<infer P> ? P : TMetadata : boolean> };
 /**
  * @public
  */
-type RegleFieldStatus<TState$1 extends any = any, TRules$1 extends RegleFormPropertyType<any, Partial<ExtendedRulesDeclarations>> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = never> = Omit<RegleCommonStatus<TState$1, TRules$1>, '$value' | '$silentValue' | '$initialValue' | '$originalValue'> & {
-  /** A reference to the original validated model. It can be used to bind your form with v-model.*/
-  $value: MaybeOutput<UnwrapNestedRefs<TState$1>>;
-  /** $value variant that will not "touch" the field and update the value silently, running only the rules, so you can easily swap values without impacting user interaction. */
-  $silentValue: MaybeOutput<UnwrapNestedRefs<TState$1>>;
+type RegleFieldStatus<TState extends any = any, TRules extends RegleFormPropertyType<any, Partial<ExtendedRulesDeclarations>> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = never> = Omit<RegleCommonStatus<TState, TRules>, '$value' | '$silentValue' | '$initialValue' | '$originalValue'> & {
+  /** A reference to the original validated model. It can be used to bind your form with v-model.*/$value: MaybeOutput<UnwrapNestedRefs<TState>>; /** $value variant that will not "touch" the field and update the value silently, running only the rules, so you can easily swap values without impacting user interaction. */
+  $silentValue: MaybeOutput<UnwrapNestedRefs<TState>>;
   /**
    * This value reflect the current initial value of the field.
    * The initial value is different than the original value as the initial value can be mutated when using `$reset`.
    */
-  readonly $initialValue: MaybeOutput<UnwrapNestedRefs<TState$1>>;
+  readonly $initialValue: MaybeOutput<UnwrapNestedRefs<TState>>;
   /**
    * This value reflect the original value of the field at original call. This can't be mutated
    */
-  readonly $originalValue: MaybeOutput<UnwrapNestedRefs<TState$1>>;
+  readonly $originalValue: MaybeOutput<UnwrapNestedRefs<TState>>;
   /** Collection of all the error messages, collected for all children properties and nested forms.
    *
    * Only contains errors from properties where $dirty equals true. */
-  readonly $errors: string[];
-  /** Collection of all the error messages, collected for all children properties and nested forms.  */
+  readonly $errors: string[]; /** Collection of all the error messages, collected for all children properties and nested forms.  */
   readonly $silentErrors: string[];
   /**
    * Collect all metadata of validators, Only contains metadata from properties where $dirty equals true.
    */
-  readonly $issues: RegleFieldIssue<TRules$1>[];
+  readonly $issues: RegleFieldIssue<TRules>[];
   /**
    * Collect all metadata of validators, including the error message.
    */
-  readonly $silentIssues: RegleFieldIssue<TRules$1>[];
-  /** Stores external errors of the current field */
-  readonly $externalErrors: string[];
-  /** Stores active tooltips messages of the current field */
-  readonly $tooltips: string[];
-  /** Represents the inactive status. Is true when this state have empty rules */
-  readonly $inactive: boolean;
-  /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
-  $extractDirtyFields: (filterNullishValues?: boolean) => MaybeOutput<TState$1>;
-  /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
-  $validate: (forceValues?: IsUnknown<TState$1> extends true ? any : TState$1) => Promise<RegleFieldResult<TState$1, TRules$1>>;
-  /** This is reactive tree containing all the declared rules of your field. To know more about the rule properties check the rules properties section */
-  readonly $rules: ComputeFieldRules<TState$1, TRules$1>;
+  readonly $silentIssues: RegleFieldIssue<TRules>[]; /** Stores external errors of the current field */
+  readonly $externalErrors: string[]; /** Stores active tooltips messages of the current field */
+  readonly $tooltips: string[]; /** Represents the inactive status. Is true when this state have empty rules */
+  readonly $inactive: boolean; /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
+  $extractDirtyFields: (filterNullishValues?: boolean) => MaybeOutput<TState>; /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
+  $validate: (forceValues?: IsUnknown<TState> extends true ? any : TState) => Promise<RegleFieldResult<TState, TRules>>; /** This is reactive tree containing all the declared rules of your field. To know more about the rule properties check the rules properties section */
+  readonly $rules: ComputeFieldRules<TState, TRules>;
 } & ([TShortcuts['fields']] extends [never] ? {} : { [K in keyof TShortcuts['fields']]: ReturnType<NonNullable<TShortcuts['fields']>[K]> });
 /**
  * @internal
@@ -1189,7 +1226,7 @@ interface $InternalRegleFieldStatus extends $InternalRegleCommonStatus {
 /**
  * @public
  */
-interface RegleCommonStatus<TValue$1 = any, TRules$1 extends Record<string, any> = never> extends StandardSchemaV1<TValue$1, [TRules$1] extends [never] ? TValue$1 : InferOutput<TRules$1, TValue$1>> {
+interface RegleCommonStatus<TValue = any, TRules extends Record<string, any> = never> extends StandardSchemaV1<TValue, [TRules] extends [never] ? TValue : InferOutput<TRules, TValue>> {
   /** Indicates whether the field is invalid. It becomes true if any associated rules return false. */
   readonly $invalid: boolean;
   /**
@@ -1225,20 +1262,20 @@ interface RegleCommonStatus<TValue$1 = any, TRules$1 extends Record<string, any>
   /** Id used to track collections items */
   $id?: string;
   /** A reference to the original validated model. It can be used to bind your form with v-model.*/
-  $value: JoinDiscriminatedUnions<UnwrapNestedRefs<TValue$1>>;
+  $value: JoinDiscriminatedUnions<UnwrapNestedRefs<TValue>>;
   /**
    * `$value` variant that will not "touch" the field and update the value silently, running only the rules, so you can easily swap values without impacting user interaction.
    * */
-  $silentValue: JoinDiscriminatedUnions<UnwrapNestedRefs<TValue$1>>;
+  $silentValue: JoinDiscriminatedUnions<UnwrapNestedRefs<TValue>>;
   /**
    * This value reflect the current initial value of the field.
    * The initial value is different than the original value as the initial value can be mutated when using `$reset`.
    */
-  readonly $initialValue: JoinDiscriminatedUnions<UnwrapNestedRefs<TValue$1>>;
+  readonly $initialValue: JoinDiscriminatedUnions<UnwrapNestedRefs<TValue>>;
   /**
    * This value reflect the original value of the field at original call. This can't be mutated
    */
-  readonly $originalValue: JoinDiscriminatedUnions<UnwrapNestedRefs<TValue$1>>;
+  readonly $originalValue: JoinDiscriminatedUnions<UnwrapNestedRefs<TValue>>;
   /** Marks the field and all nested properties as $dirty. */
   $touch(): void;
   /**
@@ -1247,7 +1284,7 @@ interface RegleCommonStatus<TValue$1 = any, TRules$1 extends Record<string, any>
    * Rerun rules if `$lazy` is false
    */
   $reset(): void;
-  $reset(options?: ResetOptions<TValue$1>): void;
+  $reset(options?: ResetOptions<TValue>): void;
   /** Clears the $externalErrors state back to an empty object. */
   $clearExternalErrors(): void;
 }
@@ -1261,35 +1298,22 @@ interface $InternalRegleCommonStatus extends Omit<RegleCommonStatus, '$touch' |
 /**
  * @public
  */
-type RegleRuleStatus<TValue$1 = any, TParams$1 extends any[] = any[], TMetadata$1 extends RegleRuleMetadataDefinition = boolean> = {
-  /** The name of the rule type. */
-  readonly $type: string;
-  /** Returns the computed error message or messages for the current rule. */
-  readonly $message: string | string[];
-  /** Stores the current rule tooltip or tooltips */
-  readonly $tooltip: string | string[];
-  /** Indicates whether or not the rule is enabled (for rules like requiredIf) */
-  readonly $active: boolean;
-  /** Indicates the state of validation for this validator. */
-  readonly $valid: boolean;
-  /** If the rule is async, indicates if it's currently pending. Always false if it's synchronous. */
-  readonly $pending: boolean;
-  /** Returns the current path of the rule (used internally for tracking) */
-  readonly $path: string;
-  /** Contains the metadata returned by the validator function. */
-  readonly $metadata: TMetadata$1 extends boolean ? TMetadata$1 : Omit<TMetadata$1, '$valid'>;
-  /** Run the rule validator and compute its properties like $message and $active */
-  $parse(): Promise<boolean>;
-  /** Reset the $valid, $metadata and $pending states */
-  $reset(): void;
-  /** Returns the original rule validator function. */
-  $validator: ((value: IsUnknown<TValue$1> extends true ? any : MaybeInput<TValue$1>, ...args: any[]) => RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>) & ((value: IsUnknown<TValue$1> extends true ? any : TValue$1, ...args: [TParams$1] extends [never[]] ? [] : [unknown[]] extends [TParams$1] ? any[] : TParams$1) => RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>);
-} & ([TParams$1] extends [never[]] ? {} : [unknown[]] extends [TParams$1] ? {
-  /** Contains the rule parameters when the rule accepts arguments. */
-  readonly $params?: any[];
+type RegleRuleStatus<TValue = any, TParams extends any[] = any[], TMetadata extends RegleRuleMetadataDefinition = boolean> = {
+  /** The name of the rule type. */readonly $type: string; /** Returns the computed error message or messages for the current rule. */
+  readonly $message: string | string[]; /** Stores the current rule tooltip or tooltips */
+  readonly $tooltip: string | string[]; /** Indicates whether or not the rule is enabled (for rules like requiredIf) */
+  readonly $active: boolean; /** Indicates the state of validation for this validator. */
+  readonly $valid: boolean; /** If the rule is async, indicates if it's currently pending. Always false if it's synchronous. */
+  readonly $pending: boolean; /** Returns the current path of the rule (used internally for tracking) */
+  readonly $path: string; /** Contains the metadata returned by the validator function. */
+  readonly $metadata: TMetadata extends boolean ? TMetadata : Omit<TMetadata, '$valid'>; /** Run the rule validator and compute its properties like $message and $active */
+  $parse(): Promise<boolean>; /** Reset the $valid, $metadata and $pending states */
+  $reset(): void; /** Returns the original rule validator function. */
+  $validator: ((value: IsUnknown<TValue> extends true ? any : MaybeInput<TValue>, ...args: any[]) => RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>) & ((value: IsUnknown<TValue> extends true ? any : TValue, ...args: [TParams] extends [never[]] ? [] : [unknown[]] extends [TParams] ? any[] : TParams) => RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>);
+} & ([TParams] extends [never[]] ? {} : [unknown[]] extends [TParams] ? {
+  /** Contains the rule parameters when the rule accepts arguments. */readonly $params?: any[];
 } : {
-  /** Contains the rule parameters when the rule accepts arguments. */
-  readonly $params: [...TParams$1];
+  /** Contains the rule parameters when the rule accepts arguments. */readonly $params: [...TParams];
 });
 /**
  * @internal
@@ -1323,31 +1347,24 @@ interface $InternalRegleRuleStatus {
 /**
  * @public
  */
-type RegleCollectionStatus<TState$1 extends any[] = any[], TRules$1 extends ReglePartialRuleTree<any> = Record<string, any>, TFieldRule extends RegleCollectionRuleDecl<any, any> = never, TShortcuts extends RegleShortcutDefinition = {}> = Omit<RegleCommonStatus<TState$1, TRules$1>, '$value'> & {
-  /** A reference to the original validated model. It can be used to bind your form with v-model.*/
-  $value: MaybeOutput<TState$1>;
-  /** $value variant that will not "touch" the field and update the value silently, running only the rules, so you can easily swap values without impacting user interaction. */
-  $silentValue: MaybeOutput<TState$1>;
-  /** Collection of status of every item in your collection. Each item will be a field you can access, or map on it to display your elements. */
-  readonly $each: Array<InferRegleStatusType<NonNullable<TRules$1>, NonNullable<TState$1>, number, TShortcuts>>;
-  /** Represents the status of the collection itself. You can have validation rules on the array like minLength, this field represents the isolated status of the collection. */
-  readonly $self: RegleFieldStatus<TState$1, TFieldRule, TShortcuts>;
+type RegleCollectionStatus<TState extends any[] = any[], TRules extends ReglePartialRuleTree<Record<string, any>> = Record<string, any>, TFieldRule extends RegleCollectionRuleDecl<any, any> = never, TShortcuts extends RegleShortcutDefinition = {}> = Omit<RegleCommonStatus<TState, TRules>, '$value'> & {
+  /** A reference to the original validated model. It can be used to bind your form with v-model.*/$value: MaybeOutput<TState>; /** $value variant that will not "touch" the field and update the value silently, running only the rules, so you can easily swap values without impacting user interaction. */
+  $silentValue: MaybeOutput<TState>; /** Collection of status of every item in your collection. Each item will be a field you can access, or map on it to display your elements. */
+  readonly $each: Array<InferRegleStatusType<NonNullable<TRules>, NonNullable<TState>, number, TShortcuts>>; /** Represents the status of the collection itself. You can have validation rules on the array like minLength, this field represents the isolated status of the collection. */
+  readonly $self: RegleFieldStatus<TState, TFieldRule, TShortcuts>;
   /**
    * Collection of all the issues, collected for all children properties and nested forms.
    *
    * Only contains issues from properties where $dirty equals true.
    */
-  readonly $issues: RegleCollectionErrors<TState$1, true>;
+  readonly $issues: RegleCollectionErrors<TState, true>;
   /** Collection of all the error messages, collected for all children properties and nested forms.
    *
    * Only contains errors from properties where $dirty equals true. */
-  readonly $errors: RegleCollectionErrors<TState$1>;
-  /** Collection of all the error messages, collected for all children properties and nested forms.  */
-  readonly $silentErrors: RegleCollectionErrors<TState$1>;
-  /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
-  $extractDirtyFields: (filterNullishValues?: boolean) => DeepPartial<TState$1>;
-  /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
-  $validate: (value?: JoinDiscriminatedUnions<TState$1>) => Promise<RegleCollectionResult<TState$1, JoinDiscriminatedUnions<TRules$1>>>;
+  readonly $errors: RegleCollectionErrors<TState>; /** Collection of all the error messages, collected for all children properties and nested forms.  */
+  readonly $silentErrors: RegleCollectionErrors<TState>; /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
+  $extractDirtyFields: (filterNullishValues?: boolean) => DeepPartial<TState>; /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
+  $validate: (value?: JoinDiscriminatedUnions<TState>) => Promise<RegleCollectionResult<TState, JoinDiscriminatedUnions<TRules>>>;
 } & ([TShortcuts['collections']] extends [never] ? {} : { [K in keyof TShortcuts['collections']]: ReturnType<NonNullable<TShortcuts['collections']>[K]> });
 /**
  * @internal
@@ -1385,7 +1402,7 @@ type RegleUnknownRulesTree = {
 /**
  * @public
  */
-type RegleComputedRules<TForm extends MaybeRefOrComputedRef<Record<string, any>> | DeepReactiveState<Record<string, any>>, TCustomRules extends Partial<ExtendedRulesDeclarations> | Regle<any, any> | useRegleFn<any> = Partial<ExtendedRulesDeclarations>, TState$1 = Unwrap<UnwrapMaybeRef<TForm>>, TCustom = (TCustomRules extends Regle<any, infer R> ? R extends ReglePartialRuleTree<any, infer C> ? C : Partial<ExtendedRulesDeclarations> : TCustomRules extends useRegleFn<infer Rules, any> ? Rules : {})> = { [TKey in keyof JoinDiscriminatedUnions<TState$1>]?: RegleFormPropertyType<JoinDiscriminatedUnions<TState$1>[TKey], Omit<Partial<ExtendedRulesDeclarations>, keyof TCustom> & Partial<TCustom>> };
+type RegleComputedRules<TForm extends MaybeRefOrComputedRef<Record<string, any>> | DeepReactiveState<Record<string, any>>, TCustomRules extends Partial<ExtendedRulesDeclarations> | Regle<any, any> | useRegleFn<any> = Partial<ExtendedRulesDeclarations>, TState = Unwrap<UnwrapMaybeRef<TForm>>, TCustom = (TCustomRules extends Regle<any, infer R> ? R extends ReglePartialRuleTree<any, infer C> ? C : Partial<ExtendedRulesDeclarations> : TCustomRules extends useRegleFn<infer Rules, any> ? Rules : {})> = { [TKey in keyof JoinDiscriminatedUnions<TState>]?: RegleFormPropertyType<JoinDiscriminatedUnions<TState>[TKey], Omit<Partial<ExtendedRulesDeclarations>, keyof TCustom> & Partial<TCustom>> };
 /**
  * @internal
  * @reference {@link ReglePartialRuleTree}
@@ -1398,7 +1415,7 @@ type $InternalReglePartialRuleTree = {
 /**
  * @public
  */
-type RegleFormPropertyType<TValue$1 = any, TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>> = [NonNullable<TValue$1>] extends [never] ? MaybeRefOrComputedRef<RegleRuleDecl<TValue$1, TCustomRules>> : NonNullable<TValue$1> extends Array<any> ? RegleCollectionRuleDecl<TValue$1, TCustomRules> : NonNullable<TValue$1> extends Date ? MaybeRefOrComputedRef<RegleRuleDecl<NonNullable<TValue$1>, TCustomRules>> : NonNullable<TValue$1> extends File ? MaybeRefOrComputedRef<RegleRuleDecl<NonNullable<TValue$1>, TCustomRules>> : NonNullable<TValue$1> extends Ref<infer V> ? RegleFormPropertyType<V, TCustomRules> : NonNullable<TValue$1> extends Record<string, any> ? NonNullable<TValue$1> extends RegleStatic<infer U> ? MaybeRefOrComputedRef<RegleRuleDecl<Raw<U>, TCustomRules>> : ReglePartialRuleTree<NonNullable<TValue$1>, TCustomRules> : MaybeRefOrComputedRef<RegleRuleDecl<NonNullable<TValue$1>, TCustomRules>>;
+type RegleFormPropertyType<TValue = any, TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>> = [NonNullable<TValue>] extends [never] ? MaybeRefOrComputedRef<RegleRuleDecl<TValue, TCustomRules>> : NonNullable<TValue> extends Array<any> ? RegleCollectionRuleDecl<TValue, TCustomRules> : NonNullable<TValue> extends Date ? MaybeRefOrComputedRef<RegleRuleDecl<NonNullable<TValue>, TCustomRules>> : NonNullable<TValue> extends File ? MaybeRefOrComputedRef<RegleRuleDecl<NonNullable<TValue>, TCustomRules>> : NonNullable<TValue> extends Ref<infer V> ? RegleFormPropertyType<V, TCustomRules> : NonNullable<TValue> extends Record<string, any> ? NonNullable<TValue> extends RegleStatic<infer U> ? MaybeRefOrComputedRef<RegleRuleDecl<Raw<U>, TCustomRules>> : ReglePartialRuleTree<NonNullable<TValue>, TCustomRules> : MaybeRefOrComputedRef<RegleRuleDecl<NonNullable<TValue>, TCustomRules>>;
 /**
  * @internal
  * @reference {@link RegleFormPropertyType}
@@ -1408,8 +1425,8 @@ type $InternalFormPropertyTypes = MaybeRefOrComputedRef<$InternalRegleRuleDecl>
  * @public
  * Rule tree for a form property
  */
-type RegleRuleDecl<TValue$1 extends any = any, TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<DefaultValidatorsTree>, TOptions extends Record<string, unknown> = FieldRegleBehaviourOptions<TValue$1>> = TOptions & { [TKey in keyof RemoveIndexSignature<TCustomRules>]?: FormRuleDeclaration<TValue$1, any[]> } & {
-  [x: string]: FormRuleDeclaration<TValue$1, any[]> | boolean | number | undefined;
+type RegleRuleDecl<TValue extends any = any, TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<DefaultValidatorsTree>, TOptions extends Record<string, unknown> = FieldRegleBehaviourOptions<TValue>> = TOptions & { [TKey in keyof RemoveIndexSignature<TCustomRules>]?: FormRuleDeclaration<TValue, any[]> } & {
+  [x: string]: FormRuleDeclaration<TValue, any[]> | boolean | number | undefined;
 };
 /**
  * @internal
@@ -1422,16 +1439,29 @@ type $InternalRegleRuleDecl = FieldRegleBehaviourOptions & CollectionRegleBehavi
 type RegleCollectionRuleDeclKeyProperty = {
   $key?: PropertyKey;
 };
+type CollectionEachRuleDecl<TValue = any[], TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>> = IsAny<TValue> extends true ? {
+  $each?: RegleCollectionEachRules<TValue, TCustomRules>;
+} : MaybeNullable<TValue> extends true ? {
+  /**
+   * Rules for each item in the collection
+   *
+   * ⚠️ `$each` is required here because your array is potentially undefined.
+   * Regle can't guess the type of the array if it's undefined.
+   * Having an empty `$each: {}` is the only way to tell Regle that the array is a collection.
+   */
+  $each: RegleCollectionEachRules<TValue, TCustomRules>;
+} : {
+  /**
+   * Rules for each item in the collection
+   */
+  $each?: RegleCollectionEachRules<TValue, TCustomRules>;
+};
 /**
  * @public
  */
-type RegleCollectionRuleDecl<TValue$1 = any[], TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>> = ({
-  $each?: RegleCollectionEachRules<TValue$1, TCustomRules>;
-} & RegleRuleDecl<NonNullable<TValue$1>, TCustomRules, CollectionRegleBehaviourOptions>) | ({
-  $each?: RegleCollectionEachRules<TValue$1, TCustomRules>;
-} & CollectionRegleBehaviourOptions);
+type RegleCollectionRuleDecl<TValue = any[], TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>> = (CollectionEachRuleDecl<TValue, TCustomRules> & RegleRuleDecl<NonNullable<TValue>, TCustomRules, CollectionRegleBehaviourOptions>) | (CollectionEachRuleDecl<TValue, TCustomRules> & CollectionRegleBehaviourOptions);
 /** @public */
-type RegleCollectionEachRules<TValue$1 = any[], TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>> = MaybeGetter<RegleFormPropertyType<ArrayElement<NonNullable<TValue$1>>, TCustomRules>, ArrayElement<TValue$1>, RegleCollectionRuleDeclKeyProperty, RegleFormPropertyType<ArrayElement<NonNullable<TValue$1>>, TCustomRules>>;
+type RegleCollectionEachRules<TValue = any[], TCustomRules extends Partial<ExtendedRulesDeclarations> = Partial<ExtendedRulesDeclarations>> = MaybeGetter<RegleFormPropertyType<ArrayElement<NonNullable<TValue>>, TCustomRules>, ArrayElement<TValue>, RegleCollectionRuleDeclKeyProperty, RegleFormPropertyType<ArrayElement<NonNullable<TValue>>, TCustomRules>>;
 /**
  * @internal
  * @reference {@link RegleCollectionRuleDecl}
@@ -1444,31 +1474,51 @@ type $InternalRegleCollectionRuleDecl = $InternalRegleRuleDecl & {
 /**
  * @public
  */
-type InlineRuleDeclaration<TValue$1 extends any = any, TParams$1 extends any[] = any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = boolean> = (value: Maybe<TValue$1>, ...args: UnwrapRegleUniversalParams<TParams$1>) => TReturn;
+type InlineRuleDeclaration<TValue extends any = any, TParams extends any[] = any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = boolean> = (value: Maybe<TValue>, ...args: UnwrapRegleUniversalParams<TParams>) => TReturn;
 /**
  * @public
  * Regroup inline and registered rules
  * */
-type FormRuleDeclaration<TValue$1 extends any = unknown, TParams$1 extends any[] = any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata$1 extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync$1 extends boolean = boolean> = InlineRuleDeclaration<TValue$1, TParams$1, TReturn> | RegleRuleDefinition<unknown, TValue$1, TParams$1, TAsync$1, TMetadata$1, any, any, boolean> | RegleRuleWithParamsDefinitionInput<unknown, TValue$1, [param?: any], TAsync$1, TMetadata$1> | RegleRuleWithParamsDefinitionInput<unknown, TValue$1, [param?: any, ...any[]], TAsync$1, TMetadata$1>;
-type RegleErrorTree<TState$1 = MaybeRef<Record<string, any> | any[]>, TIssue extends boolean = false, TSchema extends boolean = false> = { readonly [K in keyof JoinDiscriminatedUnions<UnwrapMaybeRef<TState$1>>]: RegleValidationErrors<JoinDiscriminatedUnions<UnwrapMaybeRef<TState$1>>[K], false, TIssue, TSchema> } & {
+type FormRuleDeclaration<TValue extends any = unknown, TParams extends any[] = any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync extends boolean = boolean> = InlineRuleDeclaration<TValue, TParams, TReturn> | RegleRuleDefinition<unknown, TValue, TParams, TAsync, TMetadata, any, any, boolean> | RegleRuleWithParamsDefinitionInput<unknown, TValue, [param?: any], TAsync, TMetadata> | RegleRuleWithParamsDefinitionInput<unknown, TValue, [param?: any, ...any[]], TAsync, TMetadata>;
+type RegleErrorTree<TState = MaybeRef<Record<string, any> | any[]>, TIssue extends boolean = false, TSchema extends boolean = false> = { readonly [K in keyof JoinDiscriminatedUnions<UnwrapMaybeRef<TState>>]: RegleValidationErrors<JoinDiscriminatedUnions<UnwrapMaybeRef<TState>>[K], false, TIssue, TSchema> } & {
   readonly $self?: string[];
 };
-type RegleIssuesTree<TState$1 = MaybeRef<Record<string, any> | any[]>, TSchema extends boolean = false> = { readonly [K in keyof JoinDiscriminatedUnions<UnwrapMaybeRef<TState$1>>]: RegleValidationErrors<JoinDiscriminatedUnions<UnwrapMaybeRef<TState$1>>[K], false, true, TSchema> } & {
+type RegleIssuesTree<TState = MaybeRef<Record<string, any> | any[]>, TSchema extends boolean = false, TRules extends ReglePartialRuleTree<NonNullable<TState>> = Record<string, any>> = { readonly [K in keyof JoinDiscriminatedUnions<UnwrapMaybeRef<TState>>]: RegleValidationErrors<JoinDiscriminatedUnions<UnwrapMaybeRef<TState>>[K], false, true, TSchema, K extends keyof TRules ? TRules[K] extends RegleFormPropertyType<Record<string, any>> ? TRules[K] : EmptyObject : EmptyObject> } & {
   readonly $self?: RegleFieldIssue[];
 };
-type RegleExternalErrorTree<TState$1 = MaybeRef<Record<string, any> | any[]>, TSchema extends boolean = false> = { readonly [K in keyof JoinDiscriminatedUnions<UnwrapMaybeRef<TState$1>>]?: RegleValidationErrors<JoinDiscriminatedUnions<UnwrapMaybeRef<TState$1>>[K], true, TSchema> } & {
+type RegleExternalErrorTree<TState = MaybeRef<Record<string, any> | any[]>, TSchema extends boolean = false> = { readonly [K in keyof JoinDiscriminatedUnions<UnwrapMaybeRef<TState>>]?: RegleValidationErrors<JoinDiscriminatedUnions<UnwrapMaybeRef<TState>>[K], true, TSchema> } & {
   readonly $self?: RegleFieldIssue[];
 };
-type RegleExternalSchemaErrorTree<TState$1 = MaybeRef<Record<string, any> | any[]>, TSchema extends boolean = false> = { readonly [K in keyof JoinDiscriminatedUnions<UnwrapMaybeRef<TState$1>>]?: RegleValidationErrors<JoinDiscriminatedUnions<UnwrapMaybeRef<TState$1>>[K], true, true, TSchema> };
-type ErrorMessageOrIssue<TIssue extends boolean> = TIssue extends true ? RegleFieldIssue[] : string[];
-type RegleValidationErrors<TState$1 extends Record<string, any> | any[] | unknown = never, TExternal extends boolean = false, TIssue extends boolean = false, TSchema extends boolean = false> = HasNamedKeys<TState$1> extends true ? IsAny<TState$1> extends true ? any : NonNullable<TState$1> extends Array<infer U> ? TSchema extends false ? U extends Record<string, any> ? TExternal extends false ? RegleCollectionErrors<U, TIssue, TSchema> : RegleExternalCollectionErrors<U, TIssue, TSchema> : ErrorMessageOrIssue<TIssue> : RegleCollectionErrors<U, TIssue, TSchema> : NonNullable<TState$1> extends Date | File ? ErrorMessageOrIssue<TIssue> : NonNullable<TState$1> extends Record<string, any> ? IsRegleStatic<NonNullable<TState$1>> extends true ? ErrorMessageOrIssue<TIssue> : TExternal extends false ? RegleErrorTree<TState$1, TIssue, TSchema> : RegleExternalErrorTree<TState$1, TSchema> : ErrorMessageOrIssue<TIssue> : any;
-type RegleCollectionErrors<TState$1 extends any, TIssue extends boolean = false, TSchema extends boolean = false> = {
+type RegleExternalSchemaErrorTree<TState = MaybeRef<Record<string, any> | any[]>, TSchema extends boolean = false> = { readonly [K in keyof JoinDiscriminatedUnions<UnwrapMaybeRef<TState>>]?: RegleValidationErrors<JoinDiscriminatedUnions<UnwrapMaybeRef<TState>>[K], true, true, TSchema> };
+type ErrorMessageOrIssue<TIssue extends boolean, TRules extends RegleFormPropertyType<Record<string, any>> = EmptyObject> = TIssue extends true ? RegleFieldIssue<TRules>[] : string[];
+type RegleValidationErrors<TState extends Record<string, any> | any[] | unknown = never, TExternal extends boolean = false, TIssue extends boolean = false, TSchema extends boolean = false, TRules extends RegleFormPropertyType<Record<string, any>> = EmptyObject> = HasNamedKeys<TState> extends true ? IsAny<TState> extends true ? any : NonNullable<TState> extends Array<infer U> ? TSchema extends false ? TExternal extends false ? RegleCollectionErrors<U, TIssue, TSchema> : RegleExternalCollectionErrors<U, TIssue, TSchema> : RegleCollectionErrors<U, TIssue, TSchema> : NonNullable<TState> extends Date | File ? ErrorMessageOrIssue<TIssue, TRules> : NonNullable<TState> extends Record<string, any> ? IsRegleStatic<NonNullable<TState>> extends true ? ErrorMessageOrIssue<TIssue, TRules> : TExternal extends false ? RegleErrorTree<TState, TIssue, TSchema> : RegleExternalErrorTree<TState, TSchema> : ErrorMessageOrIssue<TIssue, TRules> : any;
+type RegleFieldIssue<TRules extends RegleFormPropertyType<unknown, Partial<ExtendedRulesDeclarations>> = EmptyObject> = {
+  readonly $property: string;
+  readonly $type?: string;
+  readonly $message: string;
+} & (IsEmptyObject<TRules> extends true ? {
+  readonly $rule: string;
+} : { [K in keyof ComputeFieldRules<any, TRules>]: ComputeFieldRules<any, TRules>[K] extends {
+  $metadata: infer TMetadata;
+} ? K extends string ? {
+  readonly $rule: K;
+} & (TMetadata extends boolean ? {
+  readonly $rule: string;
+} : TMetadata) : {
+  readonly $rule: string;
+} : {
+  readonly $rule: string;
+} }[keyof ComputeFieldRules<any, TRules>]);
+type ComputeFieldRules<TState extends any, TRules extends MaybeRef<RegleFormPropertyType<unknown, Partial<ExtendedRulesDeclarations>>>> = IsEmptyObject<UnwrapRef<TRules>> extends true ? {
+  readonly [x: string]: RegleRuleStatus<TState, any[], any>;
+} : { readonly [TRuleKey in keyof Omit<UnwrapRef<TRules>, '$each' | keyof FieldRegleBehaviourOptions>]: RegleRuleStatus<TState, UnwrapRef<TRules>[TRuleKey] extends RegleRuleDefinition<unknown, any, infer TParams, any> ? TParams : [], UnwrapRef<TRules>[TRuleKey] extends RegleRuleDefinition<unknown, any, any, any, infer TMetadata> ? TMetadata : UnwrapRef<TRules>[TRuleKey] extends InlineRuleDeclaration<any, any[], infer TMetadata> ? TMetadata extends Promise<infer P> ? P : TMetadata : boolean> };
+type RegleCollectionErrors<TState extends any, TIssue extends boolean = false, TSchema extends boolean = false> = {
   readonly $self: TIssue extends true ? RegleFieldIssue[] : string[];
-  readonly $each: RegleValidationErrors<TState$1, false, TIssue, TSchema>[];
+  readonly $each: RegleValidationErrors<TState, false, TIssue, TSchema>[];
 };
-type RegleExternalCollectionErrors<TState$1 extends Record<string, any>, TIssue extends boolean = false, TSchema extends boolean = false> = {
+type RegleExternalCollectionErrors<TState extends unknown, TIssue extends boolean = false, TSchema extends boolean = false> = {
   readonly $self?: TIssue extends true ? RegleFieldIssue[] : string[];
-  readonly $each?: RegleValidationErrors<TState$1, true, TIssue, TSchema>[];
+  readonly $each?: RegleValidationErrors<TState, true, TIssue, TSchema>[];
 };
 /** @internal */
 type $InternalRegleCollectionErrors = {
@@ -1487,8 +1537,8 @@ type $InternalRegleCollectionIssues = {
   readonly $self?: RegleFieldIssue[];
   readonly $each?: $InternalRegleIssues[];
 };
-type RegleLike<TState$1 extends Record<string, any>> = {
-  $value: TState$1;
+type RegleLike<TState extends Record<string, any>> = {
+  $value: TState;
   $validate: (...args: any[]) => Promise<SuperCompatibleRegleResult>;
 };
 interface SuperCompatibleRegle {
@@ -1597,51 +1647,37 @@ type SuperCompatibleRegleCollectionIssues = $InternalRegleCollectionIssues;
  *
  * @see {@link https://reglejs.dev/core-concepts/rules/reusable-rules Documentation}
  */
-declare function createRule<const 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), TNonEmpty extends boolean = false>(definition: RegleRuleInit<TType$1, TValue$1, TParams$1, TReturn, TMetadata$1, TAsync$1, TNonEmpty>): InferRegleRule<TType$1, TValue$1, TParams$1, TAsync$1, TMetadata$1, TNonEmpty>;
+declare function createRule<const TType extends string | unknown, TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync extends boolean = (TReturn extends Promise<any> ? true : false), TNonEmpty extends boolean = false>(definition: RegleRuleInit<TType, TValue, TParams, TReturn, TMetadata, TAsync, TNonEmpty>): InferRegleRule<TType, TValue, TParams, TAsync, TMetadata, TNonEmpty>;
 /**
  * Returns a clean list of parameters
  * Removing Ref and executing function to return the unwrapped value
  */
-declare function unwrapRuleParameters<TParams$1 extends any[]>(params: MaybeRefOrGetter[]): TParams$1;
-type MergedRegles<TRegles extends Record<string, SuperCompatibleRegleRoot>, TValue$1 = { [K in keyof TRegles]: TRegles[K]['$value'] }> = Omit<RegleCommonStatus, '$value' | '$silentValue' | '$errors' | '$silentErrors' | '$name' | '$unwatch' | '$watch' | '$extractDirtyFields'> & {
-  /** Map of merged Regle instances and their properties  */
-  readonly $instances: { [K in keyof TRegles]: TRegles[K] };
-  /** A reference to the original validated model. It can be used to bind your form with v-model.*/
-  $value: TValue$1;
-  /** $value variant that will not "touch" the field and update the value silently, running only the rules, so you can easily swap values without impacting user interaction. */
-  $silentValue: TValue$1;
+declare function unwrapRuleParameters<TParams extends any[]>(params: MaybeRefOrGetter[]): TParams;
+type MergedRegles<TRegles extends Record<string, SuperCompatibleRegleRoot>, TValue = { [K in keyof TRegles]: TRegles[K]['$value'] }> = Omit<RegleCommonStatus, '$value' | '$silentValue' | '$errors' | '$silentErrors' | '$name' | '$unwatch' | '$watch' | '$extractDirtyFields'> & {
+  /** Map of merged Regle instances and their properties  */readonly $instances: { [K in keyof TRegles]: TRegles[K] }; /** A reference to the original validated model. It can be used to bind your form with v-model.*/
+  $value: TValue; /** $value variant that will not "touch" the field and update the value silently, running only the rules, so you can easily swap values without impacting user interaction. */
+  $silentValue: TValue;
   /** Collection of all the error messages, collected for all children properties and nested forms.
    *
    * Only contains errors from properties where $dirty equals true. */
-  readonly $errors: { [K in keyof TRegles]: TRegles[K]['$errors'] };
-  /** Collection of all the error messages, collected for all children properties. */
+  readonly $errors: { [K in keyof TRegles]: TRegles[K]['$errors'] }; /** Collection of all the error messages, collected for all children properties. */
   readonly $silentErrors: { [K in keyof TRegles]: TRegles[K]['$silentErrors'] };
   readonly $issues: { [K in keyof TRegles]: TRegles[K]['$issues'] };
-  readonly $silentIssues: { [K in keyof TRegles]: TRegles[K]['$silentIssues'] };
-  /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
-  $extractDirtyFields: (filterNullishValues?: boolean) => DeepPartial<TValue$1>[];
-  /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
+  readonly $silentIssues: { [K in keyof TRegles]: TRegles[K]['$silentIssues'] }; /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
+  $extractDirtyFields: (filterNullishValues?: boolean) => DeepPartial<TValue>[]; /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
   $validate: (forceValues?: TRegles['$value']) => Promise<MergedReglesResult<TRegles>>;
 } & (HasNamedKeys<TRegles> extends true ? { [K in keyof TRegles]: TRegles[K] } : {});
-type MergedScopedRegles<TValue$1 extends Record<string, unknown>[] = Record<string, unknown>[]> = Omit<MergedRegles<Record<string, SuperCompatibleRegleRoot>, TValue$1>, '$instances' | '$errors' | '$silentErrors' | '$value' | '$silentValue' | '$validate' | '$extractDirtyFields'> & {
-  /** Array of scoped Regles instances  */
-  readonly $instances: SuperCompatibleRegleRoot[];
-  /** Collection of all registered Regles instances values */
-  readonly $value: TValue$1;
-  /** Collection of all registered Regles instances errors */
-  readonly $errors: RegleValidationErrors<Record<string, unknown>>[];
-  /** Collection of all registered Regles instances silent errors */
-  readonly $silentErrors: RegleValidationErrors<Record<string, unknown>>[];
-  /** Collection of all registered Regles instances issues */
-  readonly $issues: RegleValidationErrors<Record<string, unknown>, false, true>[];
-  /** Collection of all registered Regles instances silent issues */
-  readonly $silentIssues: RegleValidationErrors<Record<string, unknown>, false, true>[];
-  /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
-  $extractDirtyFields: (filterNullishValues?: boolean) => DeepPartial<TValue$1>;
-  /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
-  $validate: (forceValues?: TValue$1) => Promise<{
+type MergedScopedRegles<TValue extends Record<string, unknown>[] = Record<string, unknown>[]> = Omit<MergedRegles<Record<string, SuperCompatibleRegleRoot>, TValue>, '$instances' | '$errors' | '$silentErrors' | '$value' | '$silentValue' | '$validate' | '$extractDirtyFields'> & {
+  /** Array of scoped Regles instances  */readonly $instances: SuperCompatibleRegleRoot[]; /** Collection of all registered Regles instances values */
+  readonly $value: TValue; /** Collection of all registered Regles instances errors */
+  readonly $errors: RegleValidationErrors<Record<string, unknown>>[]; /** Collection of all registered Regles instances silent errors */
+  readonly $silentErrors: RegleValidationErrors<Record<string, unknown>>[]; /** Collection of all registered Regles instances issues */
+  readonly $issues: RegleValidationErrors<Record<string, unknown>, false, true>[]; /** Collection of all registered Regles instances silent issues */
+  readonly $silentIssues: RegleValidationErrors<Record<string, unknown>, false, true>[]; /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
+  $extractDirtyFields: (filterNullishValues?: boolean) => DeepPartial<TValue>; /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
+  $validate: (forceValues?: TValue) => Promise<{
     valid: boolean;
-    data: TValue$1;
+    data: TValue;
     errors: RegleValidationErrors<Record<string, unknown>>[];
     issues: RegleValidationErrors<Record<string, unknown>>[];
   }>;
@@ -1700,10 +1736,10 @@ type MergedReglesResult<TRegles extends Record<string, SuperCompatibleRegleRoot>
  * @see {@link https://reglejs.dev/advanced-usage/merge-regles Documentation}
  */
 declare function mergeRegles<TRegles extends Record<string, SuperCompatibleRegleRoot>, TScoped extends boolean = false>(regles: TRegles, _scoped?: TScoped): TScoped extends false ? MergedRegles<TRegles> : MergedScopedRegles;
-type useCollectScopeFn<TNamedScoped extends boolean = false> = TNamedScoped extends true ? <const TValue$1 extends Record<string, Record<string, any>>>(namespace?: MaybeRefOrGetter<string | string[]>) => {
-  r$: MergedRegles<{ [K in keyof TValue$1]: RegleRoot<TValue$1[K]> & SuperCompatibleRegleRoot }>;
-} : <TValue$1 extends Record<string, unknown>[] = Record<string, unknown>[]>(namespace?: MaybeRefOrGetter<string | string[]>) => {
-  r$: MergedScopedRegles<TValue$1>;
+type useCollectScopeFn<TNamedScoped extends boolean = false> = TNamedScoped extends true ? <const TValue extends Record<string, Record<string, any>>>(namespace?: MaybeRefOrGetter<string | string[]>) => {
+  r$: MergedRegles<{ [K in keyof TValue]: RegleRoot<TValue[K]> & SuperCompatibleRegleRoot }>;
+} : <TValue extends Record<string, unknown>[] = Record<string, unknown>[]>(namespace?: MaybeRefOrGetter<string | string[]>) => {
+  r$: MergedScopedRegles<TValue>;
 };
 type UseScopedRegleOptions<TAsRecord extends boolean> = {
   namespace?: MaybeRefOrGetter<string>;
@@ -1796,8 +1832,8 @@ declare function createScopedUseRegle<TCustomRegle extends useRegleFn<any, any>
  *
  * @see {@link https://reglejs.dev/advanced-usage/scoped-validation Documentation}
  */
-declare const useCollectScope: <TValue$1 extends Record<string, unknown>[] = Record<string, unknown>[]>(namespace?: MaybeRefOrGetter<string | string[]>) => {
-  r$: MergedScopedRegles<TValue$1>;
+declare const useCollectScope: <TValue extends Record<string, unknown>[] = Record<string, unknown>[]>(namespace?: MaybeRefOrGetter<string | string[]>) => {
+  r$: MergedScopedRegles<TValue>;
 };
 /**
  * Clone of `useRegle` that automatically registers its instance for collection by `useCollectScope`.
@@ -1897,9 +1933,9 @@ declare function narrowVariant<TRoot extends {
     [x: string]: unknown;
   };
   $value: unknown;
-}, const TKey$1 extends keyof TRoot, const TValue$1 extends (LazyJoinDiscriminatedUnions<Exclude<TRoot[TKey$1], RegleCollectionStatus<any, any, any> | RegleStatus<any, any, any> | NarrowVariantExtracts[keyof NarrowVariantExtracts]>> extends {
+}, const TKey extends keyof TRoot, const TValue extends (LazyJoinDiscriminatedUnions<Exclude<TRoot[TKey], RegleCollectionStatus<any, any, any> | RegleStatus<any, any, any> | NarrowVariantExtracts[keyof NarrowVariantExtracts]>> extends {
   $value: infer V;
-} ? V : unknown)>(root: TRoot | undefined, discriminantKey: TKey$1, discriminantValue: TValue$1): root is NarrowVariant<TRoot, TKey$1, TValue$1>;
+} ? V : unknown)>(root: TRoot | undefined, discriminantKey: TKey, discriminantValue: TValue): root is NarrowVariant<TRoot, TKey, TValue>;
 /**
  * Create a reactive reference to a narrowed variant.
  * Useful in templates or when you need a stable ref to the narrowed type.
@@ -1924,17 +1960,17 @@ declare function narrowVariant<TRoot extends {
  *
  * @see {@link https://reglejs.dev/advanced-usage/variants Documentation}
  */
-declare function variantToRef<TRoot extends RegleStatus<{}, any, any>, const TKey$1 extends keyof TRoot['$fields'], const TValue$1 extends (LazyJoinDiscriminatedUnions<Exclude<TRoot['$fields'][TKey$1], RegleCollectionStatus<any, any, any> | RegleStatus<any, any, any> | NarrowVariantExtracts[keyof NarrowVariantExtracts]>> extends {
+declare function variantToRef<TRoot extends RegleStatus<{}, any, any>, const TKey extends keyof TRoot['$fields'], const TValue extends (LazyJoinDiscriminatedUnions<Exclude<TRoot['$fields'][TKey], RegleCollectionStatus<any, any, any> | RegleStatus<any, any, any> | NarrowVariantExtracts[keyof NarrowVariantExtracts]>> extends {
   $value: infer V;
-} ? V : unknown)>(root: MaybeRef<TRoot>, discriminantKey: TKey$1, discriminantValue: TValue$1, options: {
+} ? V : unknown)>(root: MaybeRef<TRoot>, discriminantKey: TKey, discriminantValue: TValue, options: {
   /**
    * Assert that the variant is always defined, use with caution
    */
   unsafeAssertion: true;
-}): Ref<NarrowVariant<TRoot, TKey$1, TValue$1>>;
-declare function variantToRef<TRoot extends RegleStatus<{}, any, any>, const TKey$1 extends keyof TRoot['$fields'], const TValue$1 extends (LazyJoinDiscriminatedUnions<Exclude<TRoot['$fields'][TKey$1], RegleCollectionStatus<any, any, any> | RegleStatus<any, any, any> | NarrowVariantExtracts[keyof NarrowVariantExtracts]>> extends {
+}): Ref<NarrowVariant<TRoot, TKey, TValue>>;
+declare function variantToRef<TRoot extends RegleStatus<{}, any, any>, const TKey extends keyof TRoot['$fields'], const TValue extends (LazyJoinDiscriminatedUnions<Exclude<TRoot['$fields'][TKey], RegleCollectionStatus<any, any, any> | RegleStatus<any, any, any> | NarrowVariantExtracts[keyof NarrowVariantExtracts]>> extends {
   $value: infer V;
-} ? V : unknown)>(root: MaybeRef<TRoot>, discriminantKey: TKey$1, discriminantValue: TValue$1): Ref<NarrowVariant<TRoot, TKey$1, TValue$1> | undefined>;
+} ? V : unknown)>(root: MaybeRef<TRoot>, discriminantKey: TKey, discriminantValue: TValue): Ref<NarrowVariant<TRoot, TKey, TValue> | undefined>;
 /**
  * Helper method to wrap a raw rules object with type inference.
  * Provides autocomplete and type-checking without processing.
@@ -1956,7 +1992,7 @@ declare function variantToRef<TRoot extends RegleStatus<{}, any, any>, const TKe
  *
  * @see {@link https://reglejs.dev/common-usage/standard-schema Documentation}
  */
-declare function defineRules<TRules$1 extends RegleUnknownRulesTree>(rules: TRules$1): TRules$1;
+declare function defineRules<TRules extends RegleUnknownRulesTree>(rules: TRules): TRules;
 /**
  * Refine a rules object to add rules that depend on the state values.
  * Inspired by Zod's `refine`, this allows writing dynamic rules while maintaining type safety.
@@ -1986,7 +2022,7 @@ declare function defineRules<TRules$1 extends RegleUnknownRulesTree>(rules: TRul
  *
  * @see {@link https://reglejs.dev/common-usage/standard-schema#refinerules Documentation}
  */
-declare function refineRules<TRules$1 extends RegleUnknownRulesTree, TRefinement extends ReglePartialRuleTree<InferInput<TRules$1>> & RegleUnknownRulesTree>(rules: TRules$1, refinement: (state: Ref<InferInput<TRules$1>>) => TRefinement): (state: Ref<InferInput<TRules$1>>) => Merge<TRules$1, TRefinement>;
+declare function refineRules<TRules extends RegleUnknownRulesTree, TRefinement extends ReglePartialRuleTree<InferInput<TRules>> & RegleUnknownRulesTree>(rules: TRules, refinement: (state: Ref<InferInput<TRules>>) => TRefinement): (state: Ref<InferInput<TRules>>) => Merge<TRules, TRefinement>;
 /**
  * Vue plugin to enable Regle devtools integration with Vue Devtools.
  * Provides debugging capabilities for inspecting validation trees, states, and actions.
@@ -2010,4 +2046,4 @@ declare function refineRules<TRules$1 extends RegleUnknownRulesTree, TRefinement
  * @see {@link https://reglejs.dev/introduction/devtools Documentation}
  */
 declare const RegleVuePlugin: Plugin;
-export { type $InternalRegleStatus, type AllRulesDeclarations, type ArrayElement, type CommonAlphaOptions, type CommonComparisonOptions, type CreateScopedUseRegleOptions, type DeepMaybeRef, type DeepPartial, type DeepReactiveState, type DefaultValidatorsTree, type DumbJoinDiscriminatedUnions, type ExtendedRulesDeclarations, type FormRuleDeclaration, type GlobalConfigOverrides, type HasNamedKeys, type HaveAnyRequiredProps, type InferInput, type InferOutput, type InferRegleRoot, type InferRegleRule, type InferRegleRules, type InferRegleSettings, type InferRegleShortcuts, type InferRegleStatusType, type InferRegleValidationResult, type InferSafeOutput, type InferValidOutput, type InlineRuleDeclaration, InternalRuleType, type IsRegleStatic, type JoinDiscriminatedUnions, type LazyJoinDiscriminatedUnions, type LocalRegleBehaviourOptions, type Maybe, type MaybeInput, type MaybeOutput, type MaybeReadonly, type MaybeVariantStatus, type MergedRegles, type MergedScopedRegles, type NarrowVariant, type NarrowVariantExtracts, type NarrowVariantFieldExtracts, type NoInferLegacy, type NonEmptyTuple, type Prettify, type PrimitiveTypes, type Regle, type RegleBehaviourOptions, type RegleCollectionErrors, type RegleCollectionRuleDecl, type RegleCollectionRuleDefinition, type RegleCollectionStatus, type RegleCommonStatus, type RegleComputedRules, type RegleCustomFieldStatus, type RegleEnforceCustomRequiredRules, type RegleEnforceRequiredRules, type RegleErrorTree, type RegleExternalCollectionErrors, type RegleExternalErrorTree, type RegleExternalSchemaErrorTree, type RegleFieldIssue, type RegleFieldStatus, type RegleFormPropertyType, type RegleInternalRuleDefs, type RegleIssuesTree, type RegleLike, type ReglePartialRuleTree, type RegleResult, type RegleRoot, type RegleRuleCore, type RegleRuleDecl, type RegleRuleDefinition, type RegleRuleDefinitionProcessor, type RegleRuleDefinitionWithMetadataProcessor, type RegleRuleInit, type RegleRuleMetadataConsumer, type RegleRuleMetadataDefinition, type RegleRuleMetadataExtended, type RegleRuleRaw, type RegleRuleStatus, type RegleRuleTypeReturn, type RegleRuleWithParamsDefinition, type RegleRuleWithParamsDefinitionInput, type RegleShortcutDefinition, type RegleSingleField, type RegleStatic, type RegleStaticImpl, type RegleStatus, type RegleUniversalParams, type RegleUnknownRulesTree, type RegleValidationErrors, type RegleValidationGroupEntry, type RegleValidationGroupOutput, type RegleRuleTree as RegleValidationTree, RegleVuePlugin, type ResolvedRegleBehaviourOptions, type ScopedInstancesRecord, type ScopedInstancesRecordLike, type SuperCompatibleRegle, type SuperCompatibleRegleCollectionErrors, type SuperCompatibleRegleCollectionStatus, type SuperCompatibleRegleFieldStatus, type SuperCompatibleRegleResult, type SuperCompatibleRegleRoot, type SuperCompatibleRegleRuleStatus, type SuperCompatibleRegleStatus, type TupleToPlainObj, type Unwrap, type UnwrapRegleUniversalParams, type UnwrapRuleWithParams, type UnwrapStatic, type UseScopedRegleOptions, createRule, createScopedUseRegle, createVariant, defineRegleConfig, defineRules, extendRegleConfig, flatErrors, inferRules, type inferRulesFn, type isEditedHandlerFn, markStatic, mergeRegles, narrowVariant, refineRules, unwrapRuleParameters, useCollectScope, type useCollectScopeFn, useRegle, type useRegleFn, useRootStorage, useRules, type useRulesFn, useScopedRegle, variantToRef };
+export { type $InternalRegleStatus, type AllRulesDeclarations, type ArrayElement, type CommonAlphaOptions, type CommonComparisonOptions, type CreateScopedUseRegleOptions, type DeepMaybeRef, type DeepPartial, type DeepReactiveState, type DefaultValidatorsTree, type DumbJoinDiscriminatedUnions, type ExtendedRulesDeclarations, type FormRuleDeclaration, type GlobalConfigOverrides, type HasNamedKeys, type HaveAnyRequiredProps, type InferInput, type InferOutput, type InferRegleRoot, type InferRegleRule, type InferRegleRules, type InferRegleSettings, type InferRegleShortcuts, type InferRegleStatusType, type InferRegleValidationResult, type InferSafeOutput, type InferValidOutput, type InlineRuleDeclaration, InternalRuleType, type IsRegleStatic, type JoinDiscriminatedUnions, type LazyJoinDiscriminatedUnions, type LocalRegleBehaviourOptions, type Maybe, type MaybeInput, type MaybeOutput, type MaybeReadonly, type MaybeVariantStatus, type MergedRegles, type MergedScopedRegles, type NarrowVariant, type NarrowVariantExtracts, type NarrowVariantFieldExtracts, type NoInferLegacy, type NonEmptyTuple, type Prettify, type PrimitiveTypes, type Regle, type RegleBehaviourOptions, type RegleCollectionErrors, type RegleCollectionRuleDecl, type RegleCollectionRuleDefinition, type RegleCollectionStatus, type RegleCommonStatus, type RegleComputedRules, type RegleCustomFieldStatus, type RegleEnforceCustomRequiredRules, type RegleEnforceRequiredRules, type RegleErrorTree, type RegleExternalCollectionErrors, type RegleExternalErrorTree, type RegleExternalSchemaErrorTree, type RegleFieldIssue, type RegleFieldStatus, type RegleFormPropertyType, type RegleInternalRuleDefs, type RegleIssuesTree, type RegleLike, type ReglePartialRuleTree, type RegleResult, type RegleRoot, type RegleRuleCore, type RegleRuleDecl, type RegleRuleDefinition, type RegleRuleDefinitionProcessor, type RegleRuleDefinitionWithMetadataProcessor, type RegleRuleInit, type RegleRuleMetadataConsumer, type RegleRuleMetadataDefinition, type RegleRuleMetadataExtended, type RegleRuleRaw, type RegleRuleStatus, type RegleRuleTypeReturn, type RegleRuleWithParamsDefinition, type RegleRuleWithParamsDefinitionInput, type RegleShortcutDefinition, type RegleSingleField, type RegleStatic, type RegleStaticImpl, type RegleStatus, type RegleUniversalParams, type RegleUnknownRulesTree, type RegleValidationErrors, type RegleValidationGroupEntry, type RegleValidationGroupOutput, type RegleRuleTree as RegleValidationTree, RegleVuePlugin, type ResolvedRegleBehaviourOptions, type ScopedInstancesRecord, type ScopedInstancesRecordLike, type SuperCompatibleRegle, type SuperCompatibleRegleCollectionErrors, type SuperCompatibleRegleCollectionStatus, type SuperCompatibleRegleFieldStatus, type SuperCompatibleRegleResult, type SuperCompatibleRegleRoot, type SuperCompatibleRegleRuleStatus, type SuperCompatibleRegleStatus, type TupleToPlainObj, type Unwrap, type UnwrapRegleUniversalParams, type UnwrapRuleWithParams, type UnwrapStatic, type UseScopedRegleOptions, createRule, createScopedUseRegle, createVariant, defineRegleConfig, defineRules, extendRegleConfig, flatErrors, getErrors, getIssues, inferRules, type inferRulesFn, type isEditedHandlerFn, markStatic, mergeRegles, narrowVariant, refineRules, unwrapRuleParameters, useCollectScope, type useCollectScopeFn, useRegle, type useRegleFn, useRootStorage, useRules, type useRulesFn, useScopedRegle, variantToRef };