@regle/core 0.0.12 → 0.0.14

package/dist/index.d.ts

@@ -1,18 +1,15 @@
-import * as vue from 'vue';
-import { MaybeRef, Ref, ComputedRef } from 'vue';
+import { MaybeRef, ComputedRef, Ref, UnwrapNestedRefs } from 'vue';
 
-type ArrayElement<T> = T extends Array<infer U> ? U : never;
-type ExcludeFromTuple<T extends readonly any[], E> = T extends [infer F, ...infer R] ? [NonNullable<F>] extends [E] ? ExcludeFromTuple<R, E> : [Exclude<F, E>, ...ExcludeFromTuple<R, E>] : [];
-type UnrefTuple<T extends readonly any[]> = T extends [infer F, ...infer R] ? [NonNullable<F>] extends [MaybeRef<infer U>] ? [U, ...UnrefTuple<R>] : [F, ...UnrefTuple<R>] : [];
-
-type Maybe<T> = T | null | undefined;
-type MaybeNull<T> = T | null;
+type Maybe<T = any> = T | null | undefined;
 type DeepMaybeRef<T extends Record<string, any>> = {
     [K in keyof T]: MaybeRef<T[K]>;
 };
 type ExcludeByType<T, U> = {
     [K in keyof T as T[K] extends U ? never : K]: T[K] extends U ? never : T[K];
 };
+type NonPresentKeys<TSource extends Record<string, any>, Target extends Record<string, any>> = Omit<Target, keyof TSource>;
+
+type ArrayElement<T> = T extends Array<infer U> ? U : never;
 
 type ParamDecl<T = any> = MaybeRef<Maybe<T>> | (() => Maybe<T>);
 type CreateFn<T extends any[]> = (...args: T) => any;
@@ -51,22 +48,12 @@ declare enum InternalRuleType {
 /**
  * Returned typed of rules created with `createRule`
  * */
-interface RegleRuleDefinition<TValue extends any = any, TParams extends any[] = [], TAsync extends boolean = boolean, TMetaData extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition> extends RegleInternalRuleDefs<TValue, TParams, TAsync, TMetaData> {
-    validator: RegleRuleDefinitionProcessor<TValue, TParams, TAsync extends false ? TMetaData : Promise<TMetaData>>;
-    message: RegleRuleDefinitionWithMetadataProcessor<TValue, PossibleRegleRuleMetadataConsumer, string | string[]>;
-    active: RegleRuleDefinitionWithMetadataProcessor<TValue, PossibleRegleRuleMetadataConsumer, boolean>;
-    type?: string;
-    exec: (value: Maybe<TValue>) => TAsync extends false ? TMetaData : Promise<TMetaData>;
-}
-/**
- * @internal
- * */
-interface $InternalRegleRuleDefinition extends RegleInternalRuleDefs<any, any, any> {
-    validator: RegleRuleDefinitionProcessor;
-    message: RegleRuleDefinitionWithMetadataProcessor<any, any, any>;
-    active: RegleRuleDefinitionWithMetadataProcessor<any, any, any>;
+interface RegleRuleDefinition<TValue extends any = any, TParams extends any[] = [], TAsync extends boolean = boolean, TMetaData extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, TFilteredValue extends any = TValue extends Date & File & infer M ? M : TValue> extends RegleInternalRuleDefs<TFilteredValue, TParams, TAsync, TMetaData> {
+    validator: RegleRuleDefinitionProcessor<TFilteredValue, TParams, TAsync extends false ? TMetaData : Promise<TMetaData>>;
+    message: RegleRuleDefinitionWithMetadataProcessor<TFilteredValue, PossibleRegleRuleMetadataConsumer, string | string[]>;
+    active: RegleRuleDefinitionWithMetadataProcessor<TFilteredValue, PossibleRegleRuleMetadataConsumer, boolean>;
     type?: string;
-    exec: (value: any) => RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>;
+    exec: (value: Maybe<TFilteredValue>) => TAsync extends false ? TMetaData : Promise<TMetaData>;
 }
 /**
  * Rules with params created with `createRules` are callable while being customizable
@@ -74,33 +61,27 @@ interface $InternalRegleRuleDefinition extends RegleInternalRuleDefs<any, any, a
 interface RegleRuleWithParamsDefinition<TValue extends any = any, TParams extends any[] = [], TAsync extends boolean = false, TMetadata extends RegleRuleMetadataDefinition = boolean> extends RegleRuleCore<TValue, TParams, TAsync, TMetadata>, RegleInternalRuleDefs<TValue, TParams, TAsync, TMetadata> {
     (...params: RegleUniversalParams<TParams>): RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>;
 }
+type RegleRuleMetadataExtended = {
+    $valid: boolean;
+    [x: string]: any;
+};
 /**
  * Define a rule Metadata definition
  */
-type RegleRuleMetadataDefinition = {
-    $valid: boolean;
-    [x: string]: any;
-} | boolean;
+type RegleRuleMetadataDefinition = RegleRuleMetadataExtended | boolean;
 type DefaultMetadataProperties = Pick<ExcludeByType<RegleCommonStatus, Function>, '$invalid'>;
 /**
  * Will be used to consumme metadata on related helpers and rule status
  */
 type RegleRuleMetadataConsumer<TParams extends any[] = [], TMetadata extends RegleRuleMetadataDefinition = boolean> = DefaultMetadataProperties & (TParams extends never ? {} : {
     $params: TParams;
-}) & (TMetadata extends boolean ? {} : Omit<TMetadata, '$valid'>);
+}) & (Exclude<TMetadata, boolean> extends RegleRuleMetadataExtended ? TMetadata extends boolean ? Partial<Omit<Exclude<TMetadata, boolean>, '$valid'>> : Omit<Exclude<TMetadata, boolean>, '$valid'> : {});
 /**
  * Will be used to consumme metadata on related helpers and rule status
  */
 type PossibleRegleRuleMetadataConsumer = DefaultMetadataProperties & {
     $params?: any[];
 };
-/**
- * @internal
- */
-type $InternalRegleRuleMetadataConsumer = DefaultMetadataProperties & {
-    $params?: any[];
-    [x: string]: any;
-};
 /**
  * Generic types for a created RegleRule
  */
@@ -142,16 +123,6 @@ interface RegleRuleCore<TValue extends any, TParams extends any[] = [], TAsync e
     active?: boolean | ((value: Maybe<TValue>, metadata: RegleRuleMetadataConsumer<TParams, TMetadata>) => boolean);
     type?: string;
 }
-/**
- * @internal
- * createRule arguments options
- */
-interface $InternalRegleRuleInit {
-    validator: (value: any, ...args: any[]) => RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>;
-    message: string | ((value: any, metadata: $InternalRegleRuleMetadataConsumer) => string | string[]);
-    active?: boolean | ((value: any, metadata: $InternalRegleRuleMetadataConsumer) => boolean);
-    type?: string;
-}
 
 type DefaultValidators = {
     maxLength: RegleRuleWithParamsDefinition<string, [count: number]>;
@@ -182,20 +153,6 @@ type CustomRulesDeclarationTree = {
 };
 type AllRulesDeclarations = CustomRulesDeclarationTree & DefaultValidators;
 
-/**
-Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
-
-@category Type
-*/
-type Primitive =
-	| null
-	| undefined
-	| string
-	| number
-	| boolean
-	| symbol
-	| bigint;
-
 declare global {
 	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
 	interface SymbolConstructor {
@@ -203,227 +160,50 @@ declare global {
 	}
 }
 
-/**
-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_: any[]): unknown}
-		? unknown[] extends A
-			? false
-			: true
-		: false;
-
-/**
-@see PartialDeep
-*/
-type PartialDeepOptions = {
-	/**
-	Whether to affect the individual elements of arrays and tuples.
-
-	@default false
-	*/
-	readonly recurseIntoArrays?: boolean;
-};
-
-/**
-Create a type from another type with all keys and nested keys set to optional.
-
-Use-cases:
-- Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
-- Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.
-
-@example
-```
-import type {PartialDeep} from 'type-fest';
-
-const settings: Settings = {
-	textEditor: {
-		fontSize: 14;
-		fontColor: '#000000';
-		fontWeight: 400;
-	}
-	autocomplete: false;
-	autosave: true;
-};
-
-const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
-	return {...settings, ...savedSettings};
-}
-
-settings = applySavedSettings({textEditor: {fontWeight: 500}});
-```
-
-By default, this does not affect elements in array and tuple types. You can change this by passing `{recurseIntoArrays: true}` as the second type argument:
-
-```
-import type {PartialDeep} from 'type-fest';
-
-interface Settings {
-	languages: string[];
-}
-
-const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
-	languages: [undefined]
-};
-```
-
-@category Object
-@category Array
-@category Set
-@category Map
-*/
-type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends BuiltIns | (((...arguments_: any[]) => unknown)) | (new (...arguments_: any[]) => unknown)
-	? T
-	: T extends Map<infer KeyType, infer ValueType>
-		? PartialMapDeep<KeyType, ValueType, Options>
-		: T extends Set<infer ItemType>
-			? PartialSetDeep<ItemType, Options>
-			: T extends ReadonlyMap<infer KeyType, infer ValueType>
-				? PartialReadonlyMapDeep<KeyType, ValueType, Options>
-				: T extends ReadonlySet<infer ItemType>
-					? PartialReadonlySetDeep<ItemType, Options>
-					: T extends object
-						? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
-							? Options['recurseIntoArrays'] extends true
-								? ItemType[] extends T // Test for arrays (non-tuples) specifically
-									? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
-										? ReadonlyArray<PartialDeep<ItemType | undefined, Options>>
-										: Array<PartialDeep<ItemType | undefined, Options>>
-									: PartialObjectDeep<T, Options> // Tuples behave properly
-								: T // If they don't opt into array testing, just use the original type
-							: PartialObjectDeep<T, Options>
-						: unknown;
-
-/**
-Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
-*/
-type PartialMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> = {} & Map<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>>;
-
-/**
-Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
-*/
-type PartialSetDeep<T, Options extends PartialDeepOptions> = {} & Set<PartialDeep<T, Options>>;
-
-/**
-Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
-*/
-type PartialReadonlyMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> = {} & ReadonlyMap<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>>;
-
-/**
-Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
-*/
-type PartialReadonlySetDeep<T, Options extends PartialDeepOptions> = {} & ReadonlySet<PartialDeep<T, Options>>;
+declare const emptyObjectSymbol: unique symbol;
 
 /**
-Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
-*/
-type PartialObjectDeep<ObjectType extends object, Options extends PartialDeepOptions> = {
-	[KeyType in keyof ObjectType]?: PartialDeep<ObjectType[KeyType], Options>
-};
+Represents a strictly empty plain object, the `{}` value.
 
-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.
+When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
 
 @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;
-// }
+import type {EmptyObject} from 'type-fest';
+
+// The following illustrates the problem with `{}`.
+const foo1: {} = {}; // Pass
+const foo2: {} = []; // Pass
+const foo3: {} = 42; // Pass
+const foo4: {} = {a: 1}; // Pass
+
+// With `EmptyObject` only the first case is valid.
+const bar1: EmptyObject = {}; // Pass
+const bar2: EmptyObject = 42; // Fail
+const bar3: EmptyObject = []; // Fail
+const bar4: EmptyObject = {a: 1}; // Fail
 ```
 
-Note that types containing overloaded functions are not made deeply required due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
+Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
 
-@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]>
-};
+type EmptyObject = {[emptyObjectSymbol]?: never};
 
-interface Regle<TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, CustomRulesDeclarationTree>> {
-    $state: Ref<PartialDeep<TState>>;
-    $regle: RegleStatus<TState, TRules>;
+interface Regle<TState extends Record<string, any> = EmptyObject, TRules extends ReglePartialValidationTree<TState, CustomRulesDeclarationTree> = EmptyObject, TExternal extends RegleExternalErrorTree<TState> = never> {
+    regle: RegleStatus<TState, TRules>;
     /** Show active errors based on your behaviour options (lazy, autoDirty)
-     * It allow you to skip scouting the `$regle` object
+     * It allow you to skip scouting the `regle` object
      */
-    $errors: RegleErrorTree<TRules>;
-    $valid: ComputedRef<boolean>;
-    $invalid: ComputedRef<boolean>;
+    errors: RegleErrorTree<TRules, TExternal>;
+    invalid: ComputedRef<boolean>;
     resetForm: () => void;
     validateForm: () => Promise<false | DeepSafeFormState<TState, TRules>>;
 }
 type DeepReactiveState<T extends Record<string, any>> = {
     [K in keyof T]: MaybeRef<T[K]>;
 };
-type DeepSafeFormState<TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, CustomRulesDeclarationTree>> = {
+type DeepSafeFormState<TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, CustomRulesDeclarationTree>> = [unknown] extends [TState] ? {} : {
     [K in keyof TState as [SafeProperty<TState[K], TRules[K]>] extends [never] ? K : never]?: [
         SafeProperty<TState[K], TRules[K]>
     ] extends [never] ? TState[K] : SafeProperty<TState[K], TRules[K]>;
@@ -451,22 +231,15 @@ interface RegleBehaviourOptions {
      */
     rewardEarly?: boolean;
 }
-interface LocalRegleBehaviourOptions<TState extends Record<string, any>> {
-    $externalErrors?: MaybeRef<RegleExternalErrorTree<TState>>;
+interface LocalRegleBehaviourOptions<TState extends Record<string, any>, TExternal extends RegleExternalErrorTree<TState>> {
+    $externalErrors?: MaybeRef<TExternal>;
 }
 type FieldRegleBehaviourOptions = AddDollarToOptions<RegleBehaviourOptions> & {
     $debounce?: number;
 };
-type ResolvedRegleBehaviourOptions = DeepMaybeRef<RequiredDeep<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<Record<string, any>>;
 type AddDollarToOptions<T extends Record<string, any>> = {
     [K in keyof T as `$${string & K}`]: T[K];
 };
-type FilterDollarProperties<T extends Record<string, any>> = {
-    [K in keyof T as K extends `$${string}` ? never : K]: T[K];
-};
-type PickDollarProperties<T extends Record<string, any>> = {
-    [K in keyof T as K extends `$${string}` ? K : never]: T[K];
-};
 
 /**
  * @public
@@ -481,21 +254,15 @@ type RegleValidationTree<TForm extends Record<string, any>, TCustomRules extends
     [TKey in keyof TForm]: RegleFormPropertyType<TForm[TKey], TCustomRules>;
 };
 /**
- * @internal
- * @reference {@link ReglePartialValidationTree}
+ * @public
  */
-type $InternalReglePartialValidationTree = {
-    [x: string]: $InternalFormPropertyTypes;
+type RegleComputedRules<TForm extends MaybeRef<Record<string, any>>, TCustomRules extends Partial<AllRulesDeclarations> | Regle<any, any> = Partial<AllRulesDeclarations>, TState = TForm extends Ref<infer R> ? R : TForm, TCustom = TCustomRules extends Regle<any, infer R> ? R extends ReglePartialValidationTree<any, infer C> ? C : Partial<AllRulesDeclarations> : TCustomRules> = {
+    [TKey in keyof TState]?: RegleFormPropertyType<TState[TKey], TCustom extends Partial<AllRulesDeclarations> ? TCustom : {}>;
 };
 /**
  * @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 Record<string, any> ? ReglePartialValidationTree<NonNullable<TValue>, TCustomRules> : RegleRuleDecl<NonNullable<TValue>, TCustomRules>;
-/**
- * @internal
- * @reference {@link RegleFormPropertyType}
- */
-type $InternalFormPropertyTypes = $InternalRegleRuleDecl | $InternalRegleCollectionRuleDecl | $InternalReglePartialValidationTree;
+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> ? ReglePartialValidationTree<NonNullable<TValue>, TCustomRules> : RegleRuleDecl<NonNullable<TValue>, TCustomRules>;
 /**
  * @public
  * Rule tree for a form property
@@ -503,11 +270,6 @@ type $InternalFormPropertyTypes = $InternalRegleRuleDecl | $InternalRegleCollect
 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, 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 = Record<string, FormRuleDeclaration<any, any>>;
 /**
  * @public
  */
@@ -516,36 +278,26 @@ type RegleCollectionRuleDecl<TValue = any[], TCustomRules extends Partial<AllRul
 }) | {
     $each?: RegleFormPropertyType<ArrayElement<NonNullable<TValue>>, TCustomRules>;
 };
-/**
- * @internal
- * @reference {@link RegleCollectionRuleDecl}
- *
- */
-type $InternalRegleCollectionRuleDecl = $InternalRegleRuleDecl & {
-    $each?: $InternalFormPropertyTypes;
-};
 /**
  * @public
  */
-type InlineRuleDeclaration<TValue extends any, TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>> = (value: Maybe<TValue>, ...args: any[]) => TReturn;
+type InlineRuleDeclaration<TValue extends any = any, TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>> = (value: Maybe<TValue>, ...args: any[]) => TReturn;
 /**
  * @public
  * Regroup inline and registered rules
  * */
-type FormRuleDeclaration<TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition, TMetadata extends RegleRuleMetadataDefinition = TReturn extends Promise<infer M> ? M : TReturn, TAsync extends boolean = boolean> = InlineRuleDeclaration<TValue, TReturn> | RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>;
+type FormRuleDeclaration<TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata extends RegleRuleMetadataDefinition = TReturn extends Promise<infer M> ? M : TReturn, TAsync extends boolean = boolean> = InlineRuleDeclaration<TValue, TReturn> | RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>;
 
-type RegleErrorTree<TRules extends ReglePartialValidationTree<any, any>> = {
-    readonly [K in keyof TRules]: RegleValidationErrors<TRules[K]>;
+type RegleErrorTree<TRules extends ReglePartialValidationTree<any, any>, TExternal extends RegleExternalErrorTree<Record<string, unknown>> = never> = {
+    readonly [K in keyof TRules]: RegleValidationErrors<TRules[K], K extends keyof TExternal ? TExternal[K] : never>;
+} & {
+    readonly [K in keyof NonPresentKeys<TRules, TExternal>]: RegleExternalValidationErrorsReport<TExternal[K]>;
 };
-type RegleValidationErrors<TRule extends RegleFormPropertyType<any, any> | undefined = never> = TRule extends RegleCollectionRuleDefinition ? RegleCollectionErrors<TRule['$each']> : TRule extends ReglePartialValidationTree<any, any> ? RegleErrorTree<TRule> : TRule extends RegleRuleDecl<any, any> ? string[] : string[];
-type RegleCollectionErrors<TRule extends RegleFormPropertyType<any, any> | undefined = never> = {
+type RegleValidationErrors<TRule extends RegleFormPropertyType<any, any> | undefined = never, TExternalError extends RegleExternalValidationErrors<any> | undefined = never> = TRule extends RegleCollectionRuleDefinition ? RegleCollectionErrors<TRule['$each'], TExternalError extends RegleExternalCollectionErrors ? ArrayElement<TExternalError['$each']> : never> : TRule extends RegleRuleDecl<any, any> ? string[] : TRule extends ReglePartialValidationTree<any, any> ? RegleErrorTree<TRule, TExternalError extends RegleExternalErrorTree ? TExternalError : never> : string[];
+type RegleCollectionErrors<TRule extends RegleFormPropertyType<any, any> | undefined = never, TExternalError extends RegleExternalValidationErrors<any> | undefined = never> = {
     readonly $errors: string[];
-    readonly $each: RegleValidationErrors<TRule>[];
+    readonly $each: RegleValidationErrors<TRule, TExternalError>[];
 };
-/**
- * @internal
- */
-type $InternalRegleErrors = RegleCollectionErrors<any> | string[] | RegleErrorTree<any>;
 type RegleExternalErrorTree<TState extends Record<string, any> = Record<string, any>> = {
     [K in keyof TState]?: RegleExternalValidationErrors<TState[K]>;
 };
@@ -556,8 +308,7 @@ type RegleExternalCollectionErrors<TValue extends any = any> = {
     $errors?: string[];
     $each?: RegleExternalValidationErrors<TValue>[];
 };
-type $InternalExternalRegleErrors = RegleExternalCollectionErrors<any> | string[] | RegleExternalErrorTree<any>;
-type DataType = string | number | Record<string, any> | File | Array<any> | Date | null | undefined;
+type RegleExternalValidationErrorsReport<TExternalError extends RegleExternalValidationErrors<any> | undefined = never> = TExternalError extends RegleExternalCollectionErrors ? RegleCollectionErrors<TExternalError['$each']> : TExternalError extends string[] ? string[] : TExternalError extends RegleExternalErrorTree<any> ? RegleErrorTree<TExternalError> : string[];
 
 /**
  * @public
@@ -567,43 +318,20 @@ interface RegleStatus<TState extends Record<string, any> = Record<string, any>,
         readonly [TKey in keyof TRules]: InferRegleStatusType<NonNullable<TRules[TKey]>, TState, TKey>;
     };
 }
-/**
- * @internal
- * @reference {@link RegleStatus}
- */
-interface $InternalRegleStatus extends RegleCommonStatus {
-    $fields: {
-        [x: string]: $InternalRegleStatusType;
-    };
-}
 /**
  * @public
  */
-type InferRegleStatusType<TRule extends RegleCollectionRuleDecl | RegleRuleDecl | ReglePartialValidationTree<any>, TState extends Record<PropertyKey, any> = any, TKey extends PropertyKey = string> = TRule extends RegleCollectionRuleDefinition<any, any> ? RegleCollectionStatus<TRule['$each'], TState[TKey]> : TRule extends ReglePartialValidationTree<any> ? TState[TKey] extends Array<any> ? RegleCommonStatus<TState[TKey]> : RegleStatus<TState[TKey], TRule> : RegleFieldStatus<TRule, TState, TKey>;
-/**
- * @internal
- * @reference {@link InferRegleStatusType}
- */
-type $InternalRegleStatusType = $InternalRegleCollectionStatus | RegleCommonStatus | $InternalRegleStatus | $InternalRegleFieldStatus;
+type InferRegleStatusType<TRule extends RegleCollectionRuleDecl | RegleRuleDecl | ReglePartialValidationTree<any>, TState extends Record<PropertyKey, any> = any, TKey extends PropertyKey = string> = TRule extends RegleCollectionRuleDefinition<any, any> ? NonNullable<TState[TKey]> extends Array<Record<string, any> | any> ? RegleCollectionStatus<TRule['$each'], TState[TKey]> : RegleFieldStatus<TRule, TState, TKey> : TRule extends ReglePartialValidationTree<any> ? NonNullable<TState[TKey]> extends Array<any> ? RegleCommonStatus<TState[TKey]> : NonNullable<TState[TKey]> extends Record<PropertyKey, any> ? RegleStatus<TState[TKey], TRule> : RegleFieldStatus<TRule, TState, TKey> : RegleFieldStatus<TRule, TState, TKey>;
 /**
  * @public
  */
 interface RegleFieldStatus<TRules extends RegleFormPropertyType<any, Partial<AllRulesDeclarations>> = Record<string, any>, TState extends Record<PropertyKey, any> = any, TKey extends PropertyKey = string> extends RegleCommonStatus<TState> {
-    $value: TState[TKey];
+    $value: UnwrapNestedRefs<TState[TKey]>;
     readonly $externalErrors?: string[];
     readonly $rules: {
         readonly [TRuleKey in keyof TRules]: RegleRuleStatus<TState[TKey], TRules[TRuleKey] extends RegleRuleDefinition<any, infer TParams> ? TParams : []>;
     };
 }
-/**
- * @internal
- * @reference {@link RegleFieldStatus}
- */
-interface $InternalRegleFieldStatus extends RegleCommonStatus {
-    $value: any;
-    $rules: Record<string, $InternalRegleRuleStatus>;
-    $externalErrors?: string[];
-}
 /**
  * @public
  */
@@ -614,8 +342,8 @@ interface RegleCommonStatus<TValue = any> {
     readonly $anyDirty: boolean;
     readonly $pending: boolean;
     readonly $error: boolean;
-    $id?: string;
-    $value: TValue;
+    $id?: number;
+    $value: UnwrapNestedRefs<TValue>;
     $touch(): void;
     $reset(): void;
     $validate(): Promise<boolean>;
@@ -635,47 +363,16 @@ type RegleRuleStatus<TValue = any, TParams extends any[] = any[]> = {
     readonly $path: string;
     $validator: (value: TValue, ...args: TParams) => boolean | Promise<boolean>;
     $validate(): Promise<boolean>;
+    $reset(): void;
 } & ([TParams] extends [[]] ? {} : {
     readonly $params: TParams;
 });
-/**
- * @internal
- * @reference {@link RegleRuleStatus}
- */
-interface $InternalRegleRuleStatus {
-    $type: string;
-    $message: string | string[];
-    $active: boolean;
-    $valid: boolean;
-    $pending: boolean;
-    $path: string;
-    $externalErrors?: string[];
-    $params?: any[];
-    $validator(value: any, ...args: any[]): RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>;
-    $validate(): Promise<boolean>;
-    $unwatch(): void;
-    $watch(): void;
-}
 /**
  * @public
  */
 interface RegleCollectionStatus<TRules extends RegleRuleDecl | ReglePartialValidationTree<any>, TState extends any[]> extends RegleFieldStatus<TRules, TState> {
     readonly $each: Array<InferRegleStatusType<NonNullable<TRules>, TState, number>>;
 }
-/**
- * @internal
- * @reference {@link RegleCollectionStatus}
- */
-interface $InternalRegleCollectionStatus extends Omit<$InternalRegleStatus, '$fields'> {
-    $each: Array<$InternalRegleStatusType>;
-    $rules?: Record<string, $InternalRegleRuleStatus>;
-    /** Track each array state */
-    $unwatch(): void;
-    $watch(): void;
-    $fields?: {
-        [x: string]: $InternalRegleStatusType;
-    };
-}
 
 /**
  * @description
@@ -697,7 +394,8 @@ interface $InternalRegleCollectionStatus extends Omit<$InternalRegleStatus, '$fi
  * // Create a simple rule with no params
  * import {ruleHelpers} from '@regle/validators';
  *
- * export const isFoo = createRule<string>({
+ * export const isFoo = createRule({
+ *   type: defineType<string>('foo'),
  *   validator(value) {
  *       if (ruleHelpers.isFilled(value)) {
  *           return value === 'foo';
@@ -720,7 +418,7 @@ declare function defineType<TValue extends any = unknown, TParams extends any[]
  */
 declare function unwrapRuleParameters<TParams extends any[]>(params: ParamDecl[]): TParams;
 
-declare const useRegle: <TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, Partial<AllRulesDeclarations>>, TValid = keyof TRules extends keyof TState ? true : false>(state: Ref<TState> | DeepReactiveState<TState>, rulesFactory: TValid extends true ? TRules | ComputedRef<TRules> | (() => TRules) : never, options?: (Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<TState>) | undefined) => Regle<TState, TRules>;
+declare const useRegle: <TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, Partial<AllRulesDeclarations>>, TExternal extends RegleExternalErrorTree<TState>, TValid = keyof TRules extends keyof TState ? true : false>(state: Ref<TState, TState> | DeepReactiveState<TState>, rulesFactory: TValid extends true ? TRules | ComputedRef<TRules> | (() => TRules) : never, options?: (Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<TState, TExternal>) | undefined) => Regle<TState, TRules, TExternal>;
 
 /**
  * Root function that allows you to define project-wise all your custom validators or overwrite default ones
@@ -732,6 +430,6 @@ declare const useRegle: <TState extends Record<string, any>, TRules extends Regl
 declare function defineRegleConfig<TCustomRules extends Partial<AllRulesDeclarations>>({ rules, options, }: {
     rules?: () => TCustomRules;
     options?: RegleBehaviourOptions;
-}): <TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, Partial<AllRulesDeclarations> & TCustomRules>, TValid = keyof TRules extends keyof TState ? true : false>(state: vue.Ref<TState> | DeepReactiveState<TState>, rulesFactory: TValid extends true ? TRules | vue.ComputedRef<TRules> | (() => TRules) : never, options?: (Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<TState>) | undefined) => Regle<TState, TRules>;
+}): <TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, Partial<AllRulesDeclarations> & TCustomRules>, TExternal extends RegleExternalErrorTree<TState>, TValid = keyof TRules extends keyof TState ? true : false>(state: Ref<TState, TState> | DeepReactiveState<TState>, rulesFactory: TValid extends true ? TRules | ComputedRef<TRules> | (() => TRules) : never, options?: (Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<TState, TExternal>) | undefined) => Regle<TState, TRules, TExternal>;
 
-export { type $InternalExternalRegleErrors, type $InternalFormPropertyTypes, type $InternalRegleCollectionRuleDecl, type $InternalRegleCollectionStatus, type $InternalRegleErrors, type $InternalRegleFieldStatus, type $InternalReglePartialValidationTree, type $InternalRegleRuleDecl, type $InternalRegleRuleDefinition, type $InternalRegleRuleInit, type $InternalRegleRuleMetadataConsumer, type $InternalRegleRuleStatus, type $InternalRegleStatus, type $InternalRegleStatusType, type AddDollarToOptions, type AllRulesDeclarations, type ArrayElement, type CustomRulesDeclarationTree, type DataType, type DeepMaybeRef, type DeepReactiveState, type DeepSafeFormState, type ExcludeByType, type ExcludeFromTuple, type FieldRegleBehaviourOptions, type FilterDollarProperties, type FormRuleDeclaration, type InferRegleRule, type InferRegleStatusType, type InlineRuleDeclaration, InternalRuleType, type LocalRegleBehaviourOptions, type Maybe, type MaybeNull, type ParamDecl, type PickDollarProperties, type PossibleRegleRuleMetadataConsumer, type Regle, type RegleBehaviourOptions, type RegleCollectionErrors, type RegleCollectionRuleDecl, type RegleCollectionRuleDefinition, type RegleCollectionStatus, type RegleCommonStatus, type RegleErrorTree, type RegleExternalCollectionErrors, type RegleExternalErrorTree, type RegleExternalValidationErrors, type RegleFieldStatus, type RegleFormPropertyType, type RegleInternalRuleDefs, type ReglePartialValidationTree, 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 RegleValidationTree, type ResolvedRegleBehaviourOptions, type SafeProperty, type UnrefTuple, type UnwrapRegleUniversalParams, createRule, defineRegleConfig, defineType, unwrapRuleParameters, useRegle };
+export { type DeepMaybeRef, type FormRuleDeclaration, 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 RegleErrorTree, type RegleExternalCollectionErrors, type RegleExternalErrorTree, type RegleExternalValidationErrors, type RegleFieldStatus, type RegleFormPropertyType, type ReglePartialValidationTree, 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 RegleValidationTree, type UnwrapRegleUniversalParams, createRule, defineRegleConfig, defineType, unwrapRuleParameters, useRegle };