@regle/core 1.26.0-beta.1 → 1.26.0-beta.6

package/dist/regle-core.d.ts

@@ -1,5 +1,5 @@
 /**
- * @regle/core v1.26.0-beta.1
+ * @regle/core v1.26.0-beta.6
  * (c) 2026 Victor Garcia
  * @license MIT
  */
@@ -7,723 +7,382 @@
 import { ComputedRef, MaybeRef, MaybeRefOrGetter, Plugin, Raw, Ref, UnwrapNestedRefs, UnwrapRef } from "vue";
 import { EmptyObject, Get, IsAny, IsEmptyObject, IsLiteral, IsNever, IsNullable, IsOptional, IsStringLiteral, IsUnion, IsUnknown, Merge, Or, Paths, RequireAtLeastOne, RequireOneOrNone, RequiredDeep, UnionToIntersection, UnionToTuple } from "type-fest";
 import { StandardSchemaV1 } from "@standard-schema/spec";
-interface GlobalConfigOverrides<TValue extends unknown = unknown> {
+declare const RegleStaticSymbol: unique symbol;
+type RegleStatic<T> = T extends (new (...args: infer Args) => infer U) ? RegleStaticImpl<new (...args: Args) => RegleStaticImpl<U>> : RegleStaticImpl<T>;
+type RegleStaticImpl<T> = Raw<T & {
+  [RegleStaticSymbol]: true;
+}>;
+type IsRegleStatic<T> = T extends RegleStaticImpl<T> ? true : false;
+type UnwrapStatic<T> = IsAny<T> extends true ? any : IsUnknown<T> extends true ? any : NonNullable<T> extends RegleStaticImpl<infer U> ? Raw<U> : UnwrapStaticSimple<T>;
+type UnwrapStaticSimple<T> = IsAny<T> extends true ? any : NonNullable<T> extends Array<infer U> ? Array<UnwrapStatic<U>> : isRecordLiteral<NonNullable<T>> extends true ? { [K in keyof T]: UnwrapStatic<T[K]> } : T;
+/**
+ * Combine all members of a union type, merging types for each key, and keeping loose types
+ */
+type JoinDiscriminatedUnions<TUnion extends unknown> = IsAny<TUnion> extends true ? any : IsUnknown<TUnion> extends true ? any : HasNamedKeys<TUnion> extends true ? isRecordLiteral<TUnion> extends true ? NonNullable<TUnion> extends infer TNonNull ? NormalizeUnion<TNonNull> extends infer TNormalized extends Record<string, any> ? HasCommonKey<UnionToTuple<TNonNull>, keyof TNormalized> extends true ? ResolveKeys<TUnion> extends infer TResolved extends Record<string, any> ? DumbJoinDiscriminatedUnions<TUnion> extends infer TDumbJoin ? Omit<TDumbJoin, keyof TResolved> extends infer TLoose ? Prettify<TResolved & (TLoose extends EmptyObject ? {} : TLoose)> : never : never : never : DumbJoinDiscriminatedUnions<TUnion> : never : never : TUnion : TUnion;
+type ResolveKeys<TUnion extends unknown> = NonNullable<TUnion> extends infer TNonNull ? NormalizeUnion<TNonNull> extends infer TNormalized extends Record<string, any> ? Partial<UnionToIntersection<RemoveCommonKey<UnionToTuple<TNonNull>, keyof TNormalized>[number]>> & Pick<TNormalized, keyof TNormalized> : never : never;
+/**
+ * Combine all members of a union type on one level and not nested.
+ */
+type LazyJoinDiscriminatedUnions<TUnion extends unknown> = IsAny<TUnion> extends true ? any : IsUnknown<TUnion> extends true ? any : isRecordLiteral<TUnion> extends true ? NonNullable<TUnion> extends infer TNonNull extends Record<string, any> ? Prettify<Partial<UnionToIntersection<RemoveCommonKey<UnionToTuple<TNonNull>, keyof TNonNull>[number]>> & Pick<TNonNull, keyof TNonNull>> : never : TUnion;
+type DumbJoinDiscriminatedUnions<TUnion extends unknown> = IsAny<TUnion> extends true ? any : IsUnknown<TUnion> extends true ? any : isRecordLiteral<TUnion> extends true ? NonNullable<TUnion> extends infer TNonNull extends Record<string, any> ? Prettify<Partial<UnionToIntersection<TNonNull>> & Pick<TNonNull, keyof TNonNull>> : never : TUnion;
+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
+ */
+type NormalizeUnion<TUnion> = RetrieveUnionUnknownValues<NonNullable<UnionToTuple<TUnion>>, RetrieveUnionUnknownKeysOf<NonNullable<UnionToTuple<TUnion>>>[number]>[number];
+/**
+ * Combine all union values to be able to get even the normally "never" values, act as an intersection type
+ */
+type RetrieveUnionUnknownValues<T extends readonly any[], TKeys extends string> = T extends [infer F extends Record<string, any>, ...infer R] ? [{ [K in TKeys as GetMaybeObjectValue<F, K> extends NonUndefined<GetMaybeObjectValue<F, K>> ? never : K]?: GetMaybeObjectValue<F, K> } & { [K in TKeys as GetMaybeObjectValue<F, K> extends NonUndefined<GetMaybeObjectValue<F, K>> ? K : never]: GetMaybeObjectValue<F, K> }, ...RetrieveUnionUnknownValues<R, TKeys>] : [];
+/**
+ * Get all possible keys from a union, even the ones present only on one union
+ */
+type RetrieveUnionUnknownKeysOf<T extends readonly any[]> = T extends [infer F, ...infer R] ? [keyof F, ...RetrieveUnionUnknownKeysOf<R>] : [];
+/**
+ * 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 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.
+ */
+type MergePropsIntoRequiredBooleans<TObject extends Record<string, any>> = { [K in keyof TObject]-?: TObject[K] extends NonNullable<TObject[K]> ? true : false }[keyof TObject];
+/**
+ * Ensure that if at least one prop is required, the "prop" object will be required too
+ */
+type HaveAnyRequiredProps<TObject extends Record<string, any>> = [TObject] extends [never] ? false : TObject extends Record<string, any> ? MergePropsIntoRequiredBooleans<TObject> extends false ? false : true : false;
+type EnumType<T extends Record<string, unknown>> = T[keyof T];
+type EnumLike = {
+  [k: string]: string | number;
+  [nu: number]: string;
+};
+type MaybeRefOrComputedRef<T extends any> = MaybeRef<T> | ComputedRef<T>;
+type UnwrapMaybeRef<T extends MaybeRef<any>> = T extends Ref<any> ? UnwrapRef<T> : UnwrapNestedRefs<T>;
+type TupleToPlainObj<T> = { [I in keyof T & `${number}`]: T[I] };
+type HasNamedKeys<T> = IsAny<T> extends true ? false : IsUnknown<T> extends true ? false : IsUnion<T> extends true ? ProcessHasNamedKeys<LazyJoinDiscriminatedUnions<T>> : ProcessHasNamedKeys<T>;
+type ProcessHasNamedKeys<T> = { [K in keyof NonNullable<T>]: K extends string ? (string extends K ? never : K) : never }[keyof NonNullable<T>] extends never ? false : true;
+/**
+ * Convert a nested object to a deeply nested partial object.
+ */
+type DeepPartial<T> = IsAny<T> extends true ? any : IsUnknown<T> extends true ? any : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends Date | File | RegleStaticImpl<unknown> ? T : T extends Record<string, any> ? { [K in keyof T]?: DeepPartial<T[K]> | undefined } : T | undefined;
+type Prettify<T> = T extends infer R ? { [K in keyof R]: R[K] } & {} : never;
+type Maybe<T = any> = T | null | undefined;
+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 isUndefinedOrNull<T> = Or<IsOptional<T>, IsNullable<T>>;
+type MaybeOrPartial<T> = T extends Record<string, any> ? Partial<T> : MaybeOutput<T>;
+type MaybeNullable<T> = Or<IsNullable<T>, IsOptional<T>>;
+type PromiseReturn<T> = T extends Promise<infer U> ? U : T;
+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<{}> ? false : NonNullable<T> extends Record<string, any> ? true : false;
+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]: MaybeRefOrGetter<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 WidenPrimitiveLiterals<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T;
+type isRecordLiteral<T extends unknown> = NonNullable<T> extends Date | File | RegleStatic<unknown> ? false : NonNullable<T> extends Record<string, any> ? true : false;
+type NoInferLegacy<A extends any> = [A][A extends any ? 0 : never];
+/**
+ * Extract the element type from an array.
+ *
+ * @example
+ * ```ts
+ * type Element = ArrayElement<[1, 2, 3]>; // number
+ * ```
+ */
+type ArrayElement<T> = T extends Array<infer U> ? U : never;
+/**
+ * Declares a tuple that must have at least one element
+ */
+type NonEmptyTuple<T> = [T, ...T[]] | T[];
+interface CommonComparisonOptions {
   /**
-   * Override the default $edited handler.
+   * Change the behaviour of the rule to check only if the value is equal in addition to be strictly superior or inferior
+   * @default true
    */
-  isEdited?: isEditedHandlerFn<TValue>;
+  allowEqual?: boolean;
 }
-type isEditedHandlerFn<TValue extends unknown = unknown> = (currentValue: MaybeInput<TValue>, initialValue: MaybeInput<TValue>, defaultHandlerFn: (currentValue: unknown, initialValue: unknown) => boolean) => boolean;
-type RegleImmediateDirtyMode = 'eager' | 'non-empty' | 'lazy-non-empty';
-interface RegleBehaviourOptions {
-  /**
-   * Does not run rules until the field is dirty.
-   * @default false
-   */
-  lazy?: boolean | undefined;
+interface CommonAlphaOptions {
   /**
-   * Automatically set the dirty state to true when value is changed without the need of calling `$touch`.
+   * Allow symbols in alphabetical-like rules (like "_")
    * @default true
-   *
-   */
-  autoDirty?: boolean | undefined;
-  /**
-   * Only update error status when calling `$validate` or `$validateSync`.
-   * Will not display errors as you type
-   * @default false
-   *
-   * @default true if rewardEarly is true
-   *
    */
-  silent?: boolean | undefined;
+  allowSymbols?: boolean;
+}
+interface UrlOptions {
   /**
-   * The fields will turn valid when they are, but not invalid unless calling `r$.$validate()` or `$validateSync`
-   * @default false
+   * Optional regex for validating the URL protocol
    */
-  rewardEarly?: boolean | undefined;
+  protocol?: RegExp;
+}
+type EnumOneOfLike<TValue extends unknown> = {
+  readonly [k: string]: TValue;
+};
+type DefaultValidators = {
+  alpha: RegleRuleWithParamsDefinition<unknown, string, [options?: CommonAlphaOptions | undefined]>;
+  alphaNum: RegleRuleWithParamsDefinition<unknown, string | number, [options?: CommonAlphaOptions | undefined]>;
+  atLeastOne: RegleRuleWithParamsDefinition<unknown, Record<string, unknown> | object, [keys?: readonly string[] | undefined], false, boolean, false, Record<string, unknown> | object>;
+  between: RegleRuleWithParamsDefinition<unknown, number, [min: number, max: number, options?: CommonComparisonOptions]>;
+  boolean: RegleRuleDefinition<unknown, unknown, [], false, boolean, any, unknown>;
+  checked: RegleRuleDefinition<unknown, boolean, [], false, boolean, boolean>;
+  contains: RegleRuleWithParamsDefinition<unknown, string, [part: MaybeInput<string>], false, boolean>;
+  containsSpecialCharacter: RegleRuleWithParamsDefinition<unknown, string, [minCharactersCount?: number | undefined], false, {
+    $valid: boolean;
+    minCharactersCount: number;
+  }>;
+  containsUppercase: RegleRuleWithParamsDefinition<unknown, string, [minUppercaseCount?: number | undefined], false, {
+    $valid: boolean;
+    minUppercaseCount: number;
+  }>;
+  date: RegleRuleDefinition<unknown, unknown, [], false, boolean, MaybeInput<Date>, unknown>;
+  dateAfter: RegleRuleWithParamsDefinition<unknown, string | Date, [after: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, true | {
+    $valid: false;
+    error: 'date-not-after';
+  } | {
+    $valid: false;
+    error: 'value-or-parameter-not-a-date';
+  }>;
+  dateBefore: RegleRuleWithParamsDefinition<unknown, string | Date, [before: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, true | {
+    $valid: false;
+    error: 'date-not-before';
+  } | {
+    $valid: false;
+    error: 'value-or-parameter-not-a-date';
+  }>;
+  dateBetween: RegleRuleWithParamsDefinition<unknown, string | Date, [before: MaybeInput<string | Date>, after: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, boolean>;
+  decimal: RegleRuleDefinition<unknown, string | number, [], false, boolean, string | number>;
+  domain: RegleRuleDefinition<unknown, string, [], false, boolean, string>;
+  email: RegleRuleDefinition<unknown, string, [], false, boolean, string>;
+  endsWith: RegleRuleWithParamsDefinition<unknown, string, [part: MaybeInput<string>], false, boolean>;
+  exactLength: RegleRuleWithParamsDefinition<unknown, MeasurableValue, [count: number], false, boolean>;
+  exactValue: RegleRuleWithParamsDefinition<unknown, number, [count: number], false, boolean>;
+  file: RegleRuleDefinition<unknown, unknown, [], false, boolean, MaybeInput<File>, unknown>;
+  fileType: RegleRuleWithParamsDefinition<unknown, File, [accept: readonly string[]], false, boolean>;
+  hexadecimal: RegleRuleDefinition<unknown, string, [], false, boolean, string>;
+  integer: RegleRuleDefinition<unknown, string | number, [], false, boolean, string | number>;
+  ipv4Address: RegleRuleDefinition<unknown, string, [], false, boolean, string>;
+  literal: RegleRuleDefinition<unknown, string | number, [literal: string | number], false, boolean, MaybeInput<string | number>, string | number, true>;
+  macAddress: RegleRuleWithParamsDefinition<unknown, string, [separator?: string | undefined], false, boolean>;
+  maxLength: RegleRuleWithParamsDefinition<unknown, MeasurableValue, [max: number, options?: CommonComparisonOptions], false, boolean>;
+  maxFileSize: RegleRuleWithParamsDefinition<unknown, File, [maxSize: number], false, true | {
+    $valid: boolean;
+    fileSize: number;
+  }, MaybeInput<File>, File>;
+  maxValue: RegleRuleWithParamsDefinition<unknown, number | string, [max: number | string, options?: CommonComparisonOptions], false, boolean>;
+  minFileSize: RegleRuleWithParamsDefinition<unknown, File, [minSize: number], false, true | {
+    $valid: boolean;
+    fileSize: number;
+  }, MaybeInput<File>, File>;
+  minLength: RegleRuleWithParamsDefinition<unknown, MeasurableValue, [min: number, options?: CommonComparisonOptions], false, boolean>;
+  minValue: RegleRuleWithParamsDefinition<unknown, number | string, [min: number | string, options?: CommonComparisonOptions], false, boolean>;
+  nativeEnum: RegleRuleDefinition<unknown, string | number, [enumLike: EnumLike], false, boolean, string | number>;
+  number: RegleRuleDefinition<unknown, unknown, [], false, boolean, any, unknown>;
+  numeric: RegleRuleDefinition<unknown, string | number, [], false, boolean, string | number>;
+  oneOf: RegleRuleDefinition<unknown, string | number, [options: readonly [string | number, ...(string | number)[]] | EnumOneOfLike<unknown>], false, boolean, MaybeInput<string | number>, string | number>;
+  regex: RegleRuleWithParamsDefinition<unknown, string | number, [regexp: RegExp | readonly RegExp[]], false, boolean>;
+  required: RegleRuleDefinition<unknown, unknown, [], false, boolean, unknown, unknown, true>;
+  sameAs: RegleRuleWithParamsDefinition<unknown, unknown, [target: any, otherName?: string], false, boolean>;
+  string: RegleRuleDefinition<unknown, unknown, [], false, boolean, any, unknown>;
+  type: RegleRuleDefinition<unknown, unknown, [], false, boolean, unknown, unknown>;
+  startsWith: RegleRuleWithParamsDefinition<unknown, string, [part: MaybeInput<string>], false, boolean>;
+  url: RegleRuleWithParamsDefinition<unknown, string, [options?: UrlOptions | undefined], false, boolean, unknown, string>;
+};
+interface inferRulesFn<TCustomRules extends Partial<ExtendedRulesDeclarationsOverrides>> {
+  <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.
+ * It returns the rules without any processing - useful with computed rules.
+ *
+ * @param state - The state reference
+ * @param rules - Your rule tree
+ * @returns The rules object (passthrough)
+ *
+ * @example
+ * ```ts
+ * import { inferRules, useRegle } from '@regle/core';
+ * import { required, minLength } from '@regle/rules';
+ *
+ * const state = ref({ name: '' });
+ *
+ * // inferRules preserves TypeScript autocompletion
+ * const rules = computed(() => {
+ *   return inferRules(state, {
+ *     name: { required, minLength: minLength(2) }
+ *   })
+ * });
+ *
+ * const { r$ } = useRegle(state, rules);
+ * ```
+ *
+ * @see {@link https://reglejs.dev/core-concepts/#dynamic-rules-object Documentation}
+ */
+declare const inferRules: inferRulesFn<Partial<ExtendedRulesDeclarationsOverrides>>;
+interface GlobalConfigOptions<TCustomRules extends Partial<ExtendedRulesDeclarationsOverrides> = EmptyObject, TShortcuts extends RegleShortcutDefinition<any> = never> {
   /**
-   * Define whether the external errors should be cleared when updating a field
+   * Declare custom rules to be used globally or override the default rules messages.
    *
-   * Default to `false` if `$silent` is set to `true`
+   * Ex:
+   * ```ts
+   * import { defineRegleConfig } from '@regle/core';
+   * import { required, withMessage } from '@regle/rules';
    *
-   * @default true
+   * export const { useRegle, inferRules, useRules } = defineRegleConfig({
+   *   rules: () => ({
+   *     required: withMessage(required, 'This field cannot be empty'),
+   *   }),
+   * });
+   * ```
+   * @see {@link https://reglejs.dev/advanced-usage/global-config Documentation}
    */
-  clearExternalErrorsOnChange?: boolean | undefined;
+  rules?: () => TCustomRules;
   /**
-   * Define whether the external errors should be cleared when calling `$validate` or `$validateSync`
+   * Define modifiers to be used globally.
    *
-   * @default true
-   */
-  clearExternalErrorsOnValidate?: boolean | undefined;
-  /**
-   * Set the dirty state when the form is initialized.
-   *
-   * - `true` or `'eager'`: mark every field dirty.
-   * - `'non-empty'`: mark every field dirty when any initial value is non-empty.
-   * - `'lazy-non-empty'`: mark only fields with non-empty initial values dirty.
-   *
-   * @default false
-   */
-  immediateDirty?: boolean | RegleImmediateDirtyMode | undefined;
-  /**
-   * Disable all the computation
-   * @default false
-   */
-  disabled?: boolean | undefined;
-}
-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.
-   *
-   * Useful for integrating errors from a backend or other validation sources.
-   * External errors can be assigned using a reactive object or a Ref, and will be merged into the `$externalErrors` and `$errors` properties for each field.
-   * You can also call `r$.$setExternalErrors(...)` directly without providing this option.
-   * Pass this option when the same external errors ref needs to be owned and synchronized outside of Regle.
+   * Ex:
+   * ```ts
+   * import { defineRegleConfig } from '@regle/core';
    *
-   * More details: https://reglejs.dev/advanced-usage/external-errors
+   * export const { useRegle, inferRules, useRules } = defineRegleConfig({
+   *   modifiers: {
+   *     lazy: true,
+   *     rewardEarly: true
+   *   }
+   * });
+   * ```
+   * @see {@link https://reglejs.dev/advanced-usage/global-config#declare-modifiers Documentation}
    */
-  externalErrors?: Ref<RegleExternalErrorTree<Unwrap<TState>> | Record<string, string[]>>;
+  modifiers?: RegleBehaviourOptions;
   /**
-   * Allows you to group fields for custom collective validation logic.
-   *
-   * The `validationGroups` option lets you define logical groupings of fields within your form that should be validated or checked together.
-   * This can be used, for example, to easily determine if a subset of your form (e.g. an "address" group or a set of "contact information" fields) are all valid or share a collective error state.
+   * Define reusable validation shortcuts to be used globally.
    *
-   * The function receives the `$fields` object and must return an object where each key is a group name and the value is an array of RegleStatus or RegleFieldStatus instances representing the grouped fields.
-   * These groups can then be referenced using `$validationGroups.<groupName>` to access their combined validation state (e.g. `$invalid`, `$error`, `$errors`, etc).
+   * Ex:
+   * ```ts
+   * import { defineRegleConfig } from '@regle/core';
    *
-   * More details: https://reglejs.dev/core-concepts/modifiers#validationgroups
-   */
-  validationGroups?: (fields: RegleStatus<TState, TRules>['$fields']) => TValidationGroups;
-  /**
-   * A unique identifier for the Regle instance in the devtools.
-   * @default undefined
-   */
-  id?: string | undefined;
-}
-type FieldOnlyRegleBehaviourOptions = {
-  /**
-   * Set external errors for the field.
-   */
-  externalErrors?: Ref<string[]>;
-  /**
-   * A unique identifier for the Regle instance in the devtools.
-   * @default undefined
+   * export const { useRegle, inferRules, useRules } = defineRegleConfig({
+   *   shortcuts: {
+   *     fields: {
+   *       $isRequired: (field) => field.$rules.required?.$active ?? false,
+   *     },
+   *   },
+   * });
+   * ```
+   * @see {@link https://reglejs.dev/advanced-usage/extend-properties#extend-properties Documentation}
    */
-  id?: string | undefined;
-};
-type RegleValidationGroupEntry = RegleFieldStatus<any, any> | undefined;
-interface RegleValidationGroupOutput {
-  /** Indicates whether any field in the validation group is invalid. */
-  $invalid: boolean;
-  /** Convenience flag to easily decide if an error message should be displayed. True when any field in the group is dirty, not pending, and invalid. */
-  $error: boolean;
-  /** Indicates if any async rule in the validation group is currently running. */
-  $pending: boolean;
-  /** Indicates whether any field in the validation group has been interacted with by the user. */
-  $dirty: boolean;
-  /** Indicates whether all fields in the validation group pass validation and are dirty. */
-  $correct: boolean;
-  /** Collection of all error messages from fields in the group where $dirty equals true. */
-  $errors: string[];
-  /** Collection of all error messages from fields in the group, regardless of $dirty state. */
-  $silentErrors: string[];
+  shortcuts?: TShortcuts;
+  /** Override default behaviors of Regle processors. */
+  overrides?: GlobalConfigOverrides<unknown>;
 }
-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.
-   */
-  $debounce?: number;
-  /**
-   * Override the default `$edited` handler.
-   */
-  $isEdited?: isEditedHandlerFn<TValue>;
-};
-type CollectionRegleBehaviourOptions<TValue extends unknown = unknown> = FieldRegleBehaviourOptions<TValue> & {
-  /**
-   * Allow deep compare of array children to compute the `$edited` property
-   *
-   * Disabled by default for performance
-   *
-   * @default false
-   * */
-  $deepCompare?: boolean;
-};
-type ResolvedRegleBehaviourOptions = DeepMaybeRef<RequiredDeep<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<Record<string, any>, Record<string, any>, Record<string, any[]>>;
-type ShortcutCommonFn<T extends Record<string, any>> = {
-  [x: string]: (element: Omit<OmitByType<T, Function>, '~standard'>) => unknown;
-};
-type ShortcutFieldStatus<TCustomRules extends Record<string, any>> = RegleFieldStatus<any, Partial<TCustomRules> & Partial<DefaultValidators>>;
-type ShortcutNestedStatus<TCustomRules extends Record<string, any>> = RegleStatus<Record<string, any>, ReglePartialRuleTree<any, Partial<TCustomRules>>>;
-type ShortcutCollectionStatus<TCustomRules extends Record<string, any>> = RegleCollectionStatus<any[], Partial<TCustomRules> & Partial<DefaultValidators>>;
-type RegleShortcutDefinition<TCustomRules extends Record<string, any> = {}> = {
-  /**
-   * Allow you to customize the properties for every field
-   */
-  fields?: ShortcutCommonFn<ShortcutFieldStatus<TCustomRules>>;
-  /**
-   * Allow you to customize the properties for every parent of a nested object
-   */
-  nested?: ShortcutCommonFn<ShortcutNestedStatus<TCustomRules>>;
-  /**
-   * Allow you to customize the properties for every parent of a collection
-   */
-  collections?: ShortcutCommonFn<ShortcutCollectionStatus<TCustomRules>>;
+/**
+ * Define a global Regle configuration to customize the validation behavior across your application.
+ *
+ * Features:
+ * - Customize built-in rules messages
+ * - Add your custom rules with full type inference
+ * - Define global modifiers (lazy, rewardEarly, etc.)
+ * - Define shortcuts for common validation patterns
+ *
+ * @param options - Configuration options
+ * @returns Object containing typed `useRegle`, `inferRules`, and `useRules` functions
+ *
+ * @example
+ * ```ts
+ * import { defineRegleConfig } from '@regle/core';
+ * import { required, withMessage } from '@regle/rules';
+ *
+ * export const { useRegle, inferRules, useRules } = defineRegleConfig({
+ *   rules: () => ({
+ *     // Override default required message
+ *     required: withMessage(required, 'This field cannot be empty'),
+ *     // Add custom rule
+ *     myCustomRule: createRule({
+ *       validator: (value) => value === 'valid',
+ *       message: 'Invalid value'
+ *     })
+ *   }),
+ *   modifiers: {
+ *     lazy: true,
+ *     rewardEarly: true
+ *   }
+ * });
+ * ```
+ *
+ * @see {@link https://reglejs.dev/advanced-usage/global-config Documentation}
+ */
+declare function defineRegleConfig<TShortcuts extends RegleShortcutDefinition<TCustomRules>, TCustomRules extends Partial<ExtendedRulesDeclarationsOverrides>>({
+  rules,
+  modifiers,
+  shortcuts,
+  overrides
+}: GlobalConfigOptions<TCustomRules, TShortcuts>): {
+  useRegle: useRegleFn<Omit<TCustomRules, keyof DefaultValidators>, TShortcuts>;
+  inferRules: inferRulesFn<Omit<TCustomRules, keyof DefaultValidators>>;
+  useRules: useRulesFn<TCustomRules, TShortcuts>;
 };
-type AddDollarToOptions<T extends Record<string, any>> = { [K in keyof T as `$${string & K}`]: T[K] };
 /**
- * The main Regle type that represents a complete validation instance.
+ * Extend an already created custom `useRegle` configuration with additional rules, modifiers, or shortcuts.
  *
- * @template TState - The shape of the state object being validated
- * @template TRules - The validation rules tree for the state
- * @template TValidationGroups - Groups of validation rules that can be run together
- * @template TShortcuts - Custom shortcut definitions for common validation patterns
- * @template TAdditionalReturnProperties - Additional properties to extend the return type
+ * @param regle - The existing useRegle function to extend
+ * @param options - Additional configuration to merge
+ * @param options.rules - Additional custom rules
+ * @param options.modifiers - Additional modifiers to merge
+ * @param options.shortcuts - Additional shortcuts to merge
+ * @returns Object containing the extended `useRegle` and `inferRules` functions
+ *
+ * @example
+ * ```ts
+ * import { extendRegleConfig } from '@regle/core';
+ * import { baseUseRegle } from './base-config';
+ *
+ * export const { useRegle, inferRules } = extendRegleConfig(baseUseRegle, {
+ *   rules: () => ({
+ *     additionalRule: myNewRule
+ *   }),
+ *   modifiers: {
+ *     rewardEarly: true
+ *   }
+ * });
+ * ```
  *
+ * @see {@link https://reglejs.dev/advanced-usage/global-config Documentation}
  */
-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, TRules, TValidationGroups, TShortcuts>>;
-} & TAdditionalReturnProperties;
+declare function extendRegleConfig<TRootCustomRules extends Partial<ExtendedRulesDeclarationsOverrides>, TRootShortcuts extends RegleShortcutDefinition<{}>, TShortcuts extends RegleShortcutDefinition<Merge<TRootCustomRules, TCustomRules>>, TCustomRules extends Partial<ExtendedRulesDeclarationsOverrides>>(regle: useRegleFn<TRootCustomRules, TRootShortcuts>, {
+  rules,
+  modifiers,
+  shortcuts,
+  overrides
+}: GlobalConfigOptions<TCustomRules, TShortcuts>): {
+  useRegle: useRegleFn<Merge<TRootCustomRules, TCustomRules>, TRootShortcuts & TShortcuts>;
+  inferRules: inferRulesFn<Merge<TRootCustomRules, TCustomRules>>;
+};
 /**
- * The type for a single field validation instance.
+ * Define a global Regle options to customize the validation behavior across your application.
+ * It's meant to be used with the Regle Vue plugin.
  *
- * @template TState - The type of the state value being validated
- * @template TRules - The validation rules for the field
- * @template TShortcuts - Custom shortcut definitions for common validation patterns
- * @template TAdditionalReturnProperties - Additional properties to extend the return type
- */
-type RegleSingleField<TState extends Maybe<PrimitiveTypes> = any, TRules extends RegleRuleDecl<NonNullable<TState>, CustomRulesDeclarationTree> = 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, TRules, TShortcuts>>;
-} & TAdditionalReturnProperties;
-type DeepReactiveState<T extends Record<string, any> | unknown | undefined> = IsAny<T> extends true ? any : IsUnknown<T> extends true ? never : ExtendOnlyRealRecord<T> extends true ? { [K in keyof T]: InferDeepReactiveState<T[K]> } : never;
-type InferDeepReactiveState<TState> = IsAny<TState> extends true ? any : IsUnknown<TState> extends true ? MaybeRef<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.
-   *
-   * Initial state is different than the original state as the initial state can be mutated when using `$reset`.
-   *
-   * This serve as the base comparison state for `$edited` property.
-   *
-   * ⚠️ This doesn't work if the state is a `reactive` object.
-   */
-  toInitialState?: boolean;
-  /**
-   * Reset validation status and reset form state to its original state.
-   *
-   * Original state is the unmutated state that was passed to the form when it was initialized.
-   */
-  toOriginalState?: boolean;
-  /**
-   * Reset validation status and reset form state to the given state
-   * Also set the new state as the initial state.
-   */
-  toState?: TState | (() => TState);
-  /**
-   * Clears the $externalErrors state back to an empty object.
-   *
-   * @default true
-   */
-  clearExternalErrors?: boolean;
-  /**
-   * Keep the validation state of the form ($dirty, $invalid, $pending etc..)
-   * Only useful if you only want to reset the form state.
-   *
-   * @default false
-   */
-  keepValidationState?: boolean;
-}, 'toInitialState' | 'toState'>;
-type ScopedInstancesRecord = Record<string, Record<string, SuperCompatibleRegleRoot>> & {
-  '~~global': Record<string, SuperCompatibleRegleRoot>;
-};
-type ScopedInstancesRecordLike = Partial<ScopedInstancesRecord>;
-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 ? isRecordLiteral<Data> extends true ? PartialFormState<Data extends Record<string, any> ? Data : {}> : MaybeOutput<Data> : HasNamedKeys<Data> extends true ? HasNamedKeys<TRules> 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> : isRecordLiteral<Data> extends true ? PartialFormState<Data extends Record<string, any> ? 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>;
-  /**
-   * Collection of all the issues, collected for all children properties and nested forms.
-   *
-   * Only contains issues from properties where $dirty equals true.
-   */
-  errors: DataTypeRegleErrors<Data>;
-} | {
-  valid: true;
-  data: IsUnknown<Data> extends true ? unknown : IsAny<Data> extends true ? unknown : IsEmptyObject<TRules> extends true ? isRecordLiteral<Data> extends true ? PartialFormState<Data extends Record<string, any> ? Data : {}> : MaybeOutput<Data> : HasNamedKeys<Data> extends true ? HasNamedKeys<TRules> 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 : {}> : isRecordLiteral<Data> extends true ? PartialFormState<Data extends Record<string, any> ? Data : {}> : MaybeOutput<Data> : unknown;
-  issues: EmptyObject;
-  errors: EmptyObject;
-};
-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 extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = RegleResult<Data, TRules> & ({
-  valid: false;
-  issues: RegleCollectionErrors<Data, true>;
-  errors: RegleCollectionErrors<Data>;
-} | {
-  valid: true;
-  issues: EmptyObject;
-  errors: EmptyObject;
-});
-type RegleFieldResult<Data extends any, TRules extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = RegleResult<Data, TRules> & ({
-  valid: false;
-  issues: RegleFieldIssue<TRules>[];
-  errors: string[];
-} | {
-  valid: true;
-  issues: [];
-  errors: [];
-});
-type $InternalRegleResult = {
-  valid: boolean;
-  data: any;
-  errors: $InternalRegleErrorTree | $InternalRegleCollectionErrors | string[];
-  issues: $InternalRegleIssuesTree | $InternalRegleCollectionIssues | RegleFieldIssue[];
-};
-type DeepSafeFormState<TState extends Record<string, any>, TRules extends ReglePartialRuleTree<Record<string, any>, CustomRulesDeclarationTree> | undefined> = IsUnknown<TState> extends true ? {} : IsAny<TState> extends true ? unknown : TRules extends undefined ? TState : HasNamedKeys<TState> extends true ? 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]-?: IsUnknown<SafeProperty<TState[K], TRules[K]>> extends true ? unknown : IsAny<TState[K]> extends true ? unknown : NonNullable<SafeProperty<TState[K], TRules[K]>> }> : TState : TState;
-type FieldHaveRequiredRule<TRule extends RegleFormPropertyType<any, any> | undefined = never> = TRule extends MaybeRefOrComputedRef<RegleRuleDecl<any, any>> ? UnwrapRef<TRule> extends infer TRuleResolved extends Record<string, any> ? { [K in keyof TRuleResolved]-?: TRuleResolved[K] extends RegleRuleDefinition<unknown, any, any[], any, any, any, any, true> ? true : false }[keyof TRuleResolved] extends false ? false : true : false : false;
-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<any>> = 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> {}
-type NarrowVariant<TRoot extends {
-  [x: string]: unknown;
-  $fields: {
-    [x: string]: unknown;
-  };
-  $value: unknown;
-}, 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]: 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> & { [K in TKey]: TValue };
-} & { [K in TKey]: TRoot[K] & {
-  $value: TValue;
-} };
-type MaybeVariantStatus<TState extends Record<string, any> | undefined = Record<string, any>, TRules extends ReglePartialRuleTree<NonNullable<TState>> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = {}, TIsUnionOverride extends boolean = false,
-/**
- * Workaround for $each variants, TS generic can't detect if the Rules are an union when type is too nested, to the tuple is passed from parent
- */
-TRulesTuple extends readonly any[] = never> = IsUnion<NonNullable<TState>> extends true ? Or<TIsUnionOverride, IsUnion<TRules>> extends true ? (IsNever<TRulesTuple> extends true ? TRules : TRulesTuple[number]) extends infer RulesUnionTuple extends ReglePartialRuleTree<NonNullable<TState>> ? ProcessChildrenFields<NonNullable<TState>, RulesUnionTuple, TShortcuts> extends infer TChildren ? Omit<RegleStatus<NonNullable<TState>, RulesUnionTuple, TShortcuts>, '$fields'> & {
-  $fields: TChildren[keyof TChildren];
-} & (HasNamedKeys<NonNullable<TState>> extends true ? TChildren[keyof TChildren] : {}) : never : RegleStatus<JoinDiscriminatedUnions<NonNullable<TState>>, TRules extends ReglePartialRuleTree<NonNullable<JoinDiscriminatedUnions<NonNullable<TState>>>> ? TRules : EmptyObject, TShortcuts> : RegleStatus<JoinDiscriminatedUnions<NonNullable<TState>>, TRules extends ReglePartialRuleTree<NonNullable<JoinDiscriminatedUnions<NonNullable<TState>>>> ? TRules : EmptyObject, TShortcuts> : RegleStatus<TState, TRules, TShortcuts>;
-/** Helper type to extract state tuple item at index */
-type StateTupleItem<TStateTuple extends readonly any[], TIndexInt extends number> = TStateTuple[TIndexInt] extends Record<string, any> ? TStateTuple[TIndexInt] : never;
-/** Helper type to extract NonNullable state tuple item */
-type NonNullableStateTupleItem<TStateTuple extends readonly any[], TIndexInt extends number> = NonNullable<StateTupleItem<TStateTuple, TIndexInt>>;
-/** Helper type to find the corresponding variant rule */
-type VariantRuleForKey<TStateTuple extends readonly any[], TRulesTuple extends readonly any[], TIndexInt extends number, TKey> = FindCorrespondingVariant<StateTupleItem<TStateTuple, TIndexInt>, TRulesTuple> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject;
-type ProcessChildrenFields<TState extends Record<string, any> | undefined, TRules extends ReglePartialRuleTree<NonNullable<TState>>, TShortcuts extends RegleShortcutDefinition = {}> = UnionToTuple<TState> extends infer TStateTuple extends readonly any[] ? UnionToTuple<TRules> extends infer TRulesTuple extends readonly any[] ? { [TIndex in keyof TupleToPlainObj<TStateTuple>]: TIndex extends `${infer TIndexInt extends number}` ? { [TKey in keyof TStateTuple[TIndexInt] as IsEmptyObject<VariantRuleForKey<TStateTuple, TRulesTuple, TIndexInt, TKey>> extends true ? TKey extends keyof TState ? TState[TKey] extends NonNullable<TState[TKey]> ? TKey : never : never : TKey]-?: InferRegleStatusType<VariantRuleForKey<TStateTuple, TRulesTuple, TIndexInt, TKey>, NonNullableStateTupleItem<TStateTuple, TIndexInt>, TKey, TShortcuts> } & { [TKey in keyof TStateTuple[TIndexInt] as IsEmptyObject<VariantRuleForKey<TStateTuple, TRulesTuple, TIndexInt, TKey>> extends true ? TKey extends keyof TState ? TState[TKey] extends NonNullable<TState[TKey]> ? never : TKey : TKey : never]?: InferRegleStatusType<VariantRuleForKey<TStateTuple, TRulesTuple, TIndexInt, TKey>, NonNullableStateTupleItem<TStateTuple, TIndexInt>, TKey, TShortcuts> } : {} } : {} : {};
-type FindCorrespondingVariant<TState extends Record<string, any>, TRules extends readonly 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]>]: { [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 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>[]];
-declare const RegleStaticSymbol: unique symbol;
-type RegleStatic<T> = T extends (new (...args: infer Args) => infer U) ? RegleStaticImpl<new (...args: Args) => RegleStaticImpl<U>> : RegleStaticImpl<T>;
-type RegleStaticImpl<T> = Raw<T & {
-  [RegleStaticSymbol]: true;
-}>;
-type IsRegleStatic<T> = T extends RegleStaticImpl<T> ? true : false;
-type UnwrapStatic<T> = IsAny<T> extends true ? any : IsUnknown<T> extends true ? any : NonNullable<T> extends RegleStaticImpl<infer U> ? Raw<U> : UnwrapStaticSimple<T>;
-type UnwrapStaticSimple<T> = IsAny<T> extends true ? any : NonNullable<T> extends Array<infer U> ? Array<UnwrapStatic<U>> : isRecordLiteral<NonNullable<T>> extends true ? { [K in keyof T]: UnwrapStatic<T[K]> } : T;
-/**
- * Combine all members of a union type, merging types for each key, and keeping loose types
- */
-type JoinDiscriminatedUnions<TUnion extends unknown> = IsAny<TUnion> extends true ? any : IsUnknown<TUnion> extends true ? any : HasNamedKeys<TUnion> extends true ? isRecordLiteral<TUnion> extends true ? NonNullable<TUnion> extends infer TNonNull ? NormalizeUnion<TNonNull> extends infer TNormalized extends Record<string, any> ? HasCommonKey<UnionToTuple<TNonNull>, keyof TNormalized> extends true ? ResolveKeys<TUnion> extends infer TResolved extends Record<string, any> ? DumbJoinDiscriminatedUnions<TUnion> extends infer TDumbJoin ? Omit<TDumbJoin, keyof TResolved> extends infer TLoose ? Prettify<TResolved & (TLoose extends EmptyObject ? {} : TLoose)> : never : never : never : DumbJoinDiscriminatedUnions<TUnion> : never : never : TUnion : TUnion;
-type ResolveKeys<TUnion extends unknown> = NonNullable<TUnion> extends infer TNonNull ? NormalizeUnion<TNonNull> extends infer TNormalized extends Record<string, any> ? Partial<UnionToIntersection<RemoveCommonKey<UnionToTuple<TNonNull>, keyof TNormalized>[number]>> & Pick<TNormalized, keyof TNormalized> : never : never;
-/**
- * Combine all members of a union type on one level and not nested.
- */
-type LazyJoinDiscriminatedUnions<TUnion extends unknown> = IsAny<TUnion> extends true ? any : IsUnknown<TUnion> extends true ? any : isRecordLiteral<TUnion> extends true ? NonNullable<TUnion> extends infer TNonNull extends Record<string, any> ? Prettify<Partial<UnionToIntersection<RemoveCommonKey<UnionToTuple<TNonNull>, keyof TNonNull>[number]>> & Pick<TNonNull, keyof TNonNull>> : never : TUnion;
-type DumbJoinDiscriminatedUnions<TUnion extends unknown> = IsAny<TUnion> extends true ? any : IsUnknown<TUnion> extends true ? any : isRecordLiteral<TUnion> extends true ? NonNullable<TUnion> extends infer TNonNull extends Record<string, any> ? Prettify<Partial<UnionToIntersection<TNonNull>> & Pick<TNonNull, keyof TNonNull>> : never : TUnion;
-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
- */
-type NormalizeUnion<TUnion> = RetrieveUnionUnknownValues<NonNullable<UnionToTuple<TUnion>>, RetrieveUnionUnknownKeysOf<NonNullable<UnionToTuple<TUnion>>>[number]>[number];
-/**
- * Combine all union values to be able to get even the normally "never" values, act as an intersection type
- */
-type RetrieveUnionUnknownValues<T extends readonly any[], TKeys extends string> = T extends [infer F extends Record<string, any>, ...infer R] ? [{ [K in TKeys as GetMaybeObjectValue<F, K> extends NonUndefined<GetMaybeObjectValue<F, K>> ? never : K]?: GetMaybeObjectValue<F, K> } & { [K in TKeys as GetMaybeObjectValue<F, K> extends NonUndefined<GetMaybeObjectValue<F, K>> ? K : never]: GetMaybeObjectValue<F, K> }, ...RetrieveUnionUnknownValues<R, TKeys>] : [];
-/**
- * Get all possible keys from a union, even the ones present only on one union
- */
-type RetrieveUnionUnknownKeysOf<T extends readonly any[]> = T extends [infer F, ...infer R] ? [keyof F, ...RetrieveUnionUnknownKeysOf<R>] : [];
-/**
- * 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 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.
- */
-type MergePropsIntoRequiredBooleans<TObject extends Record<string, any>> = { [K in keyof TObject]-?: TObject[K] extends NonNullable<TObject[K]> ? true : false }[keyof TObject];
-/**
- * Ensure that if at least one prop is required, the "prop" object will be required too
- */
-type HaveAnyRequiredProps<TObject extends Record<string, any>> = [TObject] extends [never] ? false : TObject extends Record<string, any> ? MergePropsIntoRequiredBooleans<TObject> extends false ? false : true : false;
-type EnumType<T extends Record<string, unknown>> = T[keyof T];
-type EnumLike = {
-  [k: string]: string | number;
-  [nu: number]: string;
-};
-type MaybeRefOrComputedRef<T extends any> = MaybeRef<T> | ComputedRef<T>;
-type UnwrapMaybeRef<T extends MaybeRef<any> | DeepReactiveState<any>> = T extends Ref<any> ? UnwrapRef<T> : UnwrapNestedRefs<T>;
-type TupleToPlainObj<T> = { [I in keyof T & `${number}`]: T[I] };
-type HasNamedKeys<T> = IsAny<T> extends true ? false : IsUnknown<T> extends true ? false : IsUnion<T> extends true ? ProcessHasNamedKeys<LazyJoinDiscriminatedUnions<T>> : ProcessHasNamedKeys<T>;
-type ProcessHasNamedKeys<T> = { [K in keyof NonNullable<T>]: K extends string ? (string extends K ? never : K) : never }[keyof NonNullable<T>] extends never ? false : true;
-/**
- * Convert a nested object to a deeply nested partial object.
- */
-type DeepPartial<T> = IsAny<T> extends true ? any : IsUnknown<T> extends true ? any : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends Date | File | RegleStaticImpl<unknown> ? T : T extends Record<string, any> ? { [K in keyof T]?: DeepPartial<T[K]> | undefined } : T | undefined;
-type Prettify<T> = T extends infer R ? { [K in keyof R]: R[K] } & {} : never;
-type Maybe<T = any> = T | null | undefined;
-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 isUndefinedOrNull<T> = Or<IsOptional<T>, IsNullable<T>>;
-type MaybeOrPartial<T> = T extends Record<string, any> ? Partial<T> : MaybeOutput<T>;
-type MaybeNullable<T> = Or<IsNullable<T>, IsOptional<T>>;
-type PromiseReturn<T> = T extends Promise<infer U> ? U : T;
-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> = { [K in keyof T as T[K] extends U ? never : K]: T[K] };
-type DeepMaybeRef<T extends Record<string, any>> = { [K in keyof T]: MaybeRefOrGetter<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 WidenPrimitiveLiterals<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T;
-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 extends any> = [A][A extends any ? 0 : never];
-/**
- * Extract the element type from an array.
- *
- * @example
- * ```ts
- * type Element = ArrayElement<[1, 2, 3]>; // number
- * ```
- */
-type ArrayElement<T> = T extends Array<infer U> ? U : never;
-/**
- * Declares a tuple that must have at least one element
- */
-type NonEmptyTuple<T> = [T, ...T[]] | T[];
-interface CommonComparisonOptions {
-  /**
-   * Change the behaviour of the rule to check only if the value is equal in addition to be strictly superior or inferior
-   * @default true
-   */
-  allowEqual?: boolean;
-}
-interface CommonAlphaOptions {
-  /**
-   * Allow symbols in alphabetical-like rules (like "_")
-   * @default true
-   */
-  allowSymbols?: boolean;
-}
-interface UrlOptions {
-  /**
-   * Optional regex for validating the URL protocol
-   */
-  protocol?: RegExp;
-}
-type EnumOneOfLike<TValue extends unknown> = {
-  readonly [k: string]: TValue;
-};
-type DefaultValidators = {
-  alpha: RegleRuleWithParamsDefinition<unknown, string, [options?: CommonAlphaOptions | undefined]>;
-  alphaNum: RegleRuleWithParamsDefinition<unknown, string | number, [options?: CommonAlphaOptions | undefined]>;
-  atLeastOne: RegleRuleWithParamsDefinition<unknown, Record<string, unknown> | object, [keys?: readonly string[] | undefined], false, boolean, false, Record<string, unknown> | object>;
-  between: RegleRuleWithParamsDefinition<unknown, number, [min: number, max: number, options?: CommonComparisonOptions]>;
-  boolean: RegleRuleDefinition<unknown, unknown, [], false, boolean, any, unknown>;
-  checked: RegleRuleDefinition<unknown, boolean, [], false, boolean, boolean>;
-  contains: RegleRuleWithParamsDefinition<unknown, string, [part: MaybeInput<string>], false, boolean>;
-  containsSpecialCharacter: RegleRuleWithParamsDefinition<unknown, string, [minCharactersCount?: number | undefined], false, {
-    $valid: boolean;
-    minCharactersCount: number;
-  }>;
-  containsUppercase: RegleRuleWithParamsDefinition<unknown, string, [minUppercaseCount?: number | undefined], false, {
-    $valid: boolean;
-    minUppercaseCount: number;
-  }>;
-  date: RegleRuleDefinition<unknown, unknown, [], false, boolean, MaybeInput<Date>, unknown>;
-  dateAfter: RegleRuleWithParamsDefinition<unknown, string | Date, [after: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, true | {
-    $valid: false;
-    error: 'date-not-after';
-  } | {
-    $valid: false;
-    error: 'value-or-parameter-not-a-date';
-  }>;
-  dateBefore: RegleRuleWithParamsDefinition<unknown, string | Date, [before: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, true | {
-    $valid: false;
-    error: 'date-not-before';
-  } | {
-    $valid: false;
-    error: 'value-or-parameter-not-a-date';
-  }>;
-  dateBetween: RegleRuleWithParamsDefinition<unknown, string | Date, [before: MaybeInput<string | Date>, after: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, boolean>;
-  decimal: RegleRuleDefinition<unknown, string | number, [], false, boolean, string | number>;
-  domain: RegleRuleDefinition<unknown, string, [], false, boolean, string>;
-  email: RegleRuleDefinition<unknown, string, [], false, boolean, string>;
-  endsWith: RegleRuleWithParamsDefinition<unknown, string, [part: MaybeInput<string>], false, boolean>;
-  exactLength: RegleRuleWithParamsDefinition<unknown, MeasurableValue, [count: number], false, boolean>;
-  exactValue: RegleRuleWithParamsDefinition<unknown, number, [count: number], false, boolean>;
-  file: RegleRuleDefinition<unknown, unknown, [], false, boolean, MaybeInput<File>, unknown>;
-  fileType: RegleRuleWithParamsDefinition<unknown, File, [accept: readonly string[]], false, boolean>;
-  hexadecimal: RegleRuleDefinition<unknown, string, [], false, boolean, string>;
-  integer: RegleRuleDefinition<unknown, string | number, [], false, boolean, string | number>;
-  ipv4Address: RegleRuleDefinition<unknown, string, [], false, boolean, string>;
-  literal: RegleRuleDefinition<unknown, string | number, [literal: string | number], false, boolean, MaybeInput<string | number>, string | number, true>;
-  macAddress: RegleRuleWithParamsDefinition<unknown, string, [separator?: string | undefined], false, boolean>;
-  maxLength: RegleRuleWithParamsDefinition<unknown, MeasurableValue, [max: number, options?: CommonComparisonOptions], false, boolean>;
-  maxFileSize: RegleRuleWithParamsDefinition<unknown, File, [maxSize: number], false, true | {
-    $valid: boolean;
-    fileSize: number;
-  }, MaybeInput<File>, File>;
-  maxValue: RegleRuleWithParamsDefinition<unknown, number | string, [max: number | string, options?: CommonComparisonOptions], false, boolean>;
-  minFileSize: RegleRuleWithParamsDefinition<unknown, File, [minSize: number], false, true | {
-    $valid: boolean;
-    fileSize: number;
-  }, MaybeInput<File>, File>;
-  minLength: RegleRuleWithParamsDefinition<unknown, MeasurableValue, [min: number, options?: CommonComparisonOptions], false, boolean>;
-  minValue: RegleRuleWithParamsDefinition<unknown, number | string, [min: number | string, options?: CommonComparisonOptions], false, boolean>;
-  nativeEnum: RegleRuleDefinition<unknown, string | number, [enumLike: EnumLike], false, boolean, string | number>;
-  number: RegleRuleDefinition<unknown, unknown, [], false, boolean, any, unknown>;
-  numeric: RegleRuleDefinition<unknown, string | number, [], false, boolean, string | number>;
-  oneOf: RegleRuleDefinition<unknown, string | number, [options: readonly [string | number, ...(string | number)[]] | EnumOneOfLike<unknown>], false, boolean, MaybeInput<string | number>, string | number>;
-  regex: RegleRuleWithParamsDefinition<unknown, string | number, [regexp: RegExp | readonly RegExp[]], false, boolean>;
-  required: RegleRuleDefinition<unknown, unknown, [], false, boolean, unknown, unknown, true>;
-  sameAs: RegleRuleWithParamsDefinition<unknown, unknown, [target: any, otherName?: string], false, boolean>;
-  string: RegleRuleDefinition<unknown, unknown, [], false, boolean, any, unknown>;
-  type: RegleRuleDefinition<unknown, unknown, [], false, boolean, unknown, unknown>;
-  startsWith: RegleRuleWithParamsDefinition<unknown, string, [part: MaybeInput<string>], false, boolean>;
-  url: RegleRuleWithParamsDefinition<unknown, string, [options?: UrlOptions | undefined], false, boolean, unknown, string>;
-};
-interface inferRulesFn<TCustomRules extends Partial<ExtendedRulesDeclarationsOverrides>> {
-  <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.
- * It returns the rules without any processing - useful with computed rules.
- *
- * @param state - The state reference
- * @param rules - Your rule tree
- * @returns The rules object (passthrough)
- *
- * @example
- * ```ts
- * import { inferRules, useRegle } from '@regle/core';
- * import { required, minLength } from '@regle/rules';
- *
- * const state = ref({ name: '' });
- *
- * // inferRules preserves TypeScript autocompletion
- * const rules = computed(() => {
- *   return inferRules(state, {
- *     name: { required, minLength: minLength(2) }
- *   })
- * });
- *
- * const { r$ } = useRegle(state, rules);
- * ```
- *
- * @see {@link https://reglejs.dev/core-concepts/#dynamic-rules-object Documentation}
- */
-declare const inferRules: inferRulesFn<Partial<ExtendedRulesDeclarationsOverrides>>;
-interface GlobalConfigOptions<TCustomRules extends Partial<ExtendedRulesDeclarationsOverrides> = EmptyObject, TShortcuts extends RegleShortcutDefinition<any> = never> {
-  /**
-   * Declare custom rules to be used globally or override the default rules messages.
-   *
-   * Ex:
-   * ```ts
-   * import { defineRegleConfig } from '@regle/core';
-   * import { required, withMessage } from '@regle/rules';
-   *
-   * export const { useRegle, inferRules, useRules } = defineRegleConfig({
-   *   rules: () => ({
-   *     required: withMessage(required, 'This field cannot be empty'),
-   *   }),
-   * });
-   * ```
-   * @see {@link https://reglejs.dev/advanced-usage/global-config Documentation}
-   */
-  rules?: () => TCustomRules;
-  /**
-   * Define modifiers to be used globally.
-   *
-   * Ex:
-   * ```ts
-   * import { defineRegleConfig } from '@regle/core';
-   *
-   * export const { useRegle, inferRules, useRules } = defineRegleConfig({
-   *   modifiers: {
-   *     lazy: true,
-   *     rewardEarly: true
-   *   }
-   * });
-   * ```
-   * @see {@link https://reglejs.dev/advanced-usage/global-config#declare-modifiers Documentation}
-   */
-  modifiers?: RegleBehaviourOptions;
-  /**
-   * Define reusable validation shortcuts to be used globally.
-   *
-   * Ex:
-   * ```ts
-   * import { defineRegleConfig } from '@regle/core';
-   *
-   * export const { useRegle, inferRules, useRules } = defineRegleConfig({
-   *   shortcuts: {
-   *     fields: {
-   *       $isRequired: (field) => field.$rules.required?.$active ?? false,
-   *     },
-   *   },
-   * });
-   * ```
-   * @see {@link https://reglejs.dev/advanced-usage/extend-properties#extend-properties Documentation}
-   */
-  shortcuts?: TShortcuts;
-  /** Override default behaviors of Regle processors. */
-  overrides?: GlobalConfigOverrides<unknown>;
-}
-/**
- * Define a global Regle configuration to customize the validation behavior across your application.
- *
- * Features:
- * - Customize built-in rules messages
- * - Add your custom rules with full type inference
- * - Define global modifiers (lazy, rewardEarly, etc.)
- * - Define shortcuts for common validation patterns
- *
- * @param options - Configuration options
- * @returns Object containing typed `useRegle`, `inferRules`, and `useRules` functions
- *
- * @example
- * ```ts
- * import { defineRegleConfig } from '@regle/core';
- * import { required, withMessage } from '@regle/rules';
- *
- * export const { useRegle, inferRules, useRules } = defineRegleConfig({
- *   rules: () => ({
- *     // Override default required message
- *     required: withMessage(required, 'This field cannot be empty'),
- *     // Add custom rule
- *     myCustomRule: createRule({
- *       validator: (value) => value === 'valid',
- *       message: 'Invalid value'
- *     })
- *   }),
- *   modifiers: {
- *     lazy: true,
- *     rewardEarly: true
- *   }
- * });
- * ```
- *
- * @see {@link https://reglejs.dev/advanced-usage/global-config Documentation}
- */
-declare function defineRegleConfig<TShortcuts extends RegleShortcutDefinition<TCustomRules>, TCustomRules extends Partial<ExtendedRulesDeclarationsOverrides>>({
-  rules,
-  modifiers,
-  shortcuts,
-  overrides
-}: GlobalConfigOptions<TCustomRules, TShortcuts>): {
-  useRegle: useRegleFn<Omit<TCustomRules, keyof DefaultValidators>, TShortcuts>;
-  inferRules: inferRulesFn<Omit<TCustomRules, keyof DefaultValidators>>;
-  useRules: useRulesFn<TCustomRules, TShortcuts>;
-};
-/**
- * Extend an already created custom `useRegle` configuration with additional rules, modifiers, or shortcuts.
- *
- * @param regle - The existing useRegle function to extend
- * @param options - Additional configuration to merge
- * @param options.rules - Additional custom rules
- * @param options.modifiers - Additional modifiers to merge
- * @param options.shortcuts - Additional shortcuts to merge
- * @returns Object containing the extended `useRegle` and `inferRules` functions
- *
- * @example
- * ```ts
- * import { extendRegleConfig } from '@regle/core';
- * import { baseUseRegle } from './base-config';
- *
- * export const { useRegle, inferRules } = extendRegleConfig(baseUseRegle, {
- *   rules: () => ({
- *     additionalRule: myNewRule
- *   }),
- *   modifiers: {
- *     rewardEarly: true
- *   }
- * });
- * ```
- *
- * @see {@link https://reglejs.dev/advanced-usage/global-config Documentation}
- */
-declare function extendRegleConfig<TRootCustomRules extends Partial<ExtendedRulesDeclarationsOverrides>, TRootShortcuts extends RegleShortcutDefinition<{}>, TShortcuts extends RegleShortcutDefinition<Merge<TRootCustomRules, TCustomRules>>, TCustomRules extends Partial<ExtendedRulesDeclarationsOverrides>>(regle: useRegleFn<TRootCustomRules, TRootShortcuts>, {
-  rules,
-  modifiers,
-  shortcuts,
-  overrides
-}: GlobalConfigOptions<TCustomRules, TShortcuts>): {
-  useRegle: useRegleFn<Merge<TRootCustomRules, TCustomRules>, TRootShortcuts & TShortcuts>;
-  inferRules: inferRulesFn<Merge<TRootCustomRules, TCustomRules>>;
-};
-/**
- * Define a global Regle options to customize the validation behavior across your application.
- * It's meant to be used with the Regle Vue plugin.
- *
- * @param options - Configuration options
- * @returns The configuration options
- *
- * @example
- * ```ts
- * import { defineRegleOptions } from '@regle/core';
- *
- * const regleOptions = defineRegleOptions({
- *   modifiers: {
- *     lazy: true,
- *     rewardEarly: true
- *   }
- * });
- * ```
- *
- * @see {@link https://reglejs.dev/advanced-usage/global-config Documentation}
+ * @param options - Configuration options
+ * @returns The configuration options
+ *
+ * @example
+ * ```ts
+ * import { defineRegleOptions } from '@regle/core';
+ *
+ * const regleOptions = defineRegleOptions({
+ *   modifiers: {
+ *     lazy: true,
+ *     rewardEarly: true
+ *   }
+ * });
+ * ```
+ *
+ * @see {@link https://reglejs.dev/advanced-usage/global-config Documentation}
  */
 declare function defineRegleOptions<T extends GlobalConfigOptions<Partial<ExtendedRulesDeclarationsOverrides>, RegleShortcutDefinition<any>>>(options: T): T;
 type useRegleFnOptions<TState extends Record<string, any> | MaybeInput<PrimitiveTypes>, TRules extends ReglePartialRuleTree<NonNullable<JoinDiscriminatedUnions<TState>>, CustomRulesDeclarationTree>, 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 & FieldOnlyRegleBehaviourOptions>> & TAdditionalOptions;
@@ -918,72 +577,413 @@ interface useRulesFn<TCustomRules extends Partial<ExtendedRulesDeclarationsOverr
   __config?: GlobalConfigOptions<TCustomRules, TShortcuts>;
 }
 /**
- * `useRules` is a variant of `useRegle` that doesn't require you to provide initial state.
- * It creates an empty state based on your rules structure and implements the Standard Schema spec.
- *
- * This is useful when you want to define validation rules first and infer the state type from them.
- *
- * @param rules - Your validation rules object
- * @param modifiers - Optional configuration to customize regle behavior
- * @returns The reactive validation state (implements StandardSchemaV1)
- *
- * @example
- * ```ts
- * import { useRules, type InferInput } from '@regle/core';
- * import { required, string, email } from '@regle/rules';
- *
- * const r$ = useRules({
- *   name: { required, string },
- *   email: { required, email }
- * });
- *
- * // State is automatically created and typed
- * r$.$value.name // string | null
- * r$.$value.email // string | null
+ * `useRules` is a variant of `useRegle` that doesn't require you to provide initial state.
+ * It creates an empty state based on your rules structure and implements the Standard Schema spec.
+ *
+ * This is useful when you want to define validation rules first and infer the state type from them.
+ *
+ * @param rules - Your validation rules object
+ * @param modifiers - Optional configuration to customize regle behavior
+ * @returns The reactive validation state (implements StandardSchemaV1)
+ *
+ * @example
+ * ```ts
+ * import { useRules, type InferInput } from '@regle/core';
+ * import { required, string, email } from '@regle/rules';
+ *
+ * const r$ = useRules({
+ *   name: { required, string },
+ *   email: { required, email }
+ * });
+ *
+ * // State is automatically created and typed
+ * r$.$value.name // string | null
+ * r$.$value.email // string | null
+ *
+ * // Can be used with Standard Schema compatible libraries
+ * const result = await r$['~standard'].validate({ name: '', email: '' });
+ * ```
+ *
+ * @see {@link https://reglejs.dev/common-usage/standard-schema#userules Documentation}
+ */
+declare const useRules: useRulesFn<Partial<ExtendedRulesDeclarationsOverrides>, RegleShortcutDefinition<any>>;
+/**
+ * Marks a value as static and treats the constructor as a regular raw Field.
+ * @param value - The value to mark as static.
+ * @returns The marked value.
+ * @example
+ * ```ts
+ * const StaticDecimal = markStatic(Decimal);
+ * const StaticBigWrapper = markStatic(BigWrapper);
+ * ```
+ */
+declare function markStatic<T extends object>(value: T): T extends RegleStaticImpl<unknown> ? T : RegleStatic<T>;
+/**
+ * Infer type of the `r$` of any function returning a regle instance
+ */
+type InferRegleRoot<T extends (...args: any[]) => SuperCompatibleRegle> = T extends ((...args: any[]) => infer U) ? U extends SuperCompatibleRegle ? U['r$'] : never : never;
+/**
+ * Infer custom rules declared in a global configuration
+ */
+type InferRegleRules<T extends useRegleFn<any, any>> = T extends useRegleFn<infer U, any> ? UnwrapRuleTree<Partial<DefaultValidators>> & UnwrapRuleTree<Partial<U>> : {};
+/**
+ * Infer custom shortcuts declared in a global configuration
+ */
+type InferRegleShortcuts<T extends useRegleFn<any, any>> = T extends useRegleFn<any, infer U> ? U : {};
+/**
+ * Extract a set rules and setting them as required
+ */
+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 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 extends unknown = any, TRules extends keyof InferRegleRules<T> = never> = RegleFieldStatus<TState, [TRules] extends [never] ? Partial<InferRegleRules<T>> : RegleEnforceCustomRequiredRules<T, TRules>, InferRegleShortcuts<T>>;
+interface GlobalConfigOverrides<TValue extends unknown = unknown> {
+  /**
+   * Override the default $edited handler.
+   */
+  isEdited?: isEditedHandlerFn<TValue>;
+}
+type isEditedHandlerFn<TValue extends unknown = unknown> = (currentValue: MaybeInput<TValue>, initialValue: MaybeInput<TValue>, defaultHandlerFn: (currentValue: unknown, initialValue: unknown) => boolean) => boolean;
+type RegleImmediateDirtyMode = 'eager' | 'non-empty' | 'lazy-non-empty';
+interface RegleBehaviourOptions {
+  /**
+   * Does not run rules until the field is dirty.
+   * @default false
+   */
+  lazy?: boolean | undefined;
+  /**
+   * Automatically set the dirty state to true when value is changed without the need of calling `$touch`.
+   * @default true
+   *
+   */
+  autoDirty?: boolean | undefined;
+  /**
+   * Only update error status when calling `$validate` or `$validateSync`.
+   * Will not display errors as you type
+   * @default false
+   *
+   * @default true if rewardEarly is true
+   *
+   */
+  silent?: boolean | undefined;
+  /**
+   * The fields will turn valid when they are, but not invalid unless calling `r$.$validate()` or `$validateSync`
+   * @default false
+   */
+  rewardEarly?: boolean | undefined;
+  /**
+   * Define whether the external errors should be cleared when updating a field
+   *
+   * Default to `false` if `$silent` is set to `true`
+   *
+   * @default true
+   */
+  clearExternalErrorsOnChange?: boolean | undefined;
+  /**
+   * Define whether the external errors should be cleared when calling `$validate` or `$validateSync`
+   *
+   * @default true
+   */
+  clearExternalErrorsOnValidate?: boolean | undefined;
+  /**
+   * Set the dirty state when the form is initialized.
+   *
+   * - `true` or `'eager'`: mark every field dirty.
+   * - `'non-empty'`: mark every field dirty when any initial value is non-empty.
+   * - `'lazy-non-empty'`: mark only fields with non-empty initial values dirty.
+   *
+   * @default false
+   */
+  immediateDirty?: boolean | RegleImmediateDirtyMode | undefined;
+  /**
+   * Disable all the computation
+   * @default false
+   */
+  disabled?: boolean | undefined;
+}
+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.
+   *
+   * Useful for integrating errors from a backend or other validation sources.
+   * External errors can be assigned using a reactive object or a Ref, and will be merged into the `$externalErrors` and `$errors` properties for each field.
+   * You can also call `r$.$setExternalErrors(...)` directly without providing this option.
+   * Pass this option when the same external errors ref needs to be owned and synchronized outside of Regle.
+   *
+   * More details: https://reglejs.dev/advanced-usage/external-errors
+   */
+  externalErrors?: Ref<RegleExternalErrorTree<Unwrap<TState>> | Record<string, string[]>>;
+  /**
+   * Allows you to group fields for custom collective validation logic.
+   *
+   * The `validationGroups` option lets you define logical groupings of fields within your form that should be validated or checked together.
+   * This can be used, for example, to easily determine if a subset of your form (e.g. an "address" group or a set of "contact information" fields) are all valid or share a collective error state.
+   *
+   * The function receives the `$fields` object and must return an object where each key is a group name and the value is an array of RegleStatus or RegleFieldStatus instances representing the grouped fields.
+   * These groups can then be referenced using `$validationGroups.<groupName>` to access their combined validation state (e.g. `$invalid`, `$error`, `$errors`, etc).
+   *
+   * More details: https://reglejs.dev/core-concepts/modifiers#validationgroups
+   */
+  validationGroups?: (fields: RegleStatus<TState, TRules>['$fields']) => TValidationGroups;
+  /**
+   * A unique identifier for the Regle instance in the devtools.
+   * @default undefined
+   */
+  id?: string | undefined;
+}
+type FieldOnlyRegleBehaviourOptions = {
+  /**
+   * Set external errors for the field.
+   */
+  externalErrors?: Ref<string[]>;
+  /**
+   * A unique identifier for the Regle instance in the devtools.
+   * @default undefined
+   */
+  id?: string | undefined;
+};
+type RegleValidationGroupEntry = RegleFieldStatus<any, any> | undefined;
+interface RegleValidationGroupOutput {
+  /** Indicates whether any field in the validation group is invalid. */
+  $invalid: boolean;
+  /** Convenience flag to easily decide if an error message should be displayed. True when any field in the group is dirty, not pending, and invalid. */
+  $error: boolean;
+  /** Indicates if any async rule in the validation group is currently running. */
+  $pending: boolean;
+  /** Indicates whether any field in the validation group has been interacted with by the user. */
+  $dirty: boolean;
+  /** Indicates whether all fields in the validation group pass validation and are dirty. */
+  $correct: boolean;
+  /** Collection of all error messages from fields in the group where $dirty equals true. */
+  $errors: string[];
+  /** Collection of all error messages from fields in the group, regardless of $dirty state. */
+  $silentErrors: string[];
+}
+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.
+   */
+  $debounce?: number;
+  /**
+   * Override the default `$edited` handler.
+   */
+  $isEdited?: isEditedHandlerFn<TValue>;
+};
+type CollectionRegleBehaviourOptions<TValue extends unknown = unknown> = FieldRegleBehaviourOptions<TValue> & {
+  /**
+   * Allow deep compare of array children to compute the `$edited` property
+   *
+   * Disabled by default for performance
+   *
+   * @default false
+   * */
+  $deepCompare?: boolean;
+};
+type ResolvedRegleBehaviourOptions = DeepMaybeRef<RequiredDeep<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<Record<string, any>, Record<string, any>, Record<string, any[]>>;
+type ShortcutCommonFn<T extends Record<string, any>> = {
+  [x: string]: (element: Omit<OmitByType<T, Function>, '~standard'>) => unknown;
+};
+type ShortcutFieldStatus<TCustomRules extends Record<string, any>> = RegleFieldStatus<any, Partial<TCustomRules> & Partial<DefaultValidators>>;
+type ShortcutNestedStatus<TCustomRules extends Record<string, any>> = RegleStatus<Record<string, any>, ReglePartialRuleTree<any, Partial<TCustomRules>>>;
+type ShortcutCollectionStatus<TCustomRules extends Record<string, any>> = RegleCollectionStatus<any[], Partial<TCustomRules> & Partial<DefaultValidators>>;
+type RegleShortcutDefinition<TCustomRules extends Record<string, any> = {}> = {
+  /**
+   * Allow you to customize the properties for every field
+   */
+  fields?: ShortcutCommonFn<ShortcutFieldStatus<TCustomRules>>;
+  /**
+   * Allow you to customize the properties for every parent of a nested object
+   */
+  nested?: ShortcutCommonFn<ShortcutNestedStatus<TCustomRules>>;
+  /**
+   * Allow you to customize the properties for every parent of a collection
+   */
+  collections?: ShortcutCommonFn<ShortcutCollectionStatus<TCustomRules>>;
+};
+type AddDollarToOptions<T extends Record<string, any>> = { [K in keyof T as `$${string & K}`]: T[K] };
+/**
+ * The main Regle type that represents a complete validation instance.
  *
- * // Can be used with Standard Schema compatible libraries
- * const result = await r$['~standard'].validate({ name: '', email: '' });
- * ```
+ * @template TState - The shape of the state object being validated
+ * @template TRules - The validation rules tree for the state
+ * @template TValidationGroups - Groups of validation rules that can be run together
+ * @template TShortcuts - Custom shortcut definitions for common validation patterns
+ * @template TAdditionalReturnProperties - Additional properties to extend the return type
  *
- * @see {@link https://reglejs.dev/common-usage/standard-schema#userules Documentation}
- */
-declare const useRules: useRulesFn<Partial<ExtendedRulesDeclarationsOverrides>, RegleShortcutDefinition<any>>;
-/**
- * Marks a value as static and treats the constructor as a regular raw Field.
- * @param value - The value to mark as static.
- * @returns The marked value.
- * @example
- * ```ts
- * const StaticDecimal = markStatic(Decimal);
- * const StaticBigWrapper = markStatic(BigWrapper);
- * ```
- */
-declare function markStatic<T extends object>(value: T): T extends RegleStaticImpl<unknown> ? T : RegleStatic<T>;
-/**
- * Infer type of the `r$` of any function returning a regle instance
- */
-type InferRegleRoot<T extends (...args: any[]) => SuperCompatibleRegle> = T extends ((...args: any[]) => infer U) ? U extends SuperCompatibleRegle ? U['r$'] : never : never;
-/**
- * Infer custom rules declared in a global configuration
- */
-type InferRegleRules<T extends useRegleFn<any, any>> = T extends useRegleFn<infer U, any> ? UnwrapRuleTree<Partial<DefaultValidators>> & UnwrapRuleTree<Partial<U>> : {};
-/**
- * Infer custom shortcuts declared in a global configuration
- */
-type InferRegleShortcuts<T extends useRegleFn<any, any>> = T extends useRegleFn<any, infer U> ? U : {};
-/**
- * Extract a set rules and setting them as required
  */
-type RegleEnforceRequiredRules<TRules extends keyof DefaultValidators> = Omit<Partial<DefaultValidatorsTree>, TRules> & { [K in TRules]-?: UnwrapRuleWithParams<DefaultValidators[K]> };
+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, TRules, TValidationGroups, TShortcuts>>;
+} & TAdditionalReturnProperties;
 /**
- * Extract a set of custom rules from a global configuration and setting them as required
-
+ * The type for a single field validation instance.
+ *
+ * @template TState - The type of the state value being validated
+ * @template TRules - The validation rules for the field
+ * @template TShortcuts - Custom shortcut definitions for common validation patterns
+ * @template TAdditionalReturnProperties - Additional properties to extend the return type
  */
-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 };
+type RegleSingleField<TState extends Maybe<PrimitiveTypes> = any, TRules extends RegleRuleDecl<NonNullable<TState>, CustomRulesDeclarationTree> = 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, TRules, TShortcuts>>;
+} & TAdditionalReturnProperties;
+type DeepReactiveState<T extends Record<string, any> | unknown | undefined> = IsAny<T> extends true ? any : IsUnknown<T> extends true ? never : ExtendOnlyRealRecord<T> extends true ? { [K in keyof T]: InferDeepReactiveState<T[K]> } : never;
+type InferDeepReactiveState<TState> = IsAny<TState> extends true ? any : IsUnknown<TState> extends true ? MaybeRef<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.
+   *
+   * Initial state is different than the original state as the initial state can be mutated when using `$reset`.
+   *
+   * This serve as the base comparison state for `$edited` property.
+   *
+   * ⚠️ This doesn't work if the state is a `reactive` object.
+   */
+  toInitialState?: boolean;
+  /**
+   * Reset validation status and reset form state to its original state.
+   *
+   * Original state is the unmutated state that was passed to the form when it was initialized.
+   */
+  toOriginalState?: boolean;
+  /**
+   * Reset validation status and reset form state to the given state
+   * Also set the new state as the initial state.
+   */
+  toState?: TState | (() => TState);
+  /**
+   * Clears the $externalErrors state back to an empty object.
+   *
+   * @default true
+   */
+  clearExternalErrors?: boolean;
+  /**
+   * Keep the validation state of the form ($dirty, $invalid, $pending etc..)
+   * Only useful if you only want to reset the form state.
+   *
+   * @default false
+   */
+  keepValidationState?: boolean;
+}, 'toInitialState' | 'toState'>;
+type ScopedInstancesRecord = Record<string, Record<string, SuperCompatibleRegleRoot>> & {
+  '~~global': Record<string, SuperCompatibleRegleRoot>;
+};
+type ScopedInstancesRecordLike = Partial<ScopedInstancesRecord>;
+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 ? isRecordLiteral<Data> extends true ? PartialFormState<Data extends Record<string, any> ? Data : {}> : MaybeOutput<Data> : HasNamedKeys<Data> extends true ? HasNamedKeys<TRules> 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> : isRecordLiteral<Data> extends true ? PartialFormState<Data extends Record<string, any> ? 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>;
+  /**
+   * Collection of all the issues, collected for all children properties and nested forms.
+   *
+   * Only contains issues from properties where $dirty equals true.
+   */
+  errors: DataTypeRegleErrors<Data>;
+} | {
+  valid: true;
+  data: IsUnknown<Data> extends true ? unknown : IsAny<Data> extends true ? unknown : IsEmptyObject<TRules> extends true ? isRecordLiteral<Data> extends true ? PartialFormState<Data extends Record<string, any> ? Data : {}> : MaybeOutput<Data> : HasNamedKeys<Data> extends true ? HasNamedKeys<TRules> 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 : {}> : isRecordLiteral<Data> extends true ? PartialFormState<Data extends Record<string, any> ? Data : {}> : MaybeOutput<Data> : unknown;
+  issues: EmptyObject;
+  errors: EmptyObject;
+};
+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 extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = RegleResult<Data, TRules> & ({
+  valid: false;
+  issues: RegleCollectionErrors<Data, true>;
+  errors: RegleCollectionErrors<Data>;
+} | {
+  valid: true;
+  issues: EmptyObject;
+  errors: EmptyObject;
+});
+type RegleFieldResult<Data extends any, TRules extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = RegleResult<Data, TRules> & ({
+  valid: false;
+  issues: RegleFieldIssue<TRules>[];
+  errors: string[];
+} | {
+  valid: true;
+  issues: [];
+  errors: [];
+});
+type $InternalRegleResult = {
+  valid: boolean;
+  data: any;
+  errors: $InternalRegleErrorTree | $InternalRegleCollectionErrors | string[];
+  issues: $InternalRegleIssuesTree | $InternalRegleCollectionIssues | RegleFieldIssue[];
+};
+type DeepSafeFormState<TState extends Record<string, any>, TRules extends ReglePartialRuleTree<Record<string, any>, CustomRulesDeclarationTree> | undefined> = IsUnknown<TState> extends true ? {} : IsAny<TState> extends true ? unknown : TRules extends undefined ? TState : HasNamedKeys<TState> extends true ? 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]-?: IsUnknown<SafeProperty<TState[K], TRules[K]>> extends true ? unknown : IsAny<TState[K]> extends true ? unknown : NonNullable<SafeProperty<TState[K], TRules[K]>> }> : TState : TState;
+type FieldHaveRequiredRule<TRule extends RegleFormPropertyType<any, any> | undefined = never> = TRule extends MaybeRefOrComputedRef<RegleRuleDecl<any, any>> ? UnwrapRef<TRule> extends infer TRuleResolved extends Record<string, any> ? { [K in keyof TRuleResolved]-?: TRuleResolved[K] extends RegleRuleDefinition<unknown, any, any[], any, any, any, any, true> ? true : false }[keyof TRuleResolved] extends false ? false : true : false : false;
+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<any>> = 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> {}
+type NarrowVariant<TRoot extends {
+  [x: string]: unknown;
+  $fields: {
+    [x: string]: unknown;
+  };
+  $value: unknown;
+}, 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]: 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> & { [K in TKey]: TValue };
+} & { [K in TKey]: TRoot[K] & {
+  $value: TValue;
+} };
+type MaybeVariantStatus<TState extends Record<string, any> | undefined = Record<string, any>, TRules extends ReglePartialRuleTree<NonNullable<TState>> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = {}, TIsUnionOverride extends boolean = false,
 /**
- * Extract custom rules and custom shortcuts and apply them to a RegleFieldStatus type
+ * Workaround for $each variants, TS generic can't detect if the Rules are an union when type is too nested, to the tuple is passed from parent
  */
-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>>;
+TRulesTuple extends readonly any[] = never> = IsUnion<NonNullable<TState>> extends true ? Or<TIsUnionOverride, IsUnion<TRules>> extends true ? (IsNever<TRulesTuple> extends true ? TRules : TRulesTuple[number]) extends infer RulesUnionTuple extends ReglePartialRuleTree<NonNullable<TState>> ? ProcessChildrenFields<NonNullable<TState>, RulesUnionTuple, TShortcuts> extends infer TChildren ? Omit<RegleStatus<NonNullable<TState>, RulesUnionTuple, TShortcuts>, '$fields'> & {
+  $fields: TChildren[keyof TChildren];
+} & (HasNamedKeys<NonNullable<TState>> extends true ? TChildren[keyof TChildren] : {}) : never : RegleStatus<JoinDiscriminatedUnions<NonNullable<TState>>, TRules extends ReglePartialRuleTree<NonNullable<JoinDiscriminatedUnions<NonNullable<TState>>>> ? TRules : EmptyObject, TShortcuts> : RegleStatus<JoinDiscriminatedUnions<NonNullable<TState>>, TRules extends ReglePartialRuleTree<NonNullable<JoinDiscriminatedUnions<NonNullable<TState>>>> ? TRules : EmptyObject, TShortcuts> : RegleStatus<TState, TRules, TShortcuts>;
+/** Helper type to extract state tuple item at index */
+type StateTupleItem<TStateTuple extends readonly any[], TIndexInt extends number> = TStateTuple[TIndexInt] extends Record<string, any> ? TStateTuple[TIndexInt] : never;
+/** Helper type to extract NonNullable state tuple item */
+type NonNullableStateTupleItem<TStateTuple extends readonly any[], TIndexInt extends number> = NonNullable<StateTupleItem<TStateTuple, TIndexInt>>;
+/** Helper type to find the corresponding variant rule */
+type VariantRuleForKey<TStateTuple extends readonly any[], TRulesTuple extends readonly any[], TIndexInt extends number, TKey> = FindCorrespondingVariant<StateTupleItem<TStateTuple, TIndexInt>, TRulesTuple> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject;
+type ProcessChildrenFields<TState extends Record<string, any> | undefined, TRules extends ReglePartialRuleTree<NonNullable<TState>>, TShortcuts extends RegleShortcutDefinition = {}> = UnionToTuple<TState> extends infer TStateTuple extends readonly any[] ? UnionToTuple<TRules> extends infer TRulesTuple extends readonly any[] ? { [TIndex in keyof TupleToPlainObj<TStateTuple>]: TIndex extends `${infer TIndexInt extends number}` ? { [TKey in keyof TStateTuple[TIndexInt] as IsEmptyObject<VariantRuleForKey<TStateTuple, TRulesTuple, TIndexInt, TKey>> extends true ? TKey extends keyof TState ? TState[TKey] extends NonNullable<TState[TKey]> ? TKey : never : never : TKey]-?: InferRegleStatusType<VariantRuleForKey<TStateTuple, TRulesTuple, TIndexInt, TKey>, NonNullableStateTupleItem<TStateTuple, TIndexInt>, TKey, TShortcuts> } & { [TKey in keyof TStateTuple[TIndexInt] as IsEmptyObject<VariantRuleForKey<TStateTuple, TRulesTuple, TIndexInt, TKey>> extends true ? TKey extends keyof TState ? TState[TKey] extends NonNullable<TState[TKey]> ? never : TKey : TKey : never]?: InferRegleStatusType<VariantRuleForKey<TStateTuple, TRulesTuple, TIndexInt, TKey>, NonNullableStateTupleItem<TStateTuple, TIndexInt>, TKey, TShortcuts> } : {} } : {} : {};
+type FindCorrespondingVariant<TState extends Record<string, any>, TRules extends readonly 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]>]: { [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 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>[]];
 /**
  * Infer safe output type from a rules object and it's original state type
  *