@regle/core 0.5.0 → 0.5.2

package/dist/regle-core.d.ts

@@ -1,4 +1,4 @@
-import { MaybeRef, Ref, UnwrapRef, UnwrapNestedRefs, MaybeRefOrGetter } from 'vue';
+import { MaybeRef, Ref, UnwrapRef, UnwrapNestedRefs, MaybeRefOrGetter, ComputedRef } from 'vue';
 
 type Prettify<T> = T extends infer R ? {
     [K in keyof R]: R[K];
@@ -78,6 +78,23 @@ Matches any primitive, `void`, `Date`, or `RegExp` value.
 */
 type BuiltIns = Primitive | void | Date | RegExp;
 
+/**
+Test if the given function has multiple call signatures.
+
+Needed to handle the case of a single call signature with properties.
+
+Multiple call signatures cannot currently be supported due to a TypeScript limitation.
+@see https://github.com/microsoft/TypeScript/issues/29732
+*/
+type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> =
+	T extends {(...arguments_: infer A): unknown; (...arguments_: infer B): unknown}
+		? B extends A
+			? A extends B
+				? false
+				: true
+			: true
+		: false;
+
 /**
 @see PartialDeep
 */
@@ -186,6 +203,83 @@ type PartialObjectDeep<ObjectType extends object, Options extends PartialDeepOpt
 	[KeyType in keyof ObjectType]?: PartialDeep<ObjectType[KeyType], Options>
 };
 
+type ExcludeUndefined<T> = Exclude<T, undefined>;
+
+/**
+Create a type from another type with all keys and nested keys set to required.
+
+Use-cases:
+- Creating optional configuration interfaces where the underlying implementation still requires all options to be fully specified.
+- Modeling the resulting type after a deep merge with a set of defaults.
+
+@example
+```
+import type {RequiredDeep} from 'type-fest';
+
+type Settings = {
+	textEditor?: {
+		fontSize?: number | undefined;
+		fontColor?: string | undefined;
+		fontWeight?: number | undefined;
+	}
+	autocomplete?: boolean | undefined;
+	autosave?: boolean | undefined;
+};
+
+type RequiredSettings = RequiredDeep<Settings>;
+// type RequiredSettings = {
+// 	textEditor: {
+// 		fontSize: number;
+// 		fontColor: string;
+// 		fontWeight: number;
+// 	}
+// 	autocomplete: boolean;
+// 	autosave: boolean;
+// }
+```
+
+Note that types containing overloaded functions are not made deeply required due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
+
+@category Utilities
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+type RequiredDeep<T, E extends ExcludeUndefined<T> = ExcludeUndefined<T>> = E extends BuiltIns
+	? E
+	: E extends Map<infer KeyType, infer ValueType>
+		? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
+		: E extends Set<infer ItemType>
+			? Set<RequiredDeep<ItemType>>
+			: E extends ReadonlyMap<infer KeyType, infer ValueType>
+				? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
+				: E extends ReadonlySet<infer ItemType>
+					? ReadonlySet<RequiredDeep<ItemType>>
+					: E extends WeakMap<infer KeyType, infer ValueType>
+						? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
+						: E extends WeakSet<infer ItemType>
+							? WeakSet<RequiredDeep<ItemType>>
+							: E extends Promise<infer ValueType>
+								? Promise<RequiredDeep<ValueType>>
+								: E extends (...arguments_: any[]) => unknown
+									? {} extends RequiredObjectDeep<E>
+										? E
+										: HasMultipleCallSignatures<E> extends true
+											? E
+											: ((...arguments_: Parameters<E>) => ReturnType<E>) & RequiredObjectDeep<E>
+									: E extends object
+										? E extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+											? ItemType[] extends E // Test for arrays (non-tuples) specifically
+												? Array<RequiredDeep<ItemType>> // Recreate relevant array type to prevent eager evaluation of circular reference
+												: RequiredObjectDeep<E> // Tuples behave properly
+											: RequiredObjectDeep<E>
+										: unknown;
+
+type RequiredObjectDeep<ObjectType extends object> = {
+	[KeyType in keyof ObjectType]-?: RequiredDeep<ObjectType[KeyType]>
+};
+
 /**
 Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
 
@@ -231,7 +325,7 @@ type Intersection = UnionToIntersection<Union>;
 
 @category Type
 */
-type UnionToIntersection<Union> = (
+type UnionToIntersection$1<Union> = (
 	// `extends unknown` is always going to be the case and is used to convert the
 	// `Union` into a [distributive conditional
 	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
@@ -289,6 +383,7 @@ interface RegleValidationGroupOutput {
 type FieldRegleBehaviourOptions = AddDollarToOptions<RegleBehaviourOptions> & {
     $debounce?: number;
 };
+type ResolvedRegleBehaviourOptions = DeepMaybeRef<RequiredDeep<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<Record<string, any>, Record<string, any>, Record<string, any[]>>;
 type ShortcutCommonFn<T extends Record<string, any>> = {
     [x: string]: (element: OmitByType<T, Function>) => unknown;
 };
@@ -307,7 +402,7 @@ interface Regle<TState extends Record<string, any> = EmptyObject, TRules extends
 type isDeepExact<T, U> = {
     [K in keyof T]-?: CheckDeepExact<NonNullable<T[K]>, K extends keyof U ? NonNullable<U[K]> : never>;
 }[keyof T] extends true ? true : false;
-type CheckDeepExact<T, U> = [U] extends [never] ? false : T extends RegleCollectionRuleDecl ? U extends RegleCollectionRuleDecl ? isDeepExact<NonNullable<T['$each']>, UnionToIntersection<NonNullable<U['$each']>>> : T extends RegleRuleDecl ? true : T extends ReglePartialRuleTree<any> ? isDeepExact<T, U> : false : T extends RegleRuleDecl ? true : T extends ReglePartialRuleTree<any> ? isDeepExact<T, U> : false;
+type CheckDeepExact<T, U> = [U] extends [never] ? false : T extends RegleCollectionRuleDecl ? U extends RegleCollectionRuleDecl ? isDeepExact<NonNullable<T['$each']>, UnionToIntersection$1<NonNullable<U['$each']>>> : T extends RegleRuleDecl ? true : T extends ReglePartialRuleTree<any> ? isDeepExact<T, U> : false : T extends RegleRuleDecl ? true : T extends ReglePartialRuleTree<any> ? isDeepExact<T, U> : false;
 type DeepReactiveState<T extends Record<string, any>> = {
     [K in keyof T]: MaybeRef<T[K]>;
 };
@@ -327,7 +422,7 @@ type IsPropertyOutputRequired<TState, TRule extends RegleFormPropertyType<any, a
 ] extends [TState] ? unknown : NonNullable<TState> extends Array<any> ? TRule extends RegleCollectionRuleDecl<any, any> ? ArrayHaveAtLeastOneRequiredField<NonNullable<TState>, TRule> extends false ? false : true : false : TRule extends ReglePartialRuleTree<any, any> ? ExtendOnlyRealRecord<TState> extends true ? ObjectHaveAtLeastOneRequiredField<NonNullable<TState> extends Record<string, any> ? NonNullable<TState> : {}, TRule> extends false ? false : true : TRule extends RegleRuleDecl<any, any> ? FieldHaveRequiredRule<TRule> extends false ? false : true : false : false;
 type SafeFieldProperty<TState, TRule extends RegleFormPropertyType<any, any> | undefined = never> = TRule extends RegleRuleDecl<any, any> ? unknown extends TRule['required'] ? Maybe<TState> : TRule['required'] extends undefined ? never : TRule['required'] extends RegleRuleDefinition<any, infer Params, any, any, any> ? Params extends never[] ? Maybe<TState> : Maybe<TState> : Maybe<TState> : Maybe<TState>;
 
-type useRegleFn<TCustomRules extends Partial<AllRulesDeclarations>, TShortcuts extends RegleShortcutDefinition<any> = never> = <TState extends Record<string, any>, TRules extends ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules> & TValid, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TValid = isDeepExact<NoInferLegacy<TRules>, ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules>> extends true ? {} : never>(state: MaybeRef<TState> | DeepReactiveState<TState>, rulesFactory: MaybeRefOrGetter<TRules>, options?: Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<Unwrap<TState>, TRules, TValidationGroups>) => Regle<Unwrap<TState>, TRules, TValidationGroups, TShortcuts>;
+type useRegleFn<TCustomRules extends Partial<AllRulesDeclarations>, TShortcuts extends RegleShortcutDefinition<any> = never> = <TState extends Record<string, any>, TRules extends ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules> & TValid, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TValid = isDeepExact<NoInferLegacy<TRules>, ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules>> extends true ? {} : MismatchInfo<NoInferLegacy<TRules>, ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules>>>(state: MaybeRef<TState> | DeepReactiveState<TState>, rulesFactory: MaybeRefOrGetter<TRules>, options?: Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<Unwrap<TState>, TRules, TValidationGroups>) => Regle<Unwrap<TState>, TRules, TValidationGroups, TShortcuts>;
 declare const useRegle: useRegleFn<Partial<AllRulesDeclarations>, RegleShortcutDefinition<any>>;
 
 interface inferRulesFn<TCustomRules extends Partial<AllRulesDeclarations>> {
@@ -336,6 +431,17 @@ interface inferRulesFn<TCustomRules extends Partial<AllRulesDeclarations>> {
 }
 declare const inferRules: inferRulesFn<Partial<AllRulesDeclarations>>;
 
+declare function useRootStorage({ initialState, options, scopeRules, state, customRules, shortcuts, }: {
+    scopeRules: ComputedRef<$InternalReglePartialRuleTree>;
+    state: Ref<Record<string, any>>;
+    options: ResolvedRegleBehaviourOptions;
+    initialState: Record<string, any>;
+    customRules?: () => CustomRulesDeclarationTree;
+    shortcuts: RegleShortcutDefinition | undefined;
+}): {
+    regle: $InternalRegleStatus | undefined;
+};
+
 type InferRegleRoot<T extends (...args: any[]) => Regle<any, any, any, any>> = T extends (...args: any[]) => infer U ? U extends Regle<any, any, any, any> ? Prettify<U['r$']> : never : never;
 type InferRegleRules<T extends useRegleFn<any, any>> = T extends useRegleFn<infer U, any> ? UnwrapRuleTree<Partial<U> & Partial<DefaultValidators>> : {};
 type InferRegleShortcuts<T extends useRegleFn<any, any>> = T extends useRegleFn<any, infer U> ? U : {};
@@ -346,6 +452,451 @@ type RegleEnforceCustomRequiredRules<T extends Partial<AllRulesDeclarations> | u
     [K in TRules]-?: T extends useRegleFn<any> ? K extends keyof InferRegleRules<T> ? NonNullable<InferRegleRules<T>[K]> : never : K extends keyof T ? NonNullable<T[K]> : never;
 };
 
+/**
+ * Negates a boolean type.
+ */
+type Not<T extends boolean> = T extends true ? false : true;
+/**
+ * Checks if all the boolean types in the {@linkcode Types} array are `true`.
+ */
+type And<Types extends boolean[]> = Types[number] extends true ? true : false;
+/**
+ * @internal
+ */
+declare const secret: unique symbol;
+/**
+ * @internal
+ */
+type Secret = typeof secret;
+/**
+ * Checks if the given type is `never`.
+ */
+type IsNever<T> = [T] extends [never] ? true : false;
+/**
+ * Checks if the given type is `any`.
+ */
+type IsAny<T> = [T] extends [Secret] ? Not<IsNever<T>> : false;
+/**
+ * Determines if the given type is `unknown`.
+ */
+type IsUnknown<T> = [unknown] extends [T] ? Not<IsAny<T>> : false;
+/**
+ * Subjective "useful" keys from a type. For objects it's just `keyof` but for
+ * tuples/arrays it's the number keys.
+ *
+ * @example
+ * ```ts
+ * UsefulKeys<{ a: 1; b: 2 }> // 'a' | 'b'
+ *
+ * UsefulKeys<['a', 'b']> // '0' | '1'
+ *
+ * UsefulKeys<string[]> // number
+ * ```
+ */
+type UsefulKeys<T> = T extends any[] ? {
+    [K in keyof T]: K;
+}[number] : keyof T;
+/**
+ * Extracts the keys from a type that are required (not optional).
+ */
+type RequiredKeys<T> = Extract<{
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T], keyof T>;
+/**
+ * Gets the keys of an object type that are optional.
+ */
+type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
+/**
+ * Extracts the keys from a type that are not `readonly`.
+ */
+type ReadonlyKeys<T> = Extract<{
+    [K in keyof T]-?: ReadonlyEquivalent<{
+        [_K in K]: T[K];
+    }, {
+        -readonly [_K in K]: T[K];
+    }> extends true ? never : K;
+}[keyof T], keyof T>;
+/**
+ * Determines if two types, are equivalent in a `readonly` manner.
+ *
+ * @internal
+ */
+type ReadonlyEquivalent<X, Y> = Extends<(<T>() => T extends X ? true : false), (<T>() => T extends Y ? true : false)>;
+/**
+ * Checks if one type extends another. Note: this is not quite the same as `Left extends Right` because:
+ * 1. If either type is `never`, the result is `true` iff the other type is also `never`.
+ * 2. Types are wrapped in a 1-tuple so that union types are not distributed - instead we consider `string | number` to _not_ extend `number`. If we used `Left extends Right` directly you would get `Extends<string | number, number>` => `false | true` => `boolean`.
+ */
+type Extends<Left, Right> = IsNever<Left> extends true ? IsNever<Right> : [Left] extends [Right] ? true : false;
+/**
+ * Checks if two types are strictly equal using
+ * the TypeScript internal identical-to operator.
+ *
+ * @see {@link https://github.com/microsoft/TypeScript/issues/55188#issuecomment-1656328122 | much history}
+ */
+type StrictEqualUsingTSInternalIdenticalToOperator<L, R> = (<T>() => T extends (L & T) | T ? true : false) extends <T>() => T extends (R & T) | T ? true : false ? IsNever<L> extends IsNever<R> ? true : false : false;
+/**
+ * Checks that {@linkcode Left} and {@linkcode Right} extend each other.
+ * Not quite the same as an equality check since `any` can make it resolve
+ * to `true`. So should only be used when {@linkcode Left} and
+ * {@linkcode Right} are known to avoid `any`.
+ */
+type MutuallyExtends<Left, Right> = And<[Extends<Left, Right>, Extends<Right, Left>]>;
+/**
+ * Convert a union to an intersection.
+ * `A | B | C` -\> `A & B & C`
+ */
+type UnionToIntersection<Union> = (Union extends any ? (distributedUnion: Union) => void : never) extends (mergedIntersection: infer Intersection) => void ? Intersection : never;
+/**
+ * Get the last element of a union.
+ * First, converts to a union of `() => T` functions,
+ * then uses {@linkcode UnionToIntersection} to get the last one.
+ */
+type LastOf<Union> = UnionToIntersection<Union extends any ? () => Union : never> extends () => infer R ? R : never;
+/**
+ * Intermediate type for {@linkcode UnionToTuple} which pushes the
+ * "last" union member to the end of a tuple, and recursively prepends
+ * the remainder of the union.
+ */
+type TuplifyUnion<Union, LastElement = LastOf<Union>> = IsNever<Union> extends true ? [] : [...TuplifyUnion<Exclude<Union, LastElement>>, LastElement];
+/**
+ * Convert a union like `1 | 2 | 3` to a tuple like `[1, 2, 3]`.
+ */
+type UnionToTuple<Union> = TuplifyUnion<Union>;
+
+/**
+ * The simple(ish) way to get overload info from a function
+ * {@linkcode FunctionType}. Recent versions of TypeScript will match any
+ * function against a generic 10-overload type, filling in slots with
+ * duplicates of the function. So, we can just match against a single type
+ * and get all the overloads.
+ *
+ * For older versions of TypeScript, we'll need to painstakingly do
+ * ten separate matches.
+ */
+type TSPost53OverloadsInfoUnion<FunctionType> = FunctionType extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+    (...args: infer A5): infer R5;
+    (...args: infer A6): infer R6;
+    (...args: infer A7): infer R7;
+    (...args: infer A8): infer R8;
+    (...args: infer A9): infer R9;
+    (...args: infer A10): infer R10;
+} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) | ((...p: A9) => R9) | ((...p: A10) => R10) : never;
+/**
+ * A function with `unknown` parameters and return type.
+ */
+type UnknownFunction = (...args: unknown[]) => unknown;
+/**
+ * `true` iff {@linkcode FunctionType} is
+ * equivalent to `(...args: unknown[]) => unknown`,
+ * which is what an overload variant looks like for a non-existent overload.
+ * This is useful because older versions of TypeScript end up with
+ * 9 "useless" overloads and one real one for parameterless/generic functions.
+ *
+ * @see {@link https://github.com/microsoft/TypeScript/issues/28867 | Related}
+ */
+type IsUselessOverloadInfo<FunctionType> = StrictEqualUsingTSInternalIdenticalToOperator<FunctionType, UnknownFunction>;
+/**
+ * Old versions of TypeScript can sometimes seem to refuse to separate out
+ * union members unless you put them each in a pointless tuple and add an
+ * extra `infer X` expression. There may be a better way to work around this
+ * problem, but since it's not a problem in newer versions of TypeScript,
+ * it's not a priority right now.
+ */
+type Tuplify<Union> = Union extends infer X ? [X] : never;
+/**
+ * For older versions of TypeScript, we need two separate workarounds
+ * to get overload info. First, we need need to use
+ * {@linkcode DecreasingOverloadsInfoUnion} to get the overload info for
+ * functions with 1-10 overloads. Then, we need to filter out the
+ * "useless" overloads that are present in older versions of TypeScript,
+ * for parameterless functions. To do this we use
+ * {@linkcode IsUselessOverloadInfo} to remove useless overloads.
+ *
+ * @see {@link https://github.com/microsoft/TypeScript/issues/28867 | Related}
+ */
+type TSPre53OverloadsInfoUnion<FunctionType> = Tuplify<DecreasingOverloadsInfoUnion<FunctionType>> extends infer Tup ? Tup extends [infer Fn] ? IsUselessOverloadInfo<Fn> extends true ? never : Fn : never : never;
+/**
+ * For versions of TypeScript below 5.3, we need to check for 10 overloads,
+ * then 9, then 8, etc., to get a union of the overload variants.
+ */
+type DecreasingOverloadsInfoUnion<F> = F extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+    (...args: infer A5): infer R5;
+    (...args: infer A6): infer R6;
+    (...args: infer A7): infer R7;
+    (...args: infer A8): infer R8;
+    (...args: infer A9): infer R9;
+    (...args: infer A10): infer R10;
+} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) | ((...p: A9) => R9) | ((...p: A10) => R10) : F extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+    (...args: infer A5): infer R5;
+    (...args: infer A6): infer R6;
+    (...args: infer A7): infer R7;
+    (...args: infer A8): infer R8;
+    (...args: infer A9): infer R9;
+} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) | ((...p: A9) => R9) : F extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+    (...args: infer A5): infer R5;
+    (...args: infer A6): infer R6;
+    (...args: infer A7): infer R7;
+    (...args: infer A8): infer R8;
+} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) : F extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+    (...args: infer A5): infer R5;
+    (...args: infer A6): infer R6;
+    (...args: infer A7): infer R7;
+} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) : F extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+    (...args: infer A5): infer R5;
+    (...args: infer A6): infer R6;
+} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) : F extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+    (...args: infer A5): infer R5;
+} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) : F extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) : F extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) : F extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+} ? ((...p: A1) => R1) | ((...p: A2) => R2) : F extends (...args: infer A1) => infer R1 ? ((...p: A1) => R1) : never;
+/**
+ * Get a union of overload variants for a function {@linkcode FunctionType}.
+ * Does a check for whether we can do the one-shot
+ * 10-overload matcher (which works for ts\>5.3), and if not,
+ * falls back to the more complicated utility.
+ */
+type OverloadsInfoUnion<FunctionType> = IsNever<TSPost53OverloadsInfoUnion<(a: 1) => 2>> extends true ? TSPre53OverloadsInfoUnion<FunctionType> : TSPost53OverloadsInfoUnion<FunctionType>;
+/**
+ * The simple(ish) way to get overload info from a constructor
+ * {@linkcode ConstructorType}. Recent versions of TypeScript will match any
+ * constructor against a generic 10-overload type, filling in slots with
+ * duplicates of the constructor. So, we can just match against a single type
+ * and get all the overloads.
+ *
+ * For older versions of TypeScript,
+ * we'll need to painstakingly do ten separate matches.
+ */
+type TSPost53ConstructorOverloadsInfoUnion<ConstructorType> = ConstructorType extends {
+    new (...args: infer A1): infer R1;
+    new (...args: infer A2): infer R2;
+    new (...args: infer A3): infer R3;
+    new (...args: infer A4): infer R4;
+    new (...args: infer A5): infer R5;
+    new (...args: infer A6): infer R6;
+    new (...args: infer A7): infer R7;
+    new (...args: infer A8): infer R8;
+    new (...args: infer A9): infer R9;
+    new (...args: infer A10): infer R10;
+} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) | (new (...p: A9) => R9) | (new (...p: A10) => R10) : never;
+/**
+ * A constructor function with `unknown` parameters and return type.
+ */
+type UnknownConstructor = new (...args: unknown[]) => unknown;
+/**
+ * Same as {@linkcode IsUselessOverloadInfo}, but for constructors.
+ */
+type IsUselessConstructorOverloadInfo<FunctionType> = StrictEqualUsingTSInternalIdenticalToOperator<FunctionType, UnknownConstructor>;
+/**
+ * For older versions of TypeScript, we need two separate workarounds to
+ * get constructor overload info. First, we need need to use
+ * {@linkcode DecreasingConstructorOverloadsInfoUnion} to get the overload
+ * info for constructors with 1-10 overloads. Then, we need to filter out the
+ * "useless" overloads that are present in older versions of TypeScript,
+ * for parameterless constructors. To do this we use
+ * {@linkcode IsUselessConstructorOverloadInfo} to remove useless overloads.
+ *
+ * @see {@link https://github.com/microsoft/TypeScript/issues/28867 | Related}
+ */
+type TSPre53ConstructorOverloadsInfoUnion<ConstructorType> = Tuplify<DecreasingConstructorOverloadsInfoUnion<ConstructorType>> extends infer Tup ? Tup extends [infer Ctor] ? IsUselessConstructorOverloadInfo<Ctor> extends true ? never : Ctor : never : never;
+/**
+ * For versions of TypeScript below 5.3, we need to check for 10 overloads,
+ * then 9, then 8, etc., to get a union of the overload variants.
+ */
+type DecreasingConstructorOverloadsInfoUnion<ConstructorType> = ConstructorType extends {
+    new (...args: infer A1): infer R1;
+    new (...args: infer A2): infer R2;
+    new (...args: infer A3): infer R3;
+    new (...args: infer A4): infer R4;
+    new (...args: infer A5): infer R5;
+    new (...args: infer A6): infer R6;
+    new (...args: infer A7): infer R7;
+    new (...args: infer A8): infer R8;
+    new (...args: infer A9): infer R9;
+    new (...args: infer A10): infer R10;
+} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) | (new (...p: A9) => R9) | (new (...p: A10) => R10) : ConstructorType extends {
+    new (...args: infer A1): infer R1;
+    new (...args: infer A2): infer R2;
+    new (...args: infer A3): infer R3;
+    new (...args: infer A4): infer R4;
+    new (...args: infer A5): infer R5;
+    new (...args: infer A6): infer R6;
+    new (...args: infer A7): infer R7;
+    new (...args: infer A8): infer R8;
+    new (...args: infer A9): infer R9;
+} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) | (new (...p: A9) => R9) : ConstructorType extends {
+    new (...args: infer A1): infer R1;
+    new (...args: infer A2): infer R2;
+    new (...args: infer A3): infer R3;
+    new (...args: infer A4): infer R4;
+    new (...args: infer A5): infer R5;
+    new (...args: infer A6): infer R6;
+    new (...args: infer A7): infer R7;
+    new (...args: infer A8): infer R8;
+} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) : ConstructorType extends {
+    new (...args: infer A1): infer R1;
+    new (...args: infer A2): infer R2;
+    new (...args: infer A3): infer R3;
+    new (...args: infer A4): infer R4;
+    new (...args: infer A5): infer R5;
+    new (...args: infer A6): infer R6;
+    new (...args: infer A7): infer R7;
+} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) : ConstructorType extends {
+    new (...args: infer A1): infer R1;
+    new (...args: infer A2): infer R2;
+    new (...args: infer A3): infer R3;
+    new (...args: infer A4): infer R4;
+    new (...args: infer A5): infer R5;
+    new (...args: infer A6): infer R6;
+} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) : ConstructorType extends {
+    new (...args: infer A1): infer R1;
+    new (...args: infer A2): infer R2;
+    new (...args: infer A3): infer R3;
+    new (...args: infer A4): infer R4;
+    new (...args: infer A5): infer R5;
+} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) : ConstructorType extends {
+    new (...args: infer A1): infer R1;
+    new (...args: infer A2): infer R2;
+    new (...args: infer A3): infer R3;
+    new (...args: infer A4): infer R4;
+} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) : ConstructorType extends {
+    new (...args: infer A1): infer R1;
+    new (...args: infer A2): infer R2;
+    new (...args: infer A3): infer R3;
+} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) : ConstructorType extends {
+    new (...args: infer A1): infer R1;
+    new (...args: infer A2): infer R2;
+} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) : ConstructorType extends new (...args: infer A1) => infer R1 ? (new (...p: A1) => R1) : never;
+/**
+ * Get a union of overload variants for a constructor
+ * {@linkcode ConstructorType}. Does a check for whether we can do the
+ * one-shot 10-overload matcher (which works for ts\>5.3), and if not,
+ * falls back to the more complicated utility.
+ */
+type ConstructorOverloadsUnion<ConstructorType> = IsNever<TSPost53ConstructorOverloadsInfoUnion<new (a: 1) => any>> extends true ? TSPre53ConstructorOverloadsInfoUnion<ConstructorType> : TSPost53ConstructorOverloadsInfoUnion<ConstructorType>;
+/**
+ * Allows inferring any constructor using the `infer` keyword.
+ */
+type InferConstructor<ConstructorType extends new (...args: any) => any> = ConstructorType;
+/**
+ * A union type of the parameters allowed for any overload
+ * of constructor {@linkcode ConstructorType}.
+ */
+type ConstructorOverloadParameters<ConstructorType> = ConstructorOverloadsUnion<ConstructorType> extends InferConstructor<infer Ctor> ? ConstructorParameters<Ctor> : never;
+/**
+ * Calculates the number of overloads for a given function type.
+ */
+type NumOverloads<FunctionType> = UnionToTuple<OverloadsInfoUnion<FunctionType>>['length'];
+
+/**
+ * Represents a deeply branded type.
+ *
+ * Recursively walk a type and replace it with a branded type related to the
+ * original. This is useful for equality-checking stricter than
+ * `A extends B ? B extends A ? true : false : false`, because it detects the
+ * difference between a few edge-case types that vanilla TypeScript
+ * doesn't by default:
+ * - `any` vs `unknown`
+ * - `{ readonly a: string }` vs `{ a: string }`
+ * - `{ a?: string }` vs `{ a: string | undefined }`
+ *
+ * __Note__: not very performant for complex types - this should only be used
+ * when you know you need it. If doing an equality check, it's almost always
+ * better to use {@linkcode StrictEqualUsingTSInternalIdenticalToOperator}.
+ */
+type DeepBrand<T> = IsNever<T> extends true ? {
+    type: 'never';
+} : IsAny<T> extends true ? {
+    type: 'any';
+} : IsUnknown<T> extends true ? {
+    type: 'unknown';
+} : T extends string | number | boolean | symbol | bigint | null | undefined | void ? {
+    type: 'primitive';
+    value: T;
+} : T extends new (...args: any[]) => any ? {
+    type: 'constructor';
+    params: ConstructorOverloadParameters<T>;
+    instance: DeepBrand<InstanceType<Extract<T, new (...args: any) => any>>>;
+} : T extends (...args: infer P) => infer R ? NumOverloads<T> extends 1 ? {
+    type: 'function';
+    params: DeepBrand<P>;
+    return: DeepBrand<R>;
+    this: DeepBrand<ThisParameterType<T>>;
+    props: DeepBrand<Omit<T, keyof Function>>;
+} : UnionToTuple<OverloadsInfoUnion<T>> extends infer OverloadsTuple ? {
+    type: 'overloads';
+    overloads: {
+        [K in keyof OverloadsTuple]: DeepBrand<OverloadsTuple[K]>;
+    };
+} : never : T extends any[] ? {
+    type: 'array';
+    items: {
+        [K in keyof T]: T[K];
+    };
+} : {
+    type: 'object';
+    properties: {
+        [K in keyof T]: DeepBrand<T[K]>;
+    };
+    readonly: ReadonlyKeys<T>;
+    required: RequiredKeys<T>;
+    optional: OptionalKeys<T>;
+    constructorParams: DeepBrand<ConstructorOverloadParameters<T>>;
+};
+/**
+ * Checks if two types are strictly equal using branding.
+ */
+type StrictEqualUsingBranding<Left, Right> = MutuallyExtends<DeepBrand<Left>, DeepBrand<Right>>;
+
+/**
+ * Borrowed from vitest
+ */
+type PrintType<T> = IsUnknown<T> extends true ? 'unknown' : IsNever<T> extends true ? 'never' : IsAny<T> extends true ? never : boolean extends T ? 'boolean' : T extends boolean ? `literal boolean: ${T}` : string extends T ? 'string' : T extends string ? `literal string: ${T}` : number extends T ? 'number' : T extends number ? `literal number: ${T}` : bigint extends T ? 'bigint' : T extends bigint ? `literal bigint: ${T}` : T extends null ? 'null' : T extends undefined ? 'undefined' : T extends (...args: any[]) => any ? 'function' : '...';
+/**
+ * Borrowed from vitest
+ */
+type MismatchInfo<Actual, Expected> = And<[Extends<PrintType<Actual>, '...'>, Not<IsAny<Actual>>]> extends true ? And<[Extends<any[], Actual>, Extends<any[], Expected>]> extends true ? Array<MismatchInfo<Extract<Actual, any[]>[number], Extract<Expected, any[]>[number]>> : {
+    [K in UsefulKeys<Actual> | UsefulKeys<Expected>]: MismatchInfo<K extends keyof Actual ? Actual[K] : never, K extends keyof Expected ? Expected[K] : never>;
+} : StrictEqualUsingBranding<Actual, Expected> extends true ? Actual : `[Regle error] The parent property does not match the form schema`;
+
 type ParamDecl<T = any> = MaybeRef<Maybe<T>> | (() => Maybe<T>);
 type CreateFn<T extends any[]> = (...args: T) => any;
 /**
@@ -373,6 +924,7 @@ interface RegleInternalRuleDefs<TValue extends any = any, TParams extends any[]
     _tooltip_patched: boolean;
     _params?: RegleUniversalParams<TParams>;
     _async: TAsync;
+    readonly _brand: symbol;
 }
 declare enum InternalRuleType {
     Inline = "__inline",
@@ -471,6 +1023,10 @@ interface RegleRuleCore<TValue extends any, TParams extends any[] = [], TAsync e
     tooltip?: RegleInitPropertyGetter<TValue, string | string[], TParams, TMetadata>;
     type?: string;
 }
+type RegleRuleTypeReturn<TValue, TParams extends [...any[]]> = {
+    value: TValue;
+    params: [...TParams];
+};
 
 type DefaultValidators = {
     alpha: RegleRuleDefinition<string>;
@@ -546,10 +1102,22 @@ type RegleRuleTree<TForm extends Record<string, any>, TCustomRules extends Parti
 type RegleComputedRules<TForm extends MaybeRef<Record<string, any>> | DeepReactiveState<Record<string, any>>, TCustomRules extends Partial<AllRulesDeclarations> | Regle<any, any> = Partial<AllRulesDeclarations>, TState = Unwrap<TForm>, TCustom = TCustomRules extends Regle<any, infer R> ? R extends ReglePartialRuleTree<any, infer C> ? C : Partial<AllRulesDeclarations> : TCustomRules> = {
     [TKey in keyof TState]?: RegleFormPropertyType<TState[TKey], TCustom extends Partial<AllRulesDeclarations> ? TCustom : {}>;
 };
+/**
+ * @internal
+ * @reference {@link ReglePartialRuleTree}
+ */
+type $InternalReglePartialRuleTree = {
+    [x: string]: $InternalFormPropertyTypes;
+};
 /**
  * @public
  */
 type RegleFormPropertyType<TValue = any, TCustomRules extends Partial<AllRulesDeclarations> = Partial<AllRulesDeclarations>> = [NonNullable<TValue>] extends [never] ? RegleRuleDecl<TValue, TCustomRules> : NonNullable<TValue> extends Array<any> ? RegleCollectionRuleDecl<TValue, TCustomRules> : NonNullable<TValue> extends Date ? RegleRuleDecl<NonNullable<TValue>, TCustomRules> : NonNullable<TValue> extends File ? RegleRuleDecl<NonNullable<TValue>, TCustomRules> : NonNullable<TValue> extends Ref<infer V> ? RegleFormPropertyType<V, TCustomRules> : NonNullable<TValue> extends Record<string, any> ? ReglePartialRuleTree<NonNullable<TValue>, TCustomRules> : RegleRuleDecl<NonNullable<TValue>, TCustomRules>;
+/**
+ * @internal
+ * @reference {@link RegleFormPropertyType}
+ */
+type $InternalFormPropertyTypes = $InternalRegleRuleDecl | $InternalRegleCollectionRuleDecl | $InternalReglePartialRuleTree | FieldRegleBehaviourOptions;
 /**
  * @public
  * Rule tree for a form property
@@ -557,6 +1125,11 @@ type RegleFormPropertyType<TValue = any, TCustomRules extends Partial<AllRulesDe
 type RegleRuleDecl<TValue extends any = any, TCustomRules extends Partial<AllRulesDeclarations> = Partial<AllRulesDeclarations>> = FieldRegleBehaviourOptions & {
     [TKey in keyof TCustomRules]?: NonNullable<TCustomRules[TKey]> extends RegleRuleWithParamsDefinition<any, infer TParams> ? RegleRuleDefinition<TValue, [...TParams, ...args: [...any[]]], boolean> : NonNullable<TCustomRules[TKey]> extends RegleRuleDefinition<any, any, any, any> ? FormRuleDeclaration<TValue, any> : FormRuleDeclaration<TValue, any> | FieldRegleBehaviourOptions[keyof FieldRegleBehaviourOptions];
 };
+/**
+ * @internal
+ * @reference {@link RegleRuleDecl}
+ */
+type $InternalRegleRuleDecl = FieldRegleBehaviourOptions & Record<string, FormRuleDeclaration<any, any>>;
 /**
  * @public
  */
@@ -571,6 +1144,13 @@ type RegleCollectionRuleDecl<TValue = any[], TCustomRules extends Partial<AllRul
 } & RegleRuleDecl<NonNullable<TValue>, TCustomRules>) | ({
     $each?: MaybeGetter<RegleFormPropertyType<ArrayElement<NonNullable<TValue>>, TCustomRules>, ArrayElement<TValue>, RegleCollectionRuleDeclKeyProperty>;
 } & FieldRegleBehaviourOptions);
+/**
+ * @internal
+ * @reference {@link RegleCollectionRuleDecl}
+ */
+type $InternalRegleCollectionRuleDecl = $InternalRegleRuleDecl & {
+    $each?: MaybeGetter<$InternalFormPropertyTypes & RegleCollectionRuleDeclKeyProperty, any>;
+};
 /**
  * @public
  */
@@ -596,6 +1176,18 @@ type RegleExternalCollectionErrors<TState extends Record<string, any>> = {
     readonly $self?: string[];
     readonly $each?: RegleValidationErrors<TState, true>[];
 };
+/** @internal */
+type $InternalRegleCollectionErrors = {
+    readonly $self?: string[];
+    readonly $each?: $InternalRegleErrors[];
+};
+type $InternalRegleErrorTree = {
+    [x: string]: $InternalRegleErrors;
+};
+/**
+ * @internal
+ */
+type $InternalRegleErrors = $InternalRegleCollectionErrors | string[] | $InternalRegleErrorTree;
 type PartialFormState<TState extends Record<string, any>> = [unknown] extends [TState] ? {} : Prettify<{
     [K in keyof TState as ExtendOnlyRealRecord<TState[K]> extends true ? never : TState[K] extends Array<any> ? never : K]?: Maybe<TState[K]>;
 } & {
@@ -608,6 +1200,10 @@ type RegleResult<Data extends Record<string, any> | any[] | unknown, TRules exte
     result: true;
     data: Data extends Array<infer U extends Record<string, any>> ? DeepSafeFormState<U, TRules>[] : Data extends Date | File ? SafeFieldProperty<Data, TRules> : Data extends Record<string, any> ? DeepSafeFormState<Data, TRules> : SafeFieldProperty<Data, TRules>;
 };
+type $InternalRegleResult = {
+    result: boolean;
+    data: any;
+};
 
 /**
  * @public
@@ -633,10 +1229,28 @@ type RegleStatus<TState extends Record<string, any> | undefined = Record<string,
 } & ([TShortcuts['nested']] extends [never] ? {} : {
     [K in keyof TShortcuts['nested']]: ReturnType<NonNullable<TShortcuts['nested']>[K]>;
 });
+/**
+ * @internal
+ * @reference {@link RegleStatus}
+ */
+interface $InternalRegleStatus extends RegleCommonStatus {
+    $fields: {
+        [x: string]: $InternalRegleStatusType;
+    };
+    readonly $errors: Record<string, $InternalRegleErrors>;
+    readonly $silentErrors: Record<string, $InternalRegleErrors>;
+    $extractDirtyFields: (filterNullishValues?: boolean) => Record<string, any>;
+    $validate: () => Promise<$InternalRegleResult>;
+}
 /**
  * @public
  */
 type InferRegleStatusType<TRule extends RegleCollectionRuleDecl | RegleRuleDecl | ReglePartialRuleTree<any>, TState extends Record<PropertyKey, any> = any, TKey extends PropertyKey = string, TShortcuts extends RegleShortcutDefinition = {}> = NonNullable<TState[TKey]> extends Array<Record<string, any> | any> ? TRule extends RegleCollectionRuleDefinition<any, any> ? ExtractFromGetter<TRule['$each']> extends ReglePartialRuleTree<any> ? RegleCollectionStatus<TState[TKey], ExtractFromGetter<TRule['$each']>, TRule, TShortcuts> : RegleFieldStatus<TState[TKey], TRule, TShortcuts> : RegleCollectionStatus<TState[TKey], {}, TRule, TShortcuts> : TRule extends ReglePartialRuleTree<any> ? NonNullable<TState[TKey]> extends Array<any> ? RegleCommonStatus<TState[TKey]> : NonNullable<TState[TKey]> extends Date | File ? RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Record<PropertyKey, any> ? RegleStatus<TState[TKey], TRule, TShortcuts> : RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Date | File ? RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Record<PropertyKey, any> ? RegleStatus<TState[TKey], ReglePartialRuleTree<TState[TKey]>, TShortcuts> : RegleFieldStatus<TState[TKey], TRule, TShortcuts>;
+/**
+ * @internal
+ * @reference {@link InferRegleStatusType}
+ */
+type $InternalRegleStatusType = $InternalRegleCollectionStatus | $InternalRegleStatus | $InternalRegleFieldStatus;
 /**
  * @public
  */
@@ -655,6 +1269,20 @@ type RegleFieldStatus<TState extends any = any, TRules extends RegleFormProperty
 } & ([TShortcuts['fields']] extends [never] ? {} : {
     [K in keyof TShortcuts['fields']]: ReturnType<NonNullable<TShortcuts['fields']>[K]>;
 });
+/**
+ * @internal
+ * @reference {@link RegleFieldStatus}
+ */
+interface $InternalRegleFieldStatus extends RegleCommonStatus {
+    $value: any;
+    $silentValue: any;
+    readonly $rules: Record<string, $InternalRegleRuleStatus>;
+    readonly $externalErrors?: string[];
+    readonly $errors: string[];
+    readonly $silentErrors: string[];
+    $extractDirtyFields: (filterNullishValues?: boolean) => any;
+    $validate: () => Promise<$InternalRegleResult>;
+}
 /**
  * @public
  */
@@ -697,6 +1325,29 @@ type RegleRuleStatus<TValue = any, TParams extends any[] = any[], TMetadata exte
 } : {
     readonly $params: TParams;
 });
+/**
+ * @internal
+ * @reference {@link RegleRuleStatus}
+ */
+interface $InternalRegleRuleStatus {
+    $type: string;
+    $message: string | string[];
+    $tooltip: string | string[];
+    $active: boolean;
+    $valid: boolean;
+    $pending: boolean;
+    $path: string;
+    $externalErrors?: string[];
+    $params?: any[];
+    $metadata: any;
+    $haveAsync: boolean;
+    $validating: boolean;
+    $validator(value: any, ...args: any[]): RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>;
+    $validate(): Promise<boolean>;
+    $unwatch(): void;
+    $watch(): void;
+    $reset(): void;
+}
 /**
  * @public
  */
@@ -712,6 +1363,22 @@ type RegleCollectionStatus<TState extends any[] = any[], TRules extends ReglePar
 } & ([TShortcuts['collections']] extends [never] ? {} : {
     [K in keyof TShortcuts['collections']]: ReturnType<NonNullable<TShortcuts['collections']>[K]>;
 });
+/**
+ * @internal
+ * @reference {@link RegleCollectionStatus}
+ */
+interface $InternalRegleCollectionStatus extends Omit<$InternalRegleStatus, '$fields' | '$errors' | '$silentErrors'> {
+    readonly $field: $InternalRegleFieldStatus;
+    readonly $each: Array<$InternalRegleStatusType>;
+    readonly $errors: $InternalRegleCollectionErrors;
+    readonly $silentErrors: $InternalRegleCollectionErrors;
+    readonly $externalErrors?: string[];
+    $extractDirtyFields: (filterNullishValues?: boolean) => any[];
+    $validate: () => Promise<$InternalRegleResult>;
+    /** Track each array state */
+    $unwatch(): void;
+    $watch(): void;
+}
 
 /**
  * @description
@@ -731,11 +1398,11 @@ type RegleCollectionStatus<TState extends any[] = any[], TRules extends ReglePar
  *
  * ```ts
  * // Create a simple rule with no params
- * import {ruleHelpers} from '@regle/rules';
+ * import {isFilled} from '@regle/rules';
  *
  * export const isFoo = createRule({
  *   validator(value: string) {
- *       if (ruleHelpers.isFilled(value)) {
+ *       if (isFilled(value)) {
  *           return value === 'foo';
  *       }
  *       return true
@@ -761,4 +1428,4 @@ declare function defineRegleConfig<TShortcuts extends RegleShortcutDefinition<TC
     inferRules: inferRulesFn<TCustomRules>;
 };
 
-export { type AllRulesDeclarations, type DeepMaybeRef, type FormRuleDeclaration, type InferRegleRoot, type InferRegleRule, type InferRegleRules, type InferRegleShortcuts, type InlineRuleDeclaration, InternalRuleType, type LocalRegleBehaviourOptions, type Maybe, type ParamDecl, type Regle, type RegleBehaviourOptions, type RegleCollectionErrors, type RegleCollectionRuleDecl, type RegleCollectionRuleDefinition, type RegleCollectionStatus, type RegleCommonStatus, type RegleComputedRules, type RegleEnforceCustomRequiredRules, type RegleEnforceRequiredRules, type RegleErrorTree, type RegleExternalErrorTree, type RegleFieldStatus, type RegleFormPropertyType, type RegleInternalRuleDefs, type ReglePartialRuleTree, type RegleResult, type RegleRoot, type RegleRuleCore, type RegleRuleDecl, type RegleRuleDefinition, type RegleRuleDefinitionProcessor, type RegleRuleDefinitionWithMetadataProcessor, type RegleRuleInit, type RegleRuleMetadataConsumer, type RegleRuleMetadataDefinition, type RegleRuleRaw, type RegleRuleStatus, type RegleRuleWithParamsDefinition, type RegleStatus, type RegleUniversalParams, type RegleValidationErrors, type RegleValidationGroupEntry, type RegleValidationGroupOutput, type RegleRuleTree as RegleValidationTree, type Unwrap, type UnwrapRegleUniversalParams, type UnwrapRuleWithParams, createRule, defineRegleConfig, inferRules, unwrapRuleParameters, useRegle };
+export { type $InternalRegleStatus, type AllRulesDeclarations, type DeepMaybeRef, type FormRuleDeclaration, type InferRegleRoot, type InferRegleRule, type InferRegleRules, type InferRegleShortcuts, type InferRegleStatusType, type InlineRuleDeclaration, InternalRuleType, type LocalRegleBehaviourOptions, type Maybe, type NoInferLegacy, type ParamDecl, type PrimitiveTypes, type Regle, type RegleBehaviourOptions, type RegleCollectionErrors, type RegleCollectionRuleDecl, type RegleCollectionRuleDefinition, type RegleCollectionStatus, type RegleCommonStatus, type RegleComputedRules, type RegleEnforceCustomRequiredRules, type RegleEnforceRequiredRules, type RegleErrorTree, type RegleExternalCollectionErrors, type RegleExternalErrorTree, type RegleFieldStatus, type RegleFormPropertyType, type RegleInternalRuleDefs, 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 RegleShortcutDefinition, type RegleStatus, type RegleUniversalParams, type RegleValidationErrors, type RegleValidationGroupEntry, type RegleValidationGroupOutput, type RegleRuleTree as RegleValidationTree, type ResolvedRegleBehaviourOptions, type Unwrap, type UnwrapRegleUniversalParams, type UnwrapRuleWithParams, createRule, defineRegleConfig, inferRules, unwrapRuleParameters, useRegle, useRootStorage };