@regle/core 1.17.2 → 1.17.4

package/dist/regle-core.d.ts

@@ -1,5 +1,5 @@
 /**
- * @regle/core v1.17.2
+ * @regle/core v1.17.4
  * (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.
@@ -544,222 +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 ? 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;
+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 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;
+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
  *