@regle/core 1.17.1 → 1.17.3

package/dist/regle-core.d.ts

@@ -1,5 +1,5 @@
 /**
- * @regle/core v1.17.1
+ * @regle/core v1.17.3
  * (c) 2026 Victor Garcia
  * @license MIT
  */
@@ -15,403 +15,6 @@ type RegleStaticImpl<T> = Raw<T & {
 type IsRegleStatic<T> = T extends RegleStaticImpl<T> ? true : false;
 type UnwrapStatic<T> = IsUnknown<T> extends true ? any : NonNullable<T> extends RegleStaticImpl<infer U> ? Raw<U> : UnwrapStaticSimple<T>;
 type UnwrapStaticSimple<T> = NonNullable<T> extends Array<infer U> ? Array<UnwrapStatic<U>> : isRecordLiteral<NonNullable<T>> extends true ? { [K in keyof T]: UnwrapStatic<T[K]> } : T;
-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 PromiseReturn<T> = T extends Promise<infer U> ? U : T;
-type MaybeGetter<T, V$1 = any, TAdd extends Record<string, any> = {}> = T | ((value: Ref<V$1>, index: number) => T & TAdd);
-type Unwrap<T extends MaybeRef<Record<string, any>>> = T extends Ref ? UnwrapRef<T> : UnwrapNestedRefs<T>;
-type UnwrapSimple<T extends MaybeRef<Record<string, any>>> = T extends Ref ? UnwrapRef<T> : T extends ((...args: any[]) => infer U) ? U : T;
-type ExtractFromGetter<T extends MaybeGetter<any, any, any>> = T extends ((value: Ref<any>, index: number) => infer U extends Record<string, any>) ? U : T;
-type ExtendOnlyRealRecord<T extends unknown> = NonNullable<T> extends File | Date | RegleStatic<{}> | RegleStaticImpl<{}> ? false : NonNullable<T> extends Record<string, any> ? true : false;
-type OmitByType<T extends Record<string, any>, U$1> = { [K in keyof T as T[K] extends U$1 ? never : K]: T[K] };
-type DeepMaybeRef<T extends Record<string, any>> = { [K in keyof T]: MaybeRef<T[K]> };
-type ExcludeByType<T, U$1> = { [K in keyof T as T[K] extends U$1 ? never : K]: T[K] extends U$1 ? never : T[K] };
-type PrimitiveTypes = string | number | boolean | bigint | Date | File;
-type isRecordLiteral<T extends unknown> = NonNullable<T> extends Date | File | RegleStatic<unknown> | RegleStaticImpl<unknown> ? false : NonNullable<T> extends Record<string, any> ? true : false;
-type NoInferLegacy<A$1 extends any> = [A$1][A$1 extends any ? 0 : never];
-/**
- * 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 inferRulesFn<TCustomRules extends Partial<ExtendedRulesDeclarations>> {
-  <TState$1 extends Record<string, any> | MaybeInput<PrimitiveTypes>, TRules$1 extends DeepExact<TRules$1, ReglePartialRuleTree<Unwrap<TState$1 extends Record<string, any> ? TState$1 : {}>, Partial<DefaultValidatorsTree> & TCustomRules>>, TDecl extends RegleRuleDecl<NonNullable<TState$1>, Partial<DefaultValidatorsTree> & TCustomRules>>(state: MaybeRef<TState$1> | DeepReactiveState<TState$1> | undefined, rulesFactory: TState$1 extends MaybeInput<PrimitiveTypes> ? TDecl : TState$1 extends Record<string, any> ? TRules$1 : {}): NonNullable<TState$1> extends PrimitiveTypes ? TDecl : TRules$1;
-}
-/**
- * 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<ExtendedRulesDeclarations>>;
-interface GlobalConfigOptions<TCustomRules extends Partial<ExtendedRulesDeclarations> = CustomRulesDeclarationTree, 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<ExtendedRulesDeclarations>>({
-  rules,
-  modifiers,
-  shortcuts,
-  overrides
-}: GlobalConfigOptions<TCustomRules, TShortcuts>): {
-  useRegle: useRegleFn<TCustomRules, TShortcuts>;
-  inferRules: inferRulesFn<TCustomRules>;
-  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<ExtendedRulesDeclarations>, TRootShortcuts extends RegleShortcutDefinition<{}>, TShortcuts extends RegleShortcutDefinition<Merge<TRootCustomRules, TCustomRules>>, TCustomRules extends Partial<ExtendedRulesDeclarations>>(regle: useRegleFn<TRootCustomRules, TRootShortcuts>, {
-  rules,
-  modifiers,
-  shortcuts,
-  overrides
-}: GlobalConfigOptions<TCustomRules, TShortcuts>): {
-  useRegle: useRegleFn<Merge<TRootCustomRules, TCustomRules>, TRootShortcuts & TShortcuts>;
-  inferRules: inferRulesFn<Merge<TRootCustomRules, TCustomRules>>;
-};
-type useRegleFnOptions<TState$1 extends Record<string, any> | MaybeInput<PrimitiveTypes>, TRules$1 extends DeepExact<TRules$1, ReglePartialRuleTree<Unwrap<TState$1 extends Record<string, any> ? TState$1 : {}>, Partial<ExtendedRulesDeclarations>>>, TAdditionalOptions extends Record<string, any>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>> = TState$1 extends MaybeInput<PrimitiveTypes> ? Partial<DeepMaybeRef<RegleBehaviourOptions>> & TAdditionalOptions : Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<JoinDiscriminatedUnions<TState$1 extends Record<string, any> ? Unwrap<TState$1> : {}>, TState$1 extends Record<string, any> ? (TRules$1 extends Record<string, any> ? TRules$1 : {}) : {}, TValidationGroups> & TAdditionalOptions;
-interface useRegleFn<TCustomRules extends Partial<ExtendedRulesDeclarations>, TShortcuts extends RegleShortcutDefinition<any> = never, TAdditionalReturnProperties extends Record<string, any> = {}, TAdditionalOptions extends Record<string, any> = {}> {
-  <TState$1 extends Record<string, any> | MaybeInput<PrimitiveTypes>, TRules$1 extends DeepExact<TRules$1, ReglePartialRuleTree<Unwrap<TState$1 extends Record<string, any> ? TState$1 : {}>, Partial<ExtendedRulesDeclarations> & Partial<TCustomRules>>>, TDecl extends RegleRuleDecl<NonNullable<TState$1>, Partial<ExtendedRulesDeclarations> & Partial<TCustomRules>>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>>(...params: [state: Maybe<MaybeRef<TState$1> | DeepReactiveState<TState$1>>, rulesFactory: TState$1 extends MaybeInput<PrimitiveTypes> ? MaybeRefOrGetter<TDecl> : TState$1 extends Record<string, any> ? MaybeRefOrComputedRef<TRules$1> | ((...args: any[]) => TRules$1) : {}, ...(HaveAnyRequiredProps<useRegleFnOptions<TState$1, TRules$1, TAdditionalOptions, TValidationGroups>> extends true ? [options: useRegleFnOptions<TState$1, TRules$1, TAdditionalOptions, TValidationGroups>] : [options?: useRegleFnOptions<TState$1, TRules$1, TAdditionalOptions, TValidationGroups>])]): NonNullable<TState$1> extends PrimitiveTypes ? RegleSingleField<NonNullable<TState$1>, TDecl, TShortcuts, TAdditionalReturnProperties> : Regle<TState$1 extends Record<string, any> ? Unwrap<TState$1> : {}, TRules$1 extends Record<string, any> ? TRules$1 : {}, TValidationGroups, TShortcuts, TAdditionalReturnProperties>;
-  __config?: GlobalConfigOptions<TCustomRules, TShortcuts>;
-}
-/**
- * `useRegle` serves as the foundation for validation logic.
- * It transforms your data and validation rules into a powerful, reactive validation system.
- *
- * @param state - Your form data (plain object, ref, reactive object, or structure with nested refs)
- * @param rules - Validation rules that should align with the structure of your state
- * @param modifiers - Optional configuration to customize regle behavior
- * @returns An object containing `r$` - the reactive validation state
- *
- * @example
- * ```ts
- * import { useRegle } from '@regle/core';
- * import { required, email, minLength } from '@regle/rules';
- *
- * const { r$ } = useRegle(
- *   { name: '', email: '' },
- *   {
- *     name: { required, minLength: minLength(2) },
- *     email: { required, email }
- *   }
- * );
- *
- * // Access validation state
- * r$.$valid        // Whether all validations pass
- * r$.$value        // The current form values
- * r$.name.$errors  // Errors for the name field
- *
- * // Trigger validation
- * const result = await r$.$validate();
- * ```
- *
- * @see {@link https://reglejs.dev/core-concepts/ Documentation}
- */
-declare const useRegle: useRegleFn<Partial<ExtendedRulesDeclarations>, RegleShortcutDefinition<any>, {}, {}>;
-/**
- * @internal
- * This is the internal function that creates the root storage for the Regle instance.
- * This allows shared logic between all `useRegle` like composables
- */
-declare function useRootStorage({
-  initialState,
-  originalState,
-  options,
-  scopeRules,
-  state,
-  customRules,
-  shortcuts,
-  schemaErrors,
-  schemaMode,
-  onValidate,
-  overrides
-}: {
-  scopeRules: Ref<$InternalReglePartialRuleTree>;
-  state: Ref<Record<string, any> | PrimitiveTypes>;
-  options: ResolvedRegleBehaviourOptions;
-  initialState: Ref<Record<string, any> | PrimitiveTypes>;
-  originalState: Record<string, any> | PrimitiveTypes;
-  customRules?: () => CustomRulesDeclarationTree;
-  shortcuts: RegleShortcutDefinition | undefined;
-  schemaErrors?: Ref<any | undefined>;
-  schemaMode?: boolean;
-  onValidate?: () => Promise<$InternalRegleResult>;
-  overrides: GlobalConfigOverrides | undefined;
-}): {
-  regle: $InternalRegleStatusType | undefined;
-};
-/**
- * Converts a nested `$errors` object to a flat array of error strings.
- * Useful for displaying a complete list of form errors or counting total errors.
- *
- * With the `includePath` option, returns errors in Standard Schema Issue format
- * including the path to each error field.
- *
- * @param errors - The `$errors` object from a Regle instance (e.g., `r$.$errors`)
- * @param options - Configuration options
- * @param options.includePath - If true, returns Standard Schema Issues with paths
- * @returns Array of error strings, or Standard Schema Issues if `includePath` is true
- *
- * @example
- * ```ts
- * import { flatErrors, useRegle } from '@regle/core';
- * import { required, email, minLength } from '@regle/rules';
- *
- * const { r$ } = useRegle(
- *   { name: '', email: 'invalid' },
- *   { name: { required, minLength: minLength(3) }, email: { email } }
- * );
- *
- * await r$.$validate();
- *
- * // Get flat array of error messages
- * const errors = flatErrors(r$.$errors);
- * // ['This field is required', 'Value must be a valid email address']
- *
- * // Get errors with paths (Standard Schema format)
- * const issues = flatErrors(r$.$errors, { includePath: true });
- * // [{ message: 'This field is required', path: ['name'] }, ...]
- * ```
- *
- * @see {@link https://reglejs.dev/core-concepts/displaying-errors#display-flat-errors Documentation}
- */
-declare function flatErrors(errors: $InternalRegleErrors, options: {
-  includePath: true;
-}): StandardSchemaV1.Issue[];
-declare function flatErrors(errors: $InternalRegleErrors, options?: {
-  includePath?: false;
-}): string[];
-type useRulesFnOptions<TRules$1 extends RegleUnknownRulesTree | RegleRuleDecl, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TState$1 = InferInput<TRules$1>> = Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<JoinDiscriminatedUnions<TState$1 extends Record<string, any> ? Unwrap<TState$1> : {}>, TState$1 extends Record<string, any> ? (TRules$1 extends Record<string, any> ? TRules$1 : {}) : {}, TValidationGroups>;
-interface useRulesFn<TCustomRules extends Partial<ExtendedRulesDeclarations>, TShortcuts extends RegleShortcutDefinition<any> = never> {
-  <TRules$1 extends RegleUnknownRulesTree | RegleRuleDecl, TDecl extends RegleRuleDecl<NonNullable<TState$1>, Partial<ExtendedRulesDeclarations> & TCustomRules>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TState$1 extends Record<string, any> = InferInput<TRules$1>>(rulesFactory: TState$1 extends Record<string, any> ? MaybeRef<TRules$1> | ((...args: any[]) => TRules$1) : {}, options?: useRulesFnOptions<TRules$1, TValidationGroups, TState$1>): NonNullable<TState$1> extends PrimitiveTypes ? Raw<RegleFieldStatus<NonNullable<TState$1>, TDecl, TShortcuts>> & StandardSchemaV1<TState$1> : Raw<RegleRoot<TState$1 extends Record<string, any> ? Unwrap<TState$1> : {}, TRules$1 extends Record<string, any> ? TRules$1 : {}, TValidationGroups, TShortcuts>> & StandardSchemaV1<TState$1>;
-  __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
- *
- * // 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<ExtendedRulesDeclarations>, 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$1 extends keyof DefaultValidators> = Omit<Partial<DefaultValidatorsTree>, TRules$1> & { [K in TRules$1]-?: UnwrapRuleWithParams<DefaultValidators[K]> };
-/**
- * Extract a set of custom rules from a global configuration and setting them as required
-
- */
-type RegleEnforceCustomRequiredRules<T extends useRegleFn<any, any>, TRules$1 extends keyof InferRegleRules<T>> = Omit<Partial<DefaultValidatorsTree>, TRules$1> & { [K in TRules$1]-?: T extends useRegleFn<any, any> ? K extends keyof InferRegleRules<T> ? NonNullable<UnwrapRuleWithParams<InferRegleRules<T>[K]>> : never : K extends keyof T ? NonNullable<T[K]> : never };
-/**
- * Extract custom rules and custom shortcuts and apply them to a RegleFieldStatus type
- */
-type RegleCustomFieldStatus<T extends useRegleFn<any, any>, TState$1 extends unknown = any, TRules$1 extends keyof InferRegleRules<T> = never> = RegleFieldStatus<TState$1, [TRules$1] extends [never] ? Partial<InferRegleRules<T>> : RegleEnforceCustomRequiredRules<T, TRules$1>, InferRegleShortcuts<T>>;
-/**
-/**
- * DeepExact<T, S> is a TypeScript utility type that recursively checks whether the structure of type S
- * exactly matches the structure of type T, including all nested properties.
- *
- * Used in `useRegle` and `inferRules` to enforce that the rules object matches the expected shape exactly.
- */
-type DeepExact<TInfer, TTree> = NonNullable<TTree> extends MaybeRef<RegleRuleDecl> ? TTree : NonNullable<TTree> extends MaybeRef<RegleCollectionRuleDecl> ? TTree : [keyof TInfer] extends [keyof ExtractFromGetter<TTree>] ? ExactObject<TInfer, TTree> : { [K in keyof TInfer as K extends keyof TTree ? never : K]: TypeError<`Unknown property: <${Coerce<K>}>`> };
-type ExactObject<TInfer, TTree> = { [K in keyof TTree]: NonNullable<TTree[K]> extends Record<string, any> ? ExtendOnlyRealRecord<TTree[K]> extends true ? NonNullable<TTree[K]> extends MaybeRef<RegleRuleDecl> ? TTree[K] : K extends keyof TInfer ? DeepExact<TInfer[K], NonNullable<TTree[K]>> : TTree[K] : TTree[K] : TTree[K] };
-type TypeError<Msg> = {
-  [' TypeError']: Msg;
-};
-type Coerce<T> = `${T & string}`;
 interface GlobalConfigOverrides<TValue$1 extends unknown = unknown> {
   /**
    * Override the default $edited handler.
@@ -421,12 +24,12 @@ interface GlobalConfigOverrides<TValue$1 extends unknown = unknown> {
 type isEditedHandlerFn<TValue$1 extends unknown = unknown> = (currentValue: MaybeInput<TValue$1>, initialValue: MaybeInput<TValue$1>, defaultHandlerFn: (currentValue: unknown, initialValue: unknown) => boolean) => boolean;
 interface RegleBehaviourOptions {
   /**
-   * Only display error when calling `r$.$validate()`
+   * Does not run rules until the field is dirty.
    * @default false
    */
   lazy?: boolean | undefined;
   /**
-   * Automatically set the dirty set without the need of `$value` or `$touch`.
+   * Automatically set the dirty state to true when value is changed without the need of calling `$touch`.
    * @default true
    *
    */
@@ -453,6 +56,11 @@ interface RegleBehaviourOptions {
    * @default true
    */
   clearExternalErrorsOnChange?: boolean | undefined;
+  /**
+   * Set the dirty state to true when the form is initialized.
+   * @default false
+   */
+  immediateDirty?: boolean | undefined;
 }
 interface LocalRegleBehaviourOptions<TState$1 extends Record<string, any>, TRules$1 extends ReglePartialRuleTree<TState$1, CustomRulesDeclarationTree>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = {}> {
   /**
@@ -539,220 +147,607 @@ type RegleShortcutDefinition<TCustomRules extends Record<string, any> = {}> = {
 };
 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.
- *
- * @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
+ * The main Regle type that represents a complete validation instance.
+ *
+ * @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
+ *
+ */
+type Regle<TState$1 extends Record<string, any> = EmptyObject, TRules$1 extends ReglePartialRuleTree<TState$1, CustomRulesDeclarationTree> = EmptyObject, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = {}, TShortcuts extends RegleShortcutDefinition = {}, TAdditionalReturnProperties extends Record<string, any> = {}> = {
+  /**
+   * r$ is a reactive object containing the values, errors, dirty state and all the necessary validations properties you'll need to display information.
+   *
+   * To see the list of properties: {@link https://reglejs.dev/core-concepts/validation-properties}
+   */
+  r$: Raw<RegleRoot<TState$1, TRules$1, TValidationGroups, TShortcuts>>;
+} & TAdditionalReturnProperties;
+/**
+ * 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 RegleSingleField<TState$1 extends Maybe<PrimitiveTypes> = any, TRules$1 extends RegleRuleDecl<NonNullable<TState$1>> = EmptyObject, TShortcuts extends RegleShortcutDefinition = {}, TAdditionalReturnProperties extends Record<string, any> = {}> = {
+  /**
+   * r$ is a reactive object containing the values, errors, dirty state and all the necessary validations properties you'll need to display information.
+   *
+   * To see the list of properties: {@link https://reglejs.dev/core-concepts/validation-properties}
+   */
+  r$: Raw<RegleFieldStatus<TState$1, TRules$1, TShortcuts>>;
+} & TAdditionalReturnProperties;
+type DeepReactiveState<T extends Record<string, any> | unknown | undefined> = ExtendOnlyRealRecord<T> extends true ? { [K in keyof T]: InferDeepReactiveState<T[K]> } : never;
+type InferDeepReactiveState<TState$1> = NonNullable<TState$1> extends Array<infer U extends Record<string, any>> ? DeepReactiveState<U[]> : NonNullable<TState$1> extends Date | File ? MaybeRef<TState$1> : NonNullable<TState$1> extends Record<string, any> ? DeepReactiveState<TState$1> : MaybeRef<TState$1>;
+type ResetOptions<TState$1 extends unknown> = RequireOneOrNone<{
+  /**
+   * 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$1 | (() => TState$1);
+  /**
+   * Clears the $externalErrors state back to an empty object.
+   *
+   * @default false
+   */
+  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$1 extends Record<string, any>> = [unknown] extends [TState$1] ? {} : Prettify<{ [K in keyof TState$1 as ExtendOnlyRealRecord<TState$1[K]> extends true ? never : TState$1[K] extends Array<any> ? never : K]?: MaybeOutput<TState$1[K]> } & { [K in keyof TState$1 as ExtendOnlyRealRecord<TState$1[K]> extends true ? K : TState$1[K] extends Array<any> ? K : never]: NonNullable<TState$1[K]> extends Array<infer U extends Record<string, any>> ? PartialFormState<U>[] : PartialFormState<TState$1[K]> }>;
+type RegleResult<Data extends Record<string, any> | any[] | unknown, TRules$1 extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = {
+  /** The result of the validation */
+  valid: false;
+  /** Output data, filter the result by checking the `valid` property */
+  data: IsUnknown<Data> extends true ? unknown : IsAny<Data> extends true ? unknown : HasNamedKeys<Data> extends true ? NonNullable<Data> extends Date | File ? MaybeOutput<Raw<Data>> : NonNullable<Data> extends Array<infer U extends Record<string, any>> ? PartialFormState<U>[] : NonNullable<Data> extends Record<string, any> ? PartialFormState<NonNullable<Data>> : MaybeOutput<Data> : unknown;
+  /**
+   * Collection of all the error messages, collected for all children properties and nested forms.
+   *
+   * Only contains errors from properties where $dirty equals true.
+   * */
+  issues: DataTypeRegleIssues<Data, TRules$1>;
+  /**
+   * 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 : HasNamedKeys<Data> extends true ? NonNullable<Data> extends Array<infer U extends Record<string, any>> ? DeepSafeFormState<U, TRules$1>[] : NonNullable<Data> extends Date | File ? SafeFieldProperty<Raw<NonNullable<Data>>, TRules$1> : NonNullable<Data> extends Record<string, any> ? DeepSafeFormState<NonNullable<Data>, TRules$1> : SafeFieldProperty<Data, TRules$1> : unknown;
+  issues: EmptyObject;
+  errors: EmptyObject;
+};
+type DataTypeRegleIssues<TData extends Record<string, any> | any[] | unknown, TRules$1 extends ReglePartialRuleTree<any> | RegleFormPropertyType<any> = never> = HasNamedKeys<TData> extends true ? NonNullable<TData> extends Array<infer U> ? isRecordLiteral<U> extends true ? RegleFieldIssue<TRules$1>[] : RegleCollectionErrors<TData, true> : isRecordLiteral<TData> extends true ? RegleIssuesTree<TData> : RegleFieldIssue<TRules$1>[] : RegleFieldIssue | RegleCollectionErrors<TData, true> | RegleIssuesTree<TData>;
+type DataTypeRegleErrors<TData extends Record<string, any> | any[] | unknown> = HasNamedKeys<TData> extends true ? NonNullable<TData> extends Array<infer U> ? isRecordLiteral<U> extends true ? string[] : RegleCollectionErrors<TData> : isRecordLiteral<TData> extends true ? RegleErrorTree<TData> : string[] : string[] | RegleErrorTree<TData> | RegleCollectionErrors<TData>;
+type RegleCollectionResult<Data extends any[], TRules$1 extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = RegleResult<Data, TRules$1> & ({
+  valid: false;
+  issues: RegleCollectionErrors<Data, true>;
+  errors: RegleCollectionErrors<Data>;
+} | {
+  valid: true;
+  issues: EmptyObject;
+  errors: EmptyObject;
+});
+type RegleFieldResult<Data extends any, TRules$1 extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = RegleResult<Data, TRules$1> & ({
+  valid: false;
+  issues: RegleFieldIssue<TRules$1>[];
+  errors: string[];
+} | {
+  valid: true;
+  issues: [];
+  errors: [];
+});
+type $InternalRegleResult = {
+  valid: boolean;
+  data: any;
+  errors: $InternalRegleErrorTree | $InternalRegleCollectionErrors | string[];
+  issues: $InternalRegleIssuesTree | $InternalRegleCollectionIssues | RegleFieldIssue[];
+};
+type DeepSafeFormState<TState$1 extends Record<string, any>, TRules$1 extends ReglePartialRuleTree<Record<string, any>, CustomRulesDeclarationTree> | RegleFormPropertyType<any, any> | undefined> = [unknown] extends [TState$1] ? {} : TRules$1 extends undefined ? TState$1 : TRules$1 extends ReglePartialRuleTree<TState$1, CustomRulesDeclarationTree> ? Prettify<{ [K in keyof TState$1 as IsPropertyOutputRequired<TState$1[K], TRules$1[K]> extends false ? K : never]?: SafeProperty<TState$1[K], TRules$1[K]> extends MaybeInput<infer M> ? MaybeOutput<M> : SafeProperty<TState$1[K], TRules$1[K]> } & { [K in keyof TState$1 as IsPropertyOutputRequired<TState$1[K], TRules$1[K]> extends false ? never : K]-?: unknown extends SafeProperty<TState$1[K], TRules$1[K]> ? unknown : NonNullable<SafeProperty<TState$1[K], TRules$1[K]>> }> : TState$1;
+type FieldHaveRequiredRule<TRule extends RegleFormPropertyType<any, any> | undefined = never> = TRule extends MaybeRefOrComputedRef<RegleRuleDecl<any, any>> ? [unknown] extends UnwrapRef<TRule>['required'] ? NonNullable<UnwrapRef<TRule>['literal']> extends RegleRuleDefinition<any, any[], any, any, any, any> ? true : false : NonNullable<UnwrapRef<TRule>['required']> extends UnwrapRef<TRule>['required'] ? UnwrapRef<TRule>['required'] extends RegleRuleDefinition<any, infer Params, any, any, any, any> ? Params extends never[] ? true : false : false : false : false;
+type ObjectHaveAtLeastOneRequiredField<TState$1 extends Record<string, any>, TRule extends ReglePartialRuleTree<TState$1, any>> = TState$1 extends Maybe<TState$1> ? { [K in keyof NonNullable<TState$1>]-?: IsPropertyOutputRequired<NonNullable<TState$1>[K], TRule[K]> }[keyof TState$1] extends false ? false : true : true;
+type ArrayHaveAtLeastOneRequiredField<TState$1 extends Maybe<any[]>, TRule extends RegleCollectionRuleDecl<TState$1>> = TState$1 extends Maybe<TState$1> ? FieldHaveRequiredRule<Omit<TRule, '$each'> extends MaybeRef<RegleRuleDecl> ? Omit<UnwrapRef<TRule>, '$each'> : {}> | ObjectHaveAtLeastOneRequiredField<ArrayElement<NonNullable<TState$1>>, ExtractFromGetter<TRule['$each']> extends undefined ? {} : NonNullable<ExtractFromGetter<TRule['$each']>>> extends false ? false : true : true;
+type SafeProperty<TState$1, TRule extends RegleFormPropertyType<any, any> | undefined> = unknown extends TState$1 ? unknown : TRule extends RegleCollectionRuleDecl<any, any> ? TState$1 extends Array<infer U extends Record<string, any>> ? DeepSafeFormState<U, ExtractFromGetter<TRule['$each']>>[] : TState$1 : TRule extends ReglePartialRuleTree<any, any> ? ExtendOnlyRealRecord<TState$1> extends true ? DeepSafeFormState<NonNullable<TState$1> extends Record<string, any> ? JoinDiscriminatedUnions<NonNullable<TState$1>> : {}, TRule> : TRule extends MaybeRef<RegleRuleDecl<any, any>> ? FieldHaveRequiredRule<UnwrapRef<TRule>> extends true ? TState$1 : MaybeOutput<TState$1> : TState$1 : TState$1;
+type IsPropertyOutputRequired<TState$1, TRule extends RegleFormPropertyType<any, any> | undefined> = [unknown] extends [TState$1] ? unknown : NonNullable<TState$1> extends Array<any> ? TRule extends RegleCollectionRuleDecl<any, any> ? ArrayHaveAtLeastOneRequiredField<NonNullable<TState$1>, TRule> extends false ? false : true : false : TRule extends ReglePartialRuleTree<any, any> ? ExtendOnlyRealRecord<TState$1> extends true ? ObjectHaveAtLeastOneRequiredField<NonNullable<TState$1> extends Record<string, any> ? NonNullable<TState$1> : {}, TRule> extends false ? false : true : TRule extends MaybeRef<RegleRuleDecl<any, any>> ? FieldHaveRequiredRule<UnwrapRef<TRule>> extends false ? false : true : false : false;
+type SafeFieldProperty<TState$1, TRule extends RegleFormPropertyType<any, any> | undefined = never> = FieldHaveRequiredRule<TRule> extends true ? NonNullable<TState$1> : MaybeOutput<TState$1>;
+/** 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$1 extends keyof TRoot, TValue$1 extends (LazyJoinDiscriminatedUnions<Exclude<TRoot[TKey$1], RegleCollectionStatus<any, any, any> | RegleStatus<any, any, any> | NarrowVariantExtracts[keyof NarrowVariantExtracts]>> extends {
+  $value: infer V;
+} ? V : unknown)> = Extract<TRoot, { [K in TKey$1]: RegleFieldStatus<TValue$1, any, any> | RegleFieldStatus<MaybeInput<TValue$1>, any, any> | (IsEmptyObject<NarrowVariantFieldExtracts<TValue$1>> extends true ? EmptyObject : NarrowVariantFieldExtracts<TValue$1>[keyof NarrowVariantFieldExtracts<TValue$1>]) }> & {
+  $fields: Extract<TRoot['$fields'], { [K in TKey$1]: RegleFieldStatus<TValue$1, any, any> | RegleFieldStatus<MaybeInput<TValue$1>, any, any> | (IsEmptyObject<NarrowVariantFieldExtracts<TValue$1>> extends true ? EmptyObject : NarrowVariantFieldExtracts<TValue$1>[keyof NarrowVariantFieldExtracts<TValue$1>]) }> & { [K in TKey$1]: TRoot[K] & {
+    $value: TValue$1;
+  } };
+} & {
+  $value: Omit<TRoot['$value'], TKey$1> & { [K in TKey$1]: TValue$1 };
+} & { [K in TKey$1]: TRoot[K] & {
+  $value: TValue$1;
+} };
+type MaybeVariantStatus<TState$1 extends Record<string, any> | undefined = Record<string, any>, TRules$1 extends ReglePartialRuleTree<NonNullable<TState$1>> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = {}> = IsUnion<NonNullable<TState$1>> extends true ? Omit<RegleStatus<TState$1, TRules$1, TShortcuts>, '$fields'> & {
+  $fields: ProcessChildrenFields<TState$1, TRules$1, TShortcuts>[keyof ProcessChildrenFields<TState$1, TRules$1, TShortcuts>];
+} & (HasNamedKeys<TState$1> extends true ? ProcessChildrenFields<TState$1, TRules$1, TShortcuts>[keyof ProcessChildrenFields<TState$1, TRules$1, TShortcuts>] : {}) : RegleStatus<TState$1, TRules$1, TShortcuts>;
+type ProcessChildrenFields<TState$1 extends Record<string, any> | undefined, TRules$1 extends ReglePartialRuleTree<NonNullable<TState$1>>, TShortcuts extends RegleShortcutDefinition = {}> = { [TIndex in keyof TupleToPlainObj<UnionToTuple<TState$1>>]: TIndex extends `${infer TIndexInt extends number}` ? { [TKey in keyof UnionToTuple<TState$1>[TIndexInt] as IsEmptyObject<FindCorrespondingVariant<UnionToTuple<TState$1>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState$1>[TIndexInt] : never, UnionToTuple<TRules$1>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject> extends true ? TKey extends keyof TState$1 ? TState$1[TKey] extends NonNullable<TState$1[TKey]> ? TKey : never : never : TKey]-?: InferRegleStatusType<FindCorrespondingVariant<UnionToTuple<TState$1>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState$1>[TIndexInt] : never, UnionToTuple<TRules$1>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject, NonNullable<UnionToTuple<TState$1>[TIndexInt]>, TKey, TShortcuts> } & { [TKey in keyof UnionToTuple<TState$1>[TIndexInt] as IsEmptyObject<FindCorrespondingVariant<UnionToTuple<TState$1>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState$1>[TIndexInt] : never, UnionToTuple<TRules$1>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject> extends true ? TKey extends keyof TState$1 ? TState$1[TKey] extends NonNullable<TState$1[TKey]> ? never : TKey : TKey : never]?: InferRegleStatusType<FindCorrespondingVariant<UnionToTuple<TState$1>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState$1>[TIndexInt] : never, UnionToTuple<TRules$1>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject, NonNullable<UnionToTuple<TState$1>[TIndexInt]>, TKey, TShortcuts> } : {} };
+type FindCorrespondingVariant<TState$1 extends Record<string, any>, TRules$1 extends any[]> = TRules$1 extends [infer F, ...infer R] ? F extends ReglePartialRuleTree<TState$1> ? [F] : FindCorrespondingVariant<TState$1, R> : [];
+type PossibleLiteralTypes<T extends Record<string, any>, TKey$1 extends keyof T> = unknown extends T[TKey$1] ? {
+  [x: string]: { [K in TKey$1]-?: Omit<RegleRuleDecl<any, Partial<ExtendedRulesDeclarations>>, 'literal'> & {
+    literal?: RegleRuleDefinition<any, [literal: any], false, boolean, any, string | number>;
+  } };
+} : { [TVal in NonNullable<T[TKey$1]>]: { [K in TKey$1]-?: Omit<RegleRuleDecl<TVal, Partial<ExtendedRulesDeclarations>>, 'literal'> & {
+  literal?: RegleRuleDefinition<MaybeInput<TVal>, [literal: TVal], false, boolean, MaybeInput<TVal>, string | number>;
+} } };
+type RequiredForm<T extends Record<string, any>, TKey$1 extends keyof T> = Omit<ReglePartialRuleTree<T>, TKey$1> & PossibleLiteralTypes<T, TKey$1>[keyof PossibleLiteralTypes<T, TKey$1>];
+type VariantTuple<T extends Record<string, any>, TKey$1 extends keyof T> = [RequiredForm<T, TKey$1>, ...RequiredForm<T, TKey$1>[]];
+/**
+ * Combine all members of a union type, merging types for each key, and keeping loose types
+ */
+type JoinDiscriminatedUnions<TUnion extends unknown> = HasNamedKeys<TUnion> extends true ? isRecordLiteral<TUnion> extends true ? HasCommonKey<UnionToTuple<NonNullable<TUnion>>, keyof NormalizeUnion<NonNullable<TUnion>>> extends true ? Prettify<Partial<UnionToIntersection<RemoveCommonKey<UnionToTuple<NonNullable<TUnion>>, keyof NormalizeUnion<NonNullable<TUnion>>>[number]>> & Pick<NormalizeUnion<NonNullable<TUnion>>, keyof NormalizeUnion<NonNullable<TUnion>>>> : DumbJoinDiscriminatedUnions<TUnion> : TUnion : TUnion;
+/**
+ * Combine all members of a union type on one level and not nested.
+ */
+type LazyJoinDiscriminatedUnions<TUnion extends unknown> = isRecordLiteral<TUnion> extends true ? Prettify<Partial<UnionToIntersection<RemoveCommonKey<UnionToTuple<TUnion>, keyof NonNullable<TUnion>>[number]>> & Pick<NonNullable<TUnion>, keyof NonNullable<TUnion>>> : TUnion;
+type DumbJoinDiscriminatedUnions<TUnion extends unknown> = isRecordLiteral<TUnion> extends true ? Prettify<Partial<UnionToIntersection<TUnion>> & Pick<NonNullable<TUnion>, keyof NonNullable<TUnion>>> : TUnion;
+type RemoveCommonKey<T extends readonly any[], K$1 extends PropertyKey> = T extends [infer F, ...infer R] ? [Prettify<Omit<F, K$1>>, ...RemoveCommonKey<R, K$1>] : [];
+type HasCommonKey<T extends readonly any[], K$1 extends PropertyKey> = T extends [infer F, ...infer R] ? K$1 extends keyof F ? true : HasCommonKey<R, K$1> : false;
+/**
+ * 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$1 extends string> = K$1 extends keyof O ? O[K$1] : 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> = 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> = 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 PromiseReturn<T> = T extends Promise<infer U> ? U : T;
+type MaybeGetter<T, V$1 = any, TAdd extends Record<string, any> = {}> = T | ((value: Ref<V$1>, index: number) => T & TAdd);
+type MaybeComputedOrGetter<T> = MaybeRefOrComputedRef<T> | ((...args: any[]) => T);
+type Unwrap<T extends MaybeRef<unknown>> = T extends Ref ? UnwrapRef<T> : UnwrapNestedRefs<T>;
+type UnwrapSimple<T extends MaybeRef<Record<string, any>>> = T extends MaybeComputedOrGetter<infer U> ? U : T extends Ref<infer U> ? U : T extends ((...args: any[]) => infer U) ? U : T;
+type ExtractFromGetter<T extends MaybeGetter<any, any, any>> = T extends ((value: Ref<any>, index: number) => infer U extends Record<string, any>) ? U : T;
+type ExtendOnlyRealRecord<T extends unknown> = NonNullable<T> extends File | Date | RegleStatic<{}> | RegleStaticImpl<{}> ? false : NonNullable<T> extends Record<string, any> ? true : false;
+type OmitByType<T extends Record<string, any>, U$1> = { [K in keyof T as T[K] extends U$1 ? never : K]: T[K] };
+type DeepMaybeRef<T extends Record<string, any>> = { [K in keyof T]: MaybeRef<T[K]> };
+type ExcludeByType<T, U$1> = { [K in keyof T as T[K] extends U$1 ? never : K]: T[K] extends U$1 ? never : T[K] };
+type PrimitiveTypes = string | number | boolean | bigint | Date | File;
+type isRecordLiteral<T extends unknown> = NonNullable<T> extends Date | File | RegleStatic<unknown> | RegleStaticImpl<unknown> ? false : NonNullable<T> extends Record<string, any> ? true : false;
+type NoInferLegacy<A$1 extends any> = [A$1][A$1 extends any ? 0 : never];
+/**
+ * Extract the element type from an array.
  *
+ * @example
+ * ```ts
+ * type Element = ArrayElement<[1, 2, 3]>; // number
+ * ```
  */
-type Regle<TState$1 extends Record<string, any> = EmptyObject, TRules$1 extends ReglePartialRuleTree<TState$1, CustomRulesDeclarationTree> = EmptyObject, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = {}, TShortcuts extends RegleShortcutDefinition = {}, TAdditionalReturnProperties extends Record<string, any> = {}> = {
-  /**
-   * r$ is a reactive object containing the values, errors, dirty state and all the necessary validations properties you'll need to display information.
-   *
-   * To see the list of properties: {@link https://reglejs.dev/core-concepts/validation-properties}
-   */
-  r$: Raw<RegleRoot<TState$1, TRules$1, TValidationGroups, TShortcuts>>;
-} & TAdditionalReturnProperties;
+type ArrayElement<T> = T extends Array<infer U> ? U : never;
 /**
- * The type for a single field validation instance.
+ * Declares a tuple that must have at least one element
+ */
+type NonEmptyTuple<T> = [T, ...T[]] | T[];
+interface inferRulesFn<TCustomRules extends Partial<ExtendedRulesDeclarations>> {
+  <TState$1 extends MaybeRef<Record<string, any> | MaybeInput<PrimitiveTypes>>, TRules$1 extends ReglePartialRuleTree<Unwrap<TState$1 extends Record<string, any> ? TState$1 : {}>, Partial<DefaultValidatorsTree> & TCustomRules>, TDecl extends RegleRuleDecl<NonNullable<TState$1>, Partial<DefaultValidatorsTree> & TCustomRules>>(state: Maybe<TState$1> | DeepReactiveState<TState$1>, rulesFactory: Unwrap<TState$1> extends MaybeInput<PrimitiveTypes> ? TDecl : Unwrap<TState$1> extends Record<string, any> ? TRules$1 : {}): NonNullable<Unwrap<TState$1>> extends PrimitiveTypes ? TDecl : TRules$1;
+}
+/**
+ * Type helper to provide autocomplete and type-checking for your form rules.
+ * It returns the rules without any processing - useful with computed rules.
  *
- * @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
+ * @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}
  */
-type RegleSingleField<TState$1 extends Maybe<PrimitiveTypes> = any, TRules$1 extends RegleRuleDecl<NonNullable<TState$1>> = EmptyObject, TShortcuts extends RegleShortcutDefinition = {}, TAdditionalReturnProperties extends Record<string, any> = {}> = {
-  /**
-   * r$ is a reactive object containing the values, errors, dirty state and all the necessary validations properties you'll need to display information.
-   *
-   * To see the list of properties: {@link https://reglejs.dev/core-concepts/validation-properties}
-   */
-  r$: Raw<RegleFieldStatus<TState$1, TRules$1, TShortcuts>>;
-} & TAdditionalReturnProperties;
-type DeepReactiveState<T extends Record<string, any> | unknown | undefined> = ExtendOnlyRealRecord<T> extends true ? { [K in keyof T]: InferDeepReactiveState<T[K]> } : never;
-type InferDeepReactiveState<TState$1> = NonNullable<TState$1> extends Array<infer U extends Record<string, any>> ? DeepReactiveState<U[]> : NonNullable<TState$1> extends Date | File ? MaybeRef<TState$1> : NonNullable<TState$1> extends Record<string, any> ? DeepReactiveState<TState$1> : MaybeRef<TState$1>;
-type ResetOptions<TState$1 extends unknown> = RequireOneOrNone<{
+declare const inferRules: inferRulesFn<Partial<ExtendedRulesDeclarations>>;
+interface GlobalConfigOptions<TCustomRules extends Partial<ExtendedRulesDeclarations> = CustomRulesDeclarationTree, TShortcuts extends RegleShortcutDefinition<any> = never> {
   /**
-   * 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.
+   * Declare custom rules to be used globally or override the default rules messages.
    *
-   * ⚠️ This doesn't work if the state is a `reactive` object.
-   */
-  toInitialState?: boolean;
-  /**
-   * Reset validation status and reset form state to its original state.
+   * Ex:
+   * ```ts
+   * import { defineRegleConfig } from '@regle/core';
+   * import { required, withMessage } from '@regle/rules';
    *
-   * 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.
+   * 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}
    */
-  toState?: TState$1 | (() => TState$1);
+  rules?: () => TCustomRules;
   /**
-   * Clears the $externalErrors state back to an empty object.
+   * Define modifiers to be used globally.
    *
-   * @default false
-   */
-  clearExternalErrors?: boolean;
-  /**
-   * Keep the validation state of the form ($dirty, $invalid, $pending etc..)
-   * Only useful if you only want to reset the form state.
+   * Ex:
+   * ```ts
+   * import { defineRegleConfig } from '@regle/core';
    *
-   * @default false
+   * export const { useRegle, inferRules, useRules } = defineRegleConfig({
+   *   modifiers: {
+   *     lazy: true,
+   *     rewardEarly: true
+   *   }
+   * });
+   * ```
+   * @see {@link https://reglejs.dev/advanced-usage/global-config#declare-modifiers Documentation}
    */
-  keepValidationState?: boolean;
-}, 'toInitialState' | 'toState'>;
-type ScopedInstancesRecord = Record<string, Record<string, SuperCompatibleRegleRoot>> & {
-  '~~global': Record<string, SuperCompatibleRegleRoot>;
-};
-type ScopedInstancesRecordLike = Partial<ScopedInstancesRecord>;
-type PartialFormState<TState$1 extends Record<string, any>> = [unknown] extends [TState$1] ? {} : Prettify<{ [K in keyof TState$1 as ExtendOnlyRealRecord<TState$1[K]> extends true ? never : TState$1[K] extends Array<any> ? never : K]?: MaybeOutput<TState$1[K]> } & { [K in keyof TState$1 as ExtendOnlyRealRecord<TState$1[K]> extends true ? K : TState$1[K] extends Array<any> ? K : never]: NonNullable<TState$1[K]> extends Array<infer U extends Record<string, any>> ? PartialFormState<U>[] : PartialFormState<TState$1[K]> }>;
-type RegleResult<Data extends Record<string, any> | any[] | unknown, TRules$1 extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = {
-  /** The result of the validation */
-  valid: false;
-  /** Output data, filter the result by checking the `valid` property */
-  data: IsUnknown<Data> extends true ? unknown : IsAny<Data> extends true ? unknown : HasNamedKeys<Data> extends true ? NonNullable<Data> extends Date | File ? MaybeOutput<Raw<Data>> : NonNullable<Data> extends Array<infer U extends Record<string, any>> ? PartialFormState<U>[] : NonNullable<Data> extends Record<string, any> ? PartialFormState<NonNullable<Data>> : MaybeOutput<Data> : unknown;
+  modifiers?: RegleBehaviourOptions;
   /**
-   * Collection of all the error messages, collected for all children properties and nested forms.
+   * Define reusable validation shortcuts to be used globally.
    *
-   * Only contains errors from properties where $dirty equals true.
-   * */
-  issues: DataTypeRegleIssues<Data, TRules$1>;
-  /**
-   * Collection of all the issues, collected for all children properties and nested forms.
+   * Ex:
+   * ```ts
+   * import { defineRegleConfig } from '@regle/core';
    *
-   * Only contains issues from properties where $dirty equals true.
+   * 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}
    */
-  errors: DataTypeRegleErrors<Data>;
-} | {
-  valid: true;
-  data: IsUnknown<Data> extends true ? unknown : IsAny<Data> extends true ? unknown : HasNamedKeys<Data> extends true ? NonNullable<Data> extends Array<infer U extends Record<string, any>> ? DeepSafeFormState<U, TRules$1>[] : NonNullable<Data> extends Date | File ? SafeFieldProperty<Raw<NonNullable<Data>>, TRules$1> : NonNullable<Data> extends Record<string, any> ? DeepSafeFormState<NonNullable<Data>, TRules$1> : SafeFieldProperty<Data, TRules$1> : unknown;
-  issues: EmptyObject;
-  errors: EmptyObject;
+  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<ExtendedRulesDeclarations>>({
+  rules,
+  modifiers,
+  shortcuts,
+  overrides
+}: GlobalConfigOptions<TCustomRules, TShortcuts>): {
+  useRegle: useRegleFn<TCustomRules, TShortcuts>;
+  inferRules: inferRulesFn<TCustomRules>;
+  useRules: useRulesFn<TCustomRules, TShortcuts>;
 };
-type DataTypeRegleIssues<TData extends Record<string, any> | any[] | unknown, TRules$1 extends ReglePartialRuleTree<any> | RegleFormPropertyType<any> = never> = HasNamedKeys<TData> extends true ? NonNullable<TData> extends Array<infer U> ? isRecordLiteral<U> extends true ? RegleFieldIssue<TRules$1>[] : RegleCollectionErrors<TData, true> : isRecordLiteral<TData> extends true ? RegleIssuesTree<TData> : RegleFieldIssue<TRules$1>[] : RegleFieldIssue | RegleCollectionErrors<TData, true> | RegleIssuesTree<TData>;
-type DataTypeRegleErrors<TData extends Record<string, any> | any[] | unknown> = HasNamedKeys<TData> extends true ? NonNullable<TData> extends Array<infer U> ? isRecordLiteral<U> extends true ? string[] : RegleCollectionErrors<TData> : isRecordLiteral<TData> extends true ? RegleErrorTree<TData> : string[] : string[] | RegleErrorTree<TData> | RegleCollectionErrors<TData>;
-type RegleCollectionResult<Data extends any[], TRules$1 extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = RegleResult<Data, TRules$1> & ({
-  valid: false;
-  issues: RegleCollectionErrors<Data, true>;
-  errors: RegleCollectionErrors<Data>;
-} | {
-  valid: true;
-  issues: EmptyObject;
-  errors: EmptyObject;
-});
-type RegleFieldResult<Data extends any, TRules$1 extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = RegleResult<Data, TRules$1> & ({
-  valid: false;
-  issues: RegleFieldIssue<TRules$1>[];
-  errors: string[];
-} | {
-  valid: true;
-  issues: [];
-  errors: [];
-});
-type $InternalRegleResult = {
-  valid: boolean;
-  data: any;
-  errors: $InternalRegleErrorTree | $InternalRegleCollectionErrors | string[];
-  issues: $InternalRegleIssuesTree | $InternalRegleCollectionIssues | RegleFieldIssue[];
+/**
+ * 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<ExtendedRulesDeclarations>, TRootShortcuts extends RegleShortcutDefinition<{}>, TShortcuts extends RegleShortcutDefinition<Merge<TRootCustomRules, TCustomRules>>, TCustomRules extends Partial<ExtendedRulesDeclarations>>(regle: useRegleFn<TRootCustomRules, TRootShortcuts>, {
+  rules,
+  modifiers,
+  shortcuts,
+  overrides
+}: GlobalConfigOptions<TCustomRules, TShortcuts>): {
+  useRegle: useRegleFn<Merge<TRootCustomRules, TCustomRules>, TRootShortcuts & TShortcuts>;
+  inferRules: inferRulesFn<Merge<TRootCustomRules, TCustomRules>>;
 };
-type DeepSafeFormState<TState$1 extends Record<string, any>, TRules$1 extends ReglePartialRuleTree<Record<string, any>, CustomRulesDeclarationTree> | RegleFormPropertyType<any, any> | undefined> = [unknown] extends [TState$1] ? {} : TRules$1 extends undefined ? TState$1 : TRules$1 extends ReglePartialRuleTree<TState$1, CustomRulesDeclarationTree> ? Prettify<{ [K in keyof TState$1 as IsPropertyOutputRequired<TState$1[K], TRules$1[K]> extends false ? K : never]?: SafeProperty<TState$1[K], TRules$1[K]> extends MaybeInput<infer M> ? MaybeOutput<M> : SafeProperty<TState$1[K], TRules$1[K]> } & { [K in keyof TState$1 as IsPropertyOutputRequired<TState$1[K], TRules$1[K]> extends false ? never : K]-?: unknown extends SafeProperty<TState$1[K], TRules$1[K]> ? unknown : NonNullable<SafeProperty<TState$1[K], TRules$1[K]>> }> : TState$1;
-type FieldHaveRequiredRule<TRule extends RegleFormPropertyType<any, any> | undefined = never> = TRule extends MaybeRefOrComputedRef<RegleRuleDecl<any, any>> ? [unknown] extends UnwrapRef<TRule>['required'] ? NonNullable<UnwrapRef<TRule>['literal']> extends RegleRuleDefinition<any, any[], any, any, any, any> ? true : false : NonNullable<UnwrapRef<TRule>['required']> extends UnwrapRef<TRule>['required'] ? UnwrapRef<TRule>['required'] extends RegleRuleDefinition<any, infer Params, any, any, any, any> ? Params extends never[] ? true : false : false : false : false;
-type ObjectHaveAtLeastOneRequiredField<TState$1 extends Record<string, any>, TRule extends ReglePartialRuleTree<TState$1, any>> = TState$1 extends Maybe<TState$1> ? { [K in keyof NonNullable<TState$1>]-?: IsPropertyOutputRequired<NonNullable<TState$1>[K], TRule[K]> }[keyof TState$1] extends false ? false : true : true;
-type ArrayHaveAtLeastOneRequiredField<TState$1 extends Maybe<any[]>, TRule extends RegleCollectionRuleDecl<TState$1>> = TState$1 extends Maybe<TState$1> ? FieldHaveRequiredRule<Omit<TRule, '$each'> extends MaybeRef<RegleRuleDecl> ? Omit<UnwrapRef<TRule>, '$each'> : {}> | ObjectHaveAtLeastOneRequiredField<ArrayElement<NonNullable<TState$1>>, ExtractFromGetter<TRule['$each']> extends undefined ? {} : NonNullable<ExtractFromGetter<TRule['$each']>>> extends false ? false : true : true;
-type SafeProperty<TState$1, TRule extends RegleFormPropertyType<any, any> | undefined> = unknown extends TState$1 ? unknown : TRule extends RegleCollectionRuleDecl<any, any> ? TState$1 extends Array<infer U extends Record<string, any>> ? DeepSafeFormState<U, ExtractFromGetter<TRule['$each']>>[] : TState$1 : TRule extends ReglePartialRuleTree<any, any> ? ExtendOnlyRealRecord<TState$1> extends true ? DeepSafeFormState<NonNullable<TState$1> extends Record<string, any> ? JoinDiscriminatedUnions<NonNullable<TState$1>> : {}, TRule> : TRule extends MaybeRef<RegleRuleDecl<any, any>> ? FieldHaveRequiredRule<UnwrapRef<TRule>> extends true ? TState$1 : MaybeOutput<TState$1> : TState$1 : TState$1;
-type IsPropertyOutputRequired<TState$1, TRule extends RegleFormPropertyType<any, any> | undefined> = [unknown] extends [TState$1] ? unknown : NonNullable<TState$1> extends Array<any> ? TRule extends RegleCollectionRuleDecl<any, any> ? ArrayHaveAtLeastOneRequiredField<NonNullable<TState$1>, TRule> extends false ? false : true : false : TRule extends ReglePartialRuleTree<any, any> ? ExtendOnlyRealRecord<TState$1> extends true ? ObjectHaveAtLeastOneRequiredField<NonNullable<TState$1> extends Record<string, any> ? NonNullable<TState$1> : {}, TRule> extends false ? false : true : TRule extends MaybeRef<RegleRuleDecl<any, any>> ? FieldHaveRequiredRule<UnwrapRef<TRule>> extends false ? false : true : false : false;
-type SafeFieldProperty<TState$1, TRule extends RegleFormPropertyType<any, any> | undefined = never> = FieldHaveRequiredRule<TRule> extends true ? NonNullable<TState$1> : MaybeOutput<TState$1>;
-/** 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$1 extends keyof TRoot, TValue$1 extends (LazyJoinDiscriminatedUnions<Exclude<TRoot[TKey$1], RegleCollectionStatus<any, any, any> | RegleStatus<any, any, any> | NarrowVariantExtracts[keyof NarrowVariantExtracts]>> extends {
-  $value: infer V;
-} ? V : unknown)> = Extract<TRoot, { [K in TKey$1]: RegleFieldStatus<TValue$1, any, any> | RegleFieldStatus<MaybeInput<TValue$1>, any, any> | (IsEmptyObject<NarrowVariantFieldExtracts<TValue$1>> extends true ? EmptyObject : NarrowVariantFieldExtracts<TValue$1>[keyof NarrowVariantFieldExtracts<TValue$1>]) }> & {
-  $fields: Extract<TRoot['$fields'], { [K in TKey$1]: RegleFieldStatus<TValue$1, any, any> | RegleFieldStatus<MaybeInput<TValue$1>, any, any> | (IsEmptyObject<NarrowVariantFieldExtracts<TValue$1>> extends true ? EmptyObject : NarrowVariantFieldExtracts<TValue$1>[keyof NarrowVariantFieldExtracts<TValue$1>]) }> & { [K in TKey$1]: TRoot[K] & {
-    $value: TValue$1;
-  } };
-} & {
-  $value: Omit<TRoot['$value'], TKey$1> & { [K in TKey$1]: TValue$1 };
-} & { [K in TKey$1]: TRoot[K] & {
-  $value: TValue$1;
-} };
-type MaybeVariantStatus<TState$1 extends Record<string, any> | undefined = Record<string, any>, TRules$1 extends ReglePartialRuleTree<NonNullable<TState$1>> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = {}> = IsUnion<NonNullable<TState$1>> extends true ? Omit<RegleStatus<TState$1, TRules$1, TShortcuts>, '$fields'> & {
-  $fields: ProcessChildrenFields<TState$1, TRules$1, TShortcuts>[keyof ProcessChildrenFields<TState$1, TRules$1, TShortcuts>];
-} & (HasNamedKeys<TState$1> extends true ? ProcessChildrenFields<TState$1, TRules$1, TShortcuts>[keyof ProcessChildrenFields<TState$1, TRules$1, TShortcuts>] : {}) : RegleStatus<TState$1, TRules$1, TShortcuts>;
-type ProcessChildrenFields<TState$1 extends Record<string, any> | undefined, TRules$1 extends ReglePartialRuleTree<NonNullable<TState$1>>, TShortcuts extends RegleShortcutDefinition = {}> = { [TIndex in keyof TupleToPlainObj<UnionToTuple<TState$1>>]: TIndex extends `${infer TIndexInt extends number}` ? { [TKey in keyof UnionToTuple<TState$1>[TIndexInt] as IsEmptyObject<FindCorrespondingVariant<UnionToTuple<TState$1>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState$1>[TIndexInt] : never, UnionToTuple<TRules$1>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject> extends true ? TKey extends keyof TState$1 ? TState$1[TKey] extends NonNullable<TState$1[TKey]> ? TKey : never : never : TKey]-?: InferRegleStatusType<FindCorrespondingVariant<UnionToTuple<TState$1>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState$1>[TIndexInt] : never, UnionToTuple<TRules$1>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject, NonNullable<UnionToTuple<TState$1>[TIndexInt]>, TKey, TShortcuts> } & { [TKey in keyof UnionToTuple<TState$1>[TIndexInt] as IsEmptyObject<FindCorrespondingVariant<UnionToTuple<TState$1>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState$1>[TIndexInt] : never, UnionToTuple<TRules$1>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject> extends true ? TKey extends keyof TState$1 ? TState$1[TKey] extends NonNullable<TState$1[TKey]> ? never : TKey : TKey : never]?: InferRegleStatusType<FindCorrespondingVariant<UnionToTuple<TState$1>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState$1>[TIndexInt] : never, UnionToTuple<TRules$1>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject : EmptyObject, NonNullable<UnionToTuple<TState$1>[TIndexInt]>, TKey, TShortcuts> } : {} };
-type FindCorrespondingVariant<TState$1 extends Record<string, any>, TRules$1 extends any[]> = TRules$1 extends [infer F, ...infer R] ? F extends ReglePartialRuleTree<TState$1> ? [F] : FindCorrespondingVariant<TState$1, R> : [];
-type PossibleLiteralTypes<T extends Record<string, any>, TKey$1 extends keyof T> = unknown extends T[TKey$1] ? {
-  [x: string]: { [K in TKey$1]-?: Omit<RegleRuleDecl<any, Partial<ExtendedRulesDeclarations>>, 'literal'> & {
-    literal?: RegleRuleDefinition<any, [literal: any], false, boolean, any, string | number>;
-  } };
-} : { [TVal in NonNullable<T[TKey$1]>]: { [K in TKey$1]-?: Omit<RegleRuleDecl<TVal, Partial<ExtendedRulesDeclarations>>, 'literal'> & {
-  literal?: RegleRuleDefinition<MaybeInput<TVal>, [literal: TVal], false, boolean, MaybeInput<TVal>, string | number>;
-} } };
-type RequiredForm<T extends Record<string, any>, TKey$1 extends keyof T> = Omit<ReglePartialRuleTree<T>, TKey$1> & PossibleLiteralTypes<T, TKey$1>[keyof PossibleLiteralTypes<T, TKey$1>];
-type VariantTuple<T extends Record<string, any>, TKey$1 extends keyof T> = [RequiredForm<T, TKey$1>, ...RequiredForm<T, TKey$1>[]];
+type useRegleFnOptions<TState$1 extends Record<string, any> | MaybeInput<PrimitiveTypes>, TRules$1 extends ReglePartialRuleTree<Unwrap<TState$1 extends Record<string, any> ? TState$1 : {}>, Partial<ExtendedRulesDeclarations>>, TAdditionalOptions extends Record<string, any>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>> = TState$1 extends MaybeInput<PrimitiveTypes> ? Partial<DeepMaybeRef<RegleBehaviourOptions>> & TAdditionalOptions : Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<JoinDiscriminatedUnions<TState$1 extends Record<string, any> ? Unwrap<TState$1> : {}>, TState$1 extends Record<string, any> ? (TRules$1 extends Record<string, any> ? TRules$1 : {}) : {}, TValidationGroups> & TAdditionalOptions;
+interface useRegleFn<TCustomRules extends Partial<ExtendedRulesDeclarations>, TShortcuts extends RegleShortcutDefinition<any> = never, TAdditionalReturnProperties extends Record<string, any> = {}, TAdditionalOptions extends Record<string, any> = {}> {
+  <TState$1 extends MaybeRef<Record<string, any> | MaybeInput<PrimitiveTypes>>, TRules$1 extends ReglePartialRuleTree<Unwrap<TState$1>, Partial<ExtendedRulesDeclarations> & Partial<TCustomRules>>, TDecl extends RegleRuleDecl<NonNullable<Unwrap<TState$1>>, Partial<ExtendedRulesDeclarations> & Partial<TCustomRules>>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>>(...params: [state: Maybe<TState$1> | DeepReactiveState<TState$1>, rulesFactory: Unwrap<TState$1> extends MaybeInput<PrimitiveTypes> ? MaybeRefOrGetter<TDecl> : Unwrap<TState$1> extends Record<string, any> ? MaybeComputedOrGetter<TRules$1> : {}, ...(HaveAnyRequiredProps<useRegleFnOptions<Unwrap<TState$1>, TRules$1, TAdditionalOptions, TValidationGroups>> extends true ? [options: useRegleFnOptions<Unwrap<TState$1>, TRules$1, TAdditionalOptions, TValidationGroups>] : [options?: useRegleFnOptions<Unwrap<TState$1>, TRules$1, TAdditionalOptions, TValidationGroups>])]): NonNullable<Unwrap<TState$1>> extends PrimitiveTypes ? RegleSingleField<NonNullable<Unwrap<TState$1>>, TDecl, TShortcuts, TAdditionalReturnProperties> : Regle<Unwrap<TState$1> extends Record<string, any> ? Unwrap<TState$1> : {}, UnwrapSimple<TRules$1> extends Record<string, any> ? UnwrapSimple<TRules$1> : {}, TValidationGroups, TShortcuts, TAdditionalReturnProperties>;
+  __config?: GlobalConfigOptions<TCustomRules, TShortcuts>;
+}
 /**
- * Combine all members of a union type, merging types for each key, and keeping loose types
+ * `useRegle` serves as the foundation for validation logic.
+ * It transforms your data and validation rules into a powerful, reactive validation system.
+ *
+ * @param state - Your form data (plain object, ref, reactive object, or structure with nested refs)
+ * @param rules - Validation rules that should align with the structure of your state
+ * @param modifiers - Optional configuration to customize regle behavior
+ * @returns An object containing `r$` - the reactive validation state
+ *
+ * @example
+ * ```ts
+ * import { useRegle } from '@regle/core';
+ * import { required, email, minLength } from '@regle/rules';
+ *
+ * const { r$ } = useRegle(
+ *   { name: '', email: '' },
+ *   {
+ *     name: { required, minLength: minLength(2) },
+ *     email: { required, email }
+ *   }
+ * );
+ *
+ * // Access validation state
+ * r$.$valid        // Whether all validations pass
+ * r$.$value        // The current form values
+ * r$.name.$errors  // Errors for the name field
+ *
+ * // Trigger validation
+ * const result = await r$.$validate();
+ * ```
+ *
+ * @see {@link https://reglejs.dev/core-concepts/ Documentation}
  */
-type JoinDiscriminatedUnions<TUnion extends unknown> = HasNamedKeys<TUnion> extends true ? isRecordLiteral<TUnion> extends true ? Prettify<Partial<UnionToIntersection<RemoveCommonKey<UnionToTuple<NonNullable<TUnion>>, keyof NormalizeUnion<NonNullable<TUnion>>>[number]>> & Pick<NormalizeUnion<NonNullable<TUnion>>, keyof NormalizeUnion<NonNullable<TUnion>>>> : TUnion : TUnion;
+declare const useRegle: useRegleFn<Partial<ExtendedRulesDeclarations>, RegleShortcutDefinition<any>, {}, {}>;
 /**
- * Combine all members of a union type on one level and not nested.
+ * @internal
+ * This is the internal function that creates the root storage for the Regle instance.
+ * This allows shared logic between all `useRegle` like composables
  */
-type LazyJoinDiscriminatedUnions<TUnion extends unknown> = isRecordLiteral<TUnion> extends true ? Prettify<Partial<UnionToIntersection<RemoveCommonKey<UnionToTuple<TUnion>, keyof NonNullable<TUnion>>[number]>> & Pick<NonNullable<TUnion>, keyof NonNullable<TUnion>>> : TUnion;
-type RemoveCommonKey<T extends readonly any[], K$1 extends PropertyKey> = T extends [infer F, ...infer R] ? [Prettify<Omit<F, K$1>>, ...RemoveCommonKey<R, K$1>] : [];
+declare function useRootStorage({
+  initialState,
+  originalState,
+  options,
+  scopeRules,
+  state,
+  customRules,
+  shortcuts,
+  schemaErrors,
+  schemaMode,
+  onValidate,
+  overrides
+}: {
+  scopeRules: Ref<$InternalReglePartialRuleTree>;
+  state: Ref<Record<string, any> | PrimitiveTypes>;
+  options: ResolvedRegleBehaviourOptions;
+  initialState: Ref<Record<string, any> | PrimitiveTypes>;
+  originalState: Record<string, any> | PrimitiveTypes;
+  customRules?: () => CustomRulesDeclarationTree;
+  shortcuts: RegleShortcutDefinition | undefined;
+  schemaErrors?: Ref<any | undefined>;
+  schemaMode?: boolean;
+  onValidate?: () => Promise<$InternalRegleResult>;
+  overrides: GlobalConfigOverrides | undefined;
+}): {
+  regle: $InternalRegleStatusType | undefined;
+};
 /**
- * Transforms a union and apply undefined values to non-present keys to support intersection
+ * Converts a nested `$errors` object to a flat array of error strings.
+ * Useful for displaying a complete list of form errors or counting total errors.
+ *
+ * With the `includePath` option, returns errors in Standard Schema Issue format
+ * including the path to each error field.
+ *
+ * @param errors - The `$errors` object from a Regle instance (e.g., `r$.$errors`)
+ * @param options - Configuration options
+ * @param options.includePath - If true, returns Standard Schema Issues with paths
+ * @returns Array of error strings, or Standard Schema Issues if `includePath` is true
+ *
+ * @example
+ * ```ts
+ * import { flatErrors, useRegle } from '@regle/core';
+ * import { required, email, minLength } from '@regle/rules';
+ *
+ * const { r$ } = useRegle(
+ *   { name: '', email: 'invalid' },
+ *   { name: { required, minLength: minLength(3) }, email: { email } }
+ * );
+ *
+ * await r$.$validate();
+ *
+ * // Get flat array of error messages
+ * const errors = flatErrors(r$.$errors);
+ * // ['This field is required', 'Value must be a valid email address']
+ *
+ * // Get errors with paths (Standard Schema format)
+ * const issues = flatErrors(r$.$errors, { includePath: true });
+ * // [{ message: 'This field is required', path: ['name'] }, ...]
+ * ```
+ *
+ * @see {@link https://reglejs.dev/core-concepts/displaying-errors#display-flat-errors Documentation}
  */
-type NormalizeUnion<TUnion> = RetrieveUnionUnknownValues<NonNullable<UnionToTuple<TUnion>>, RetrieveUnionUnknownKeysOf<NonNullable<UnionToTuple<TUnion>>>[number]>[number];
+declare function flatErrors(errors: $InternalRegleErrors, options: {
+  includePath: true;
+}): StandardSchemaV1.Issue[];
+declare function flatErrors(errors: $InternalRegleErrors, options?: {
+  includePath?: false;
+}): string[];
+type useRulesFnOptions<TRules$1 extends RegleUnknownRulesTree | RegleRuleDecl, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TState$1 = InferInput<TRules$1>> = Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<JoinDiscriminatedUnions<TState$1 extends Record<string, any> ? Unwrap<TState$1> : {}>, TState$1 extends Record<string, any> ? (TRules$1 extends Record<string, any> ? TRules$1 : {}) : {}, TValidationGroups>;
+interface useRulesFn<TCustomRules extends Partial<ExtendedRulesDeclarations>, TShortcuts extends RegleShortcutDefinition<any> = never> {
+  <TRules$1 extends RegleUnknownRulesTree | RegleRuleDecl, TDecl extends RegleRuleDecl<NonNullable<TState$1>, Partial<ExtendedRulesDeclarations> & TCustomRules>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TState$1 extends Record<string, any> = InferInput<TRules$1>>(rulesFactory: TState$1 extends Record<string, any> ? MaybeRef<TRules$1> | ((...args: any[]) => TRules$1) : {}, options?: useRulesFnOptions<TRules$1, TValidationGroups, TState$1>): NonNullable<TState$1> extends PrimitiveTypes ? Raw<RegleFieldStatus<NonNullable<TState$1>, TDecl, TShortcuts>> & StandardSchemaV1<TState$1> : Raw<RegleRoot<TState$1 extends Record<string, any> ? Unwrap<TState$1> : {}, TRules$1 extends Record<string, any> ? TRules$1 : {}, TValidationGroups, TShortcuts>> & StandardSchemaV1<TState$1>;
+  __config?: GlobalConfigOptions<TCustomRules, TShortcuts>;
+}
 /**
- * Combine all union values to be able to get even the normally "never" values, act as an intersection type
+ * `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}
  */
-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>] : [];
+declare const useRules: useRulesFn<Partial<ExtendedRulesDeclarations>, RegleShortcutDefinition<any>>;
 /**
- * Get all possible keys from a union, even the ones present only on one union
+ * 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);
+ * ```
  */
-type RetrieveUnionUnknownKeysOf<T extends readonly any[]> = T extends [infer F, ...infer R] ? [keyof F, ...RetrieveUnionUnknownKeysOf<R>] : [];
+declare function markStatic<T extends object>(value: T): T extends RegleStaticImpl<unknown> ? T : RegleStatic<T>;
 /**
- * Get item value from object, otherwise fallback to undefined. Avoid TS to not be able to infer keys not present on all unions
+ * Infer type of the `r$` of any function returning a regle instance
  */
-type GetMaybeObjectValue<O extends Record<string, any>, K$1 extends string> = K$1 extends keyof O ? O[K$1] : undefined;
-type RemoveIndexSignature<T> = { [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: T[K] };
+type InferRegleRoot<T extends (...args: any[]) => SuperCompatibleRegle> = T extends ((...args: any[]) => infer U) ? U extends SuperCompatibleRegle ? U['r$'] : never : never;
 /**
- * Merge every boolean property into a single boolean.
+ * Infer custom rules declared in a global configuration
  */
-type MergePropsIntoRequiredBooleans<TObject extends Record<string, any>> = { [K in keyof TObject]-?: TObject[K] extends NonNullable<TObject[K]> ? true : false }[keyof TObject];
+type InferRegleRules<T extends useRegleFn<any, any>> = T extends useRegleFn<infer U, any> ? UnwrapRuleTree<Partial<DefaultValidators>> & UnwrapRuleTree<Partial<U>> : {};
 /**
- * Ensure that if at least one prop is required, the "prop" object will be required too
+ * Infer custom shortcuts declared in a global configuration
  */
-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> = 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;
+type InferRegleShortcuts<T extends useRegleFn<any, any>> = T extends useRegleFn<any, infer U> ? U : {};
 /**
- * Convert a nested object to a deeply nested partial object.
+ * Extract a set rules and setting them as required
  */
-type DeepPartial<T> = 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 RegleEnforceRequiredRules<TRules$1 extends keyof DefaultValidators> = Omit<Partial<DefaultValidatorsTree>, TRules$1> & { [K in TRules$1]-?: UnwrapRuleWithParams<DefaultValidators[K]> };
+/**
+ * Extract a set of custom rules from a global configuration and setting them as required
+
+ */
+type RegleEnforceCustomRequiredRules<T extends useRegleFn<any, any>, TRules$1 extends keyof InferRegleRules<T>> = Omit<Partial<DefaultValidatorsTree>, TRules$1> & { [K in TRules$1]-?: T extends useRegleFn<any, any> ? K extends keyof InferRegleRules<T> ? NonNullable<UnwrapRuleWithParams<InferRegleRules<T>[K]>> : never : K extends keyof T ? NonNullable<T[K]> : never };
+/**
+ * Extract custom rules and custom shortcuts and apply them to a RegleFieldStatus type
+ */
+type RegleCustomFieldStatus<T extends useRegleFn<any, any>, TState$1 extends unknown = any, TRules$1 extends keyof InferRegleRules<T> = never> = RegleFieldStatus<TState$1, [TRules$1] extends [never] ? Partial<InferRegleRules<T>> : RegleEnforceCustomRequiredRules<T, TRules$1>, InferRegleShortcuts<T>>;
 /**
  * Infer safe output type from a rules object and it's original state type
  *
@@ -1991,4 +1986,4 @@ declare function refineRules<TRules$1 extends RegleUnknownRulesTree, TRefinement
  * @see {@link https://reglejs.dev/introduction/devtools Documentation}
  */
 declare const RegleVuePlugin: Plugin;
-export { type $InternalRegleStatus, type AllRulesDeclarations, type ArrayElement, type CommonAlphaOptions, type CommonComparisonOptions, type CreateScopedUseRegleOptions, type DeepMaybeRef, type DeepPartial, type DeepReactiveState, type DefaultValidatorsTree, type ExtendedRulesDeclarations, type FormRuleDeclaration, type GlobalConfigOverrides, type HasNamedKeys, type HaveAnyRequiredProps, type InferInput, type InferOutput, type InferRegleRoot, type InferRegleRule, type InferRegleRules, type InferRegleSettings, type InferRegleShortcuts, type InferRegleStatusType, type InferRegleValidationResult, type InferSafeOutput, type InferValidOutput, type InlineRuleDeclaration, InternalRuleType, type IsRegleStatic, type JoinDiscriminatedUnions, type LocalRegleBehaviourOptions, type Maybe, type MaybeInput, type MaybeOutput, type MaybeReadonly, type MaybeVariantStatus, type MergedRegles, type MergedScopedRegles, type NarrowVariant, type NarrowVariantExtracts, type NarrowVariantFieldExtracts, type NoInferLegacy, type NonEmptyTuple, type PrimitiveTypes, type Regle, type RegleBehaviourOptions, type RegleCollectionErrors, type RegleCollectionRuleDecl, type RegleCollectionRuleDefinition, type RegleCollectionStatus, type RegleCommonStatus, type RegleComputedRules, type RegleCustomFieldStatus, type RegleEnforceCustomRequiredRules, type RegleEnforceRequiredRules, type RegleErrorTree, type RegleExternalCollectionErrors, type RegleExternalErrorTree, type RegleExternalSchemaErrorTree, type RegleFieldIssue, type RegleFieldStatus, type RegleFormPropertyType, type RegleInternalRuleDefs, type RegleIssuesTree, type RegleLike, type ReglePartialRuleTree, type RegleResult, type RegleRoot, type RegleRuleCore, type RegleRuleDecl, type RegleRuleDefinition, type RegleRuleDefinitionProcessor, type RegleRuleDefinitionWithMetadataProcessor, type RegleRuleInit, type RegleRuleMetadataConsumer, type RegleRuleMetadataDefinition, type RegleRuleMetadataExtended, type RegleRuleRaw, type RegleRuleStatus, type RegleRuleTypeReturn, type RegleRuleWithParamsDefinition, type RegleRuleWithParamsDefinitionInput, type RegleShortcutDefinition, type RegleSingleField, type RegleStatic, type RegleStaticImpl, type RegleStatus, type RegleUniversalParams, type RegleUnknownRulesTree, type RegleValidationErrors, type RegleValidationGroupEntry, type RegleValidationGroupOutput, type RegleRuleTree as RegleValidationTree, RegleVuePlugin, type ResolvedRegleBehaviourOptions, type ScopedInstancesRecord, type ScopedInstancesRecordLike, type SuperCompatibleRegle, type SuperCompatibleRegleCollectionErrors, type SuperCompatibleRegleCollectionStatus, type SuperCompatibleRegleFieldStatus, type SuperCompatibleRegleResult, type SuperCompatibleRegleRoot, type SuperCompatibleRegleRuleStatus, type SuperCompatibleRegleStatus, type TupleToPlainObj, type Unwrap, type UnwrapRegleUniversalParams, type UnwrapRuleWithParams, type UnwrapStatic, type UseScopedRegleOptions, createRule, createScopedUseRegle, createVariant, defineRegleConfig, defineRules, extendRegleConfig, flatErrors, inferRules, type inferRulesFn, type isEditedHandlerFn, markStatic, mergeRegles, narrowVariant, refineRules, unwrapRuleParameters, useCollectScope, type useCollectScopeFn, useRegle, type useRegleFn, useRootStorage, useRules, type useRulesFn, useScopedRegle, variantToRef };
+export { type $InternalRegleStatus, type AllRulesDeclarations, type ArrayElement, type CommonAlphaOptions, type CommonComparisonOptions, type CreateScopedUseRegleOptions, type DeepMaybeRef, type DeepPartial, type DeepReactiveState, type DefaultValidatorsTree, type DumbJoinDiscriminatedUnions, type ExtendedRulesDeclarations, type FormRuleDeclaration, type GlobalConfigOverrides, type HasNamedKeys, type HaveAnyRequiredProps, type InferInput, type InferOutput, type InferRegleRoot, type InferRegleRule, type InferRegleRules, type InferRegleSettings, type InferRegleShortcuts, type InferRegleStatusType, type InferRegleValidationResult, type InferSafeOutput, type InferValidOutput, type InlineRuleDeclaration, InternalRuleType, type IsRegleStatic, type JoinDiscriminatedUnions, type LazyJoinDiscriminatedUnions, type LocalRegleBehaviourOptions, type Maybe, type MaybeInput, type MaybeOutput, type MaybeReadonly, type MaybeVariantStatus, type MergedRegles, type MergedScopedRegles, type NarrowVariant, type NarrowVariantExtracts, type NarrowVariantFieldExtracts, type NoInferLegacy, type NonEmptyTuple, type PrimitiveTypes, type Regle, type RegleBehaviourOptions, type RegleCollectionErrors, type RegleCollectionRuleDecl, type RegleCollectionRuleDefinition, type RegleCollectionStatus, type RegleCommonStatus, type RegleComputedRules, type RegleCustomFieldStatus, type RegleEnforceCustomRequiredRules, type RegleEnforceRequiredRules, type RegleErrorTree, type RegleExternalCollectionErrors, type RegleExternalErrorTree, type RegleExternalSchemaErrorTree, type RegleFieldIssue, type RegleFieldStatus, type RegleFormPropertyType, type RegleInternalRuleDefs, type RegleIssuesTree, type RegleLike, type ReglePartialRuleTree, type RegleResult, type RegleRoot, type RegleRuleCore, type RegleRuleDecl, type RegleRuleDefinition, type RegleRuleDefinitionProcessor, type RegleRuleDefinitionWithMetadataProcessor, type RegleRuleInit, type RegleRuleMetadataConsumer, type RegleRuleMetadataDefinition, type RegleRuleMetadataExtended, type RegleRuleRaw, type RegleRuleStatus, type RegleRuleTypeReturn, type RegleRuleWithParamsDefinition, type RegleRuleWithParamsDefinitionInput, type RegleShortcutDefinition, type RegleSingleField, type RegleStatic, type RegleStaticImpl, type RegleStatus, type RegleUniversalParams, type RegleUnknownRulesTree, type RegleValidationErrors, type RegleValidationGroupEntry, type RegleValidationGroupOutput, type RegleRuleTree as RegleValidationTree, RegleVuePlugin, type ResolvedRegleBehaviourOptions, type ScopedInstancesRecord, type ScopedInstancesRecordLike, type SuperCompatibleRegle, type SuperCompatibleRegleCollectionErrors, type SuperCompatibleRegleCollectionStatus, type SuperCompatibleRegleFieldStatus, type SuperCompatibleRegleResult, type SuperCompatibleRegleRoot, type SuperCompatibleRegleRuleStatus, type SuperCompatibleRegleStatus, type TupleToPlainObj, type Unwrap, type UnwrapRegleUniversalParams, type UnwrapRuleWithParams, type UnwrapStatic, type UseScopedRegleOptions, createRule, createScopedUseRegle, createVariant, defineRegleConfig, defineRules, extendRegleConfig, flatErrors, inferRules, type inferRulesFn, type isEditedHandlerFn, markStatic, mergeRegles, narrowVariant, refineRules, unwrapRuleParameters, useCollectScope, type useCollectScopeFn, useRegle, type useRegleFn, useRootStorage, useRules, type useRulesFn, useScopedRegle, variantToRef };