@regle/core 0.0.5 → 0.0.7

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import * as vue from 'vue';
-import { MaybeRef, Ref } from 'vue';
-import { PartialDeep } from 'type-fest';
+import { MaybeRef, Ref, ComputedRef } from 'vue';
+import { DeepMaybeRef as DeepMaybeRef$1 } from 'types/utils';
+import { DeepReactiveState as DeepReactiveState$1 } from 'types/core/useRegle.types';
 
 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>] : [];
@@ -11,40 +12,11 @@ type MaybeNull<T> = T | null;
 type DeepMaybeRef<T extends Record<string, any>> = {
     [K in keyof T]: MaybeRef<T[K]>;
 };
-
-/**
- * @argument
- * createRule arguments options
- */
-interface RegleRuleInit<TValue extends any, TParams extends any[] = [], TType extends string = string> {
-    validator: (value: Maybe<TValue>, ...args: TParams) => boolean | Promise<boolean>;
-    message: string | ((value: Maybe<TValue>, ...args: TParams) => string);
-    active?: boolean | ((value: Maybe<TValue>, ...args: TParams) => boolean);
-    type: TType;
-}
-
-type DefaultValidators = {
-    maxLength: RegleRuleWithParamsDefinition<string, [count: number]>;
-    required: RegleRuleDefinition<unknown, []>;
-    requiredIf: RegleRuleWithParamsDefinition<unknown, [condition: boolean]>;
-    alpha: RegleRuleDefinition<string>;
-    alphaNum: RegleRuleDefinition<string | number>;
-    between: RegleRuleWithParamsDefinition<number, [min: number, max: number]>;
-    decimal: RegleRuleDefinition<number | string>;
-    email: RegleRuleDefinition<string>;
-    integer: RegleRuleDefinition<number | string>;
-    maxValue: RegleRuleWithParamsDefinition<number, [count: number]>;
-    minLength: RegleRuleWithParamsDefinition<string | Record<PropertyKey, any> | any[], [
-        count: number
-    ]>;
-    minValue: RegleRuleWithParamsDefinition<number, [count: number]>;
-    numeric: RegleRuleDefinition<number | string>;
-    requireUnless: RegleRuleWithParamsDefinition<unknown, [condition: boolean]>;
-    sameAs: RegleRuleWithParamsDefinition<unknown, [target: unknown]>;
-    url: RegleRuleDefinition<string>;
+type ExcludeByType<T, U> = {
+    [K in keyof T as T[K] extends U ? never : K]: T[K] extends U ? never : T[K];
 };
 
-type ParamDecl<T = any> = MaybeRef<T> | (() => T);
+type ParamDecl<T = any> = MaybeRef<Maybe<T>> | (() => Maybe<T>);
 type CreateFn<T extends any[]> = (...args: T) => any;
 /**
  * Transform normal parameters tuple declaration to a rich tuple declaration
@@ -64,14 +36,14 @@ type UnwrapRegleUniversalParams<T extends ParamDecl[] = [], F = CreateFn<T>> = [
 /**
  * Internal definition of the rule, can be used to reset or patch the rule
  */
-interface RegleInternalRuleDefs<TValue extends any = any, TParams extends any[] = []> {
-    _validator: (value: Maybe<TValue>, ...args: TParams) => boolean | Promise<boolean>;
-    _message: string | ((value: Maybe<TValue>, ...args: TParams) => string);
-    _active?: boolean | ((value: Maybe<TValue>, ...args: TParams) => boolean);
-    _type: string;
+interface RegleInternalRuleDefs<TValue extends any = any, TParams extends any[] = [], TAsync extends boolean = false, TMetadata extends RegleRuleMetadataDefinition = boolean> {
+    _validator: (value: Maybe<TValue>, ...args: TParams) => TAsync extends false ? TMetadata : Promise<TMetadata>;
+    _message: string | ((value: Maybe<TValue>, metadata: RegleRuleMetadataConsumer<TParams, TMetadata>) => string);
+    _active?: boolean | ((value: Maybe<TValue>, metadata: RegleRuleMetadataConsumer<TParams, TMetadata>) => boolean);
+    _type?: string;
     _patched: boolean;
     _params?: RegleUniversalParams<TParams>;
-    _async: boolean;
+    _async: TAsync;
 }
 declare enum InternalRuleType {
     Inline = "__inline",
@@ -81,39 +53,130 @@ declare enum InternalRuleType {
 /**
  * Returned typed of rules created with `createRule`
  * */
-interface RegleRuleDefinition<TValue extends any = any, TParams extends any[] = []> extends RegleInternalRuleDefs<TValue, TParams> {
-    validator: RegleRuleDefinitionProcessor<TValue, TParams, boolean | Promise<boolean>>;
-    message: RegleRuleDefinitionProcessor<TValue, TParams, string>;
-    active: RegleRuleDefinitionProcessor<TValue, TParams, boolean>;
-    type: string;
+interface RegleRuleDefinition<TValue extends any = any, TParams extends any[] = [], TAsync extends boolean = false, TMetaData extends RegleRuleMetadataDefinition = boolean> extends RegleInternalRuleDefs<TValue, TParams, TAsync, TMetaData> {
+    validator: RegleRuleDefinitionProcessor<TValue, TParams, TAsync extends false ? TMetaData : Promise<TMetaData>>;
+    message: RegleRuleDefinitionWithMetadataProcessor<TValue, RegleRuleMetadataConsumer<TParams, TMetaData>, string>;
+    active: RegleRuleDefinitionWithMetadataProcessor<TValue, RegleRuleMetadataConsumer<TParams, TMetaData>, 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>;
+    type?: string;
+    exec: (value: any) => RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>;
 }
 /**
  * Rules with params created with `createRules` are callable while being customizable
  */
-interface RegleRuleWithParamsDefinition<TValue extends any = any, TParams extends any[] = []> extends RegleRuleInit<TValue, TParams>, RegleInternalRuleDefs<TValue, TParams> {
-    (...params: RegleUniversalParams<TParams>): RegleRuleDefinition<TValue, TParams>;
+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>;
 }
+/**
+ * Define a rule Metadata definition
+ */
+type RegleRuleMetadataDefinition = {
+    $valid: boolean;
+    [x: string]: any;
+} | 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'>);
+/**
+ * @internal
+ */
+type $InternalRegleRuleMetadataConsumer = DefaultMetadataProperties & {
+    $params?: any[];
+    [x: string]: any;
+};
 /**
  * Generic types for a created RegleRule
  */
-type RegleRuleRaw<TValue extends any = any, TParams extends any[] = []> = RegleRuleDefinition<TValue, TParams> | RegleRuleWithParamsDefinition<TValue, TParams>;
+type RegleRuleRaw<TValue extends any = any, TParams extends any[] = [], TAsync extends boolean = false, TMetaData extends RegleRuleMetadataDefinition = boolean> = RegleRuleDefinition<TValue, TParams, TAsync, TMetaData> | RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetaData>;
 /**
  * Process the type of a created rule with `createRule`.
  * For a rule with params it will return a function
  * Otherwise it will return the rule definition
  */
-type InferRegleRule<TValue extends any = any, TParams extends any[] = []> = [
-    TParams
-] extends [[]] ? RegleRuleDefinition<TValue, TParams> : RegleRuleWithParamsDefinition<TValue, TParams>;
-type RegleRuleDefinitionProcessor<TValue extends any = any, TParams extends any[] = [], TReturn = any> = (value: Maybe<TValue>, ...args: TParams) => TReturn;
+type InferRegleRule<TValue extends any = any, TParams extends any[] = [], TAsync extends boolean = false, TMetaData extends RegleRuleMetadataDefinition = boolean> = [TParams] extends [[]] ? RegleRuleDefinition<TValue, TParams, TAsync, TMetaData> : RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetaData>;
+type RegleRuleDefinitionProcessor<TValue extends any = any, TParams extends any[] = [], TReturn = any> = (value: Maybe<TValue>, ...params: TParams) => TReturn;
+type RegleRuleDefinitionWithMetadataProcessor<TValue extends any, TMetadata extends RegleRuleMetadataConsumer<any, any>, TReturn = any> = (value: Maybe<TValue>, metadata: TMetadata) => TReturn;
 type RegleCollectionRuleDefinition<TValue = any[], TCustomRules extends Partial<AllRulesDeclarations> = Partial<AllRulesDeclarations>> = (RegleRuleDecl<NonNullable<TValue>, TCustomRules> & {
     $each: RegleFormPropertyType<ArrayElement<TValue>, TCustomRules>;
 }) | {
     $each: RegleFormPropertyType<ArrayElement<TValue>, TCustomRules>;
 };
 
+/**
+ * @argument
+ * createRule arguments options
+ */
+interface RegleRuleInit<TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata extends RegleRuleMetadataDefinition, TAsync extends boolean = TReturn extends Promise<any> ? true : false> {
+    type: {
+        value: TValue;
+        params: TParams;
+    };
+    validator: (value: Maybe<TValue>, ...args: TParams) => TReturn;
+    message: string | ((value: Maybe<TValue>, metadata: RegleRuleMetadataConsumer<TParams, TMetadata>) => string);
+    active?: boolean | ((value: Maybe<TValue>, metadata: RegleRuleMetadataConsumer<TParams, TMetadata>) => boolean);
+}
+/**
+ * @argument
+ * Rule core
+ */
+interface RegleRuleCore<TValue extends any, TParams extends any[] = [], TAsync extends boolean = false, TMetadata extends RegleRuleMetadataDefinition = boolean> {
+    validator: (value: Maybe<TValue>, ...args: TParams) => TAsync extends false ? TMetadata : Promise<TMetadata>;
+    message: string | ((value: Maybe<TValue>, metadata: RegleRuleMetadataConsumer<TParams, TMetadata>) => string);
+    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);
+    active?: boolean | ((value: any, metadata: $InternalRegleRuleMetadataConsumer) => boolean);
+    type?: string;
+}
+
+type DefaultValidators = {
+    maxLength: RegleRuleWithParamsDefinition<string, [count: number]>;
+    required: RegleRuleDefinition<unknown, []>;
+    requiredIf: RegleRuleWithParamsDefinition<unknown, [condition: boolean]>;
+    requiredUnless: RegleRuleWithParamsDefinition<unknown, [condition: boolean]>;
+    alpha: RegleRuleDefinition<string>;
+    alphaNum: RegleRuleDefinition<string | number>;
+    between: RegleRuleWithParamsDefinition<number, [min: number, max: number]>;
+    decimal: RegleRuleDefinition<number | string>;
+    email: RegleRuleDefinition<string>;
+    integer: RegleRuleDefinition<number | string>;
+    maxValue: RegleRuleWithParamsDefinition<number, [count: number]>;
+    minLength: RegleRuleWithParamsDefinition<string | Record<PropertyKey, any> | any[], [
+        count: number
+    ]>;
+    minValue: RegleRuleWithParamsDefinition<number, [count: number]>;
+    numeric: RegleRuleDefinition<number | string>;
+    sameAs: RegleRuleWithParamsDefinition<unknown, [target: unknown]>;
+    url: RegleRuleDefinition<string>;
+    dateAfter: RegleRuleWithParamsDefinition<Date, [after: Date]>;
+    dateBefore: RegleRuleWithParamsDefinition<Date, [before: Date]>;
+    dateBetween: RegleRuleWithParamsDefinition<Date, [before: Date, after: Date]>;
+    ipAddress: RegleRuleDefinition<string, [], false>;
+    macAddress: RegleRuleWithParamsDefinition<string, [separator?: string | undefined], false>;
+};
+
 type CustomRulesDeclarationTree = {
-    [x: string]: RegleRuleRaw<any, any> | undefined;
+    [x: string]: RegleRuleRaw<any, any, boolean, any> | undefined;
 };
 type AllRulesDeclarations = CustomRulesDeclarationTree & DefaultValidators;
 
@@ -170,12 +233,16 @@ type $InternalRegleCollectionRuleDecl = $InternalRegleRuleDecl & {
 /**
  * @public
  */
-type InlineRuleDeclaration<TValue extends any = any> = (value: Maybe<TValue>, ...args: any[]) => boolean | Promise<boolean>;
+type InlineRuleDeclaration<TValue extends any = any, TMetadata extends RegleRuleMetadataDefinition = boolean, TReturn extends TMetadata | Promise<TMetadata> = TMetadata, TAsync extends boolean = TReturn extends Promise<any> ? true : false> = (value: Maybe<TValue>, ...args: any[]) => TReturn;
+/**
+ * @public
+ */
+type InlinePromiseRuleDeclaration<TValue extends any = any, TMetadata extends RegleRuleMetadataDefinition = boolean> = (value: Maybe<TValue>, ...args: any[]) => Promise<TMetadata>;
 /**
  * @public
  * Regroup inline and registered rules
  * */
-type FormRuleDeclaration<TValue extends any, TParams extends any[] = []> = InlineRuleDeclaration<TValue> | RegleRuleDefinition<TValue, TParams>;
+type FormRuleDeclaration<TValue extends any, TParams extends any[] = [], TMetadata extends RegleRuleMetadataDefinition = boolean> = InlineRuleDeclaration<TValue, TMetadata> | RegleRuleDefinition<TValue, TParams, boolean, TMetadata>;
 
 type RegleErrorTree<TRules extends ReglePartialValidationTree<any, any>> = {
     readonly [K in keyof TRules]: RegleValidationErrors<TRules[K]>;
@@ -185,7 +252,21 @@ type RegleCollectionErrors<TRule extends RegleFormPropertyType<any, any> | undef
     readonly $errors: string[];
     readonly $each: RegleValidationErrors<TRule>[];
 };
-type PossibleRegleErrors = RegleCollectionErrors<any> | string[] | RegleErrorTree<any>;
+/**
+ * @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]>;
+};
+type RegleExternalValidationErrors<TValue extends any> = [NonNullable<TValue>] extends [
+    never
+] ? string[] : TValue extends Array<infer U> ? RegleExternalCollectionErrors<U> : NonNullable<TValue> extends Date ? string[] : NonNullable<TValue> extends File ? string[] : TValue extends Record<string, any> ? RegleExternalErrorTree<TValue> : string[];
+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;
 
 /**
@@ -219,6 +300,7 @@ type $InternalRegleStatusType = $InternalRegleCollectionStatus | RegleCommonStat
  */
 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];
+    readonly $externalErrors?: string[];
     readonly $rules: {
         readonly [TRuleKey in keyof TRules]: RegleRuleStatus<TState[TKey], TRules[TRuleKey] extends RegleRuleDefinition<any, infer TParams> ? TParams : []>;
     };
@@ -230,6 +312,7 @@ interface RegleFieldStatus<TRules extends RegleFormPropertyType<any, Partial<All
 interface $InternalRegleFieldStatus extends RegleCommonStatus {
     $value: any;
     $rules: Record<string, $InternalRegleRuleStatus>;
+    $externalErrors?: string[];
 }
 /**
  * @public
@@ -248,6 +331,7 @@ interface RegleCommonStatus<TValue = any> {
     $validate(): Promise<boolean>;
     $unwatch(): void;
     $watch(): void;
+    $clearExternalErrors(): void;
 }
 /**
  * @public
@@ -269,17 +353,18 @@ type RegleRuleStatus<TValue = any, TParams extends any[] = any[]> = {
  * @reference {@link RegleRuleStatus}
  */
 interface $InternalRegleRuleStatus {
-    readonly $type: string;
-    readonly $message: string;
-    readonly $active: boolean;
-    readonly $valid: boolean;
-    readonly $pending: boolean;
-    readonly $path: string;
-    $validator(value: any, ...args: any[]): boolean | Promise<boolean>;
+    $type: string;
+    $message: 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;
-    readonly $params?: any[];
 }
 /**
  * @public
@@ -302,13 +387,247 @@ interface $InternalRegleCollectionStatus extends Omit<$InternalRegleStatus, '$fi
     };
 }
 
+/**
+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 {
+		readonly observable: symbol;
+	}
+}
+
+/**
+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>>;
+
+/**
+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>
+};
+
+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]>
+};
+
 interface Regle<TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, CustomRulesDeclarationTree>> {
-    state: Ref<PartialDeep<TState>>;
+    $state: Ref<PartialDeep<TState>>;
     $regle: RegleStatus<TState, TRules>;
-    errors: RegleErrorTree<TRules>;
+    /** Show active errors based on your behaviour options (lazy, autoDirty)
+     * It allow you to skip scouting the `$regle` object
+     */
+    $errors: RegleErrorTree<TRules>;
+    $valid: ComputedRef<boolean>;
+    $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>> = {
     [K in keyof TState as [SafeProperty<TState[K], TRules[K]>] extends [never] ? K : never]?: [
         SafeProperty<TState[K], TRules[K]>
@@ -335,8 +654,47 @@ interface RegleBehaviourOptions {
      */
     rewardEarly?: boolean;
 }
+interface LocalRegleBehaviourOptions<TState extends Record<string, any>> {
+    $externalErrors?: MaybeRef<RegleExternalErrorTree<TState>>;
+}
+type ResolvedRegleBehaviourOptions = DeepMaybeRef$1<RequiredDeep<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<Record<string, any>>;
 
-declare function createRule<TValue extends any, TParams extends any[] = [], TType extends string = string>(definition: RegleRuleInit<TValue, TParams, TType>): InferRegleRule<TValue, TParams>;
+/**
+ * @description
+ * Create a typed custom rule that can be used like default validators.
+ * It can also be declared in the global options
+ *
+ * It will automatically detect if the rule is async
+ *
+ * @typeParam TValue - The input value the rule should receive
+ * @typeParam TParams - Tuple declaration of the rule parameters (if any)
+ *
+ * @param definition - The rule processors object
+ *
+ * @returns A rule definition that can be callable depending on params presence
+ *
+ * @exemple
+ *
+ * ```ts
+ * // Create a simple rule with no params
+ * import {ruleHelpers} from '@regle/validators';
+ *
+ * export const isFoo = createRule<string>({
+ *   validator(value) {
+ *       if (ruleHelpers.isFilled(value)) {
+ *           return value === 'foo';
+ *       }
+ *       return true
+ *   },
+ *   message: "The value should be 'foo'"
+ * })
+ * ```
+ */
+declare function createRule<TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetaData extends RegleRuleMetadataDefinition = TReturn extends Promise<infer M> ? M : TReturn, TAsync extends boolean = TReturn extends Promise<any> ? true : false>(definition: RegleRuleInit<TValue, TParams, TReturn, TMetaData, TAsync>): InferRegleRule<TValue, TParams, TAsync, TMetaData>;
+declare function defineType<TValue extends any = unknown, TParams extends any[] = []>(ruleName: string): {
+    value: TValue;
+    params: TParams;
+};
 
 /**
  * Returns a clean list of parameters
@@ -344,6 +702,8 @@ declare function createRule<TValue extends any, TParams extends any[] = [], TTyp
  */
 declare function unwrapRuleParameters<TParams extends any[]>(params: ParamDecl[]): TParams;
 
+declare const useRegle: <TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, Partial<AllRulesDeclarations>>>(state: Ref<TState> | DeepReactiveState$1<TState>, rulesFactory: ComputedRef<TRules> | (() => TRules), options?: (Partial<DeepMaybeRef$1<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<TState>) | undefined) => Regle<TState, TRules>;
+
 /**
  * Root function that allows you to define project-wise all your custom validators or overwrite default ones
  *
@@ -351,9 +711,9 @@ declare function unwrapRuleParameters<TParams extends any[]>(params: ParamDecl[]
  *
  * @param customRules
  */
-declare function defineRegleOptions<TCustomRules extends Partial<AllRulesDeclarations>>({ rules, options, }: {
+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>>(state: vue.Ref<TState>, rulesFactory: vue.ComputedRef<TRules> | (() => TRules), options?: Partial<DeepMaybeRef<Required<RegleBehaviourOptions>>> | undefined) => Regle<TState, TRules>;
+}): <TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, Partial<AllRulesDeclarations> & TCustomRules>>(state: vue.Ref<TState> | DeepReactiveState<TState>, rulesFactory: vue.ComputedRef<TRules> | (() => TRules), options?: (Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<TState>) | undefined) => Regle<TState, TRules>;
 
-export { $InternalFormPropertyTypes, $InternalRegleCollectionRuleDecl, $InternalRegleCollectionStatus, $InternalRegleFieldStatus, $InternalReglePartialValidationTree, $InternalRegleRuleDecl, $InternalRegleRuleStatus, $InternalRegleStatus, $InternalRegleStatusType, AllRulesDeclarations, ArrayElement, CustomRulesDeclarationTree, DataType, DeepMaybeRef, ExcludeFromTuple, FormRuleDeclaration, InferRegleRule, InferRegleStatusType, InlineRuleDeclaration, InternalRuleType, Maybe, MaybeNull, ParamDecl, PossibleRegleErrors, Regle, RegleBehaviourOptions, RegleCollectionErrors, RegleCollectionRuleDecl, RegleCollectionRuleDefinition, RegleCollectionStatus, RegleCommonStatus, RegleErrorTree, RegleFieldStatus, RegleFormPropertyType, RegleInternalRuleDefs, ReglePartialValidationTree, RegleRuleDecl, RegleRuleDefinition, RegleRuleDefinitionProcessor, RegleRuleInit, RegleRuleRaw, RegleRuleStatus, RegleRuleWithParamsDefinition, RegleStatus, RegleUniversalParams, RegleValidationErrors, UnrefTuple, UnwrapRegleUniversalParams, createRule, defineRegleOptions, unwrapRuleParameters };
+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 AllRulesDeclarations, type ArrayElement, type CustomRulesDeclarationTree, type DataType, type DeepMaybeRef, type ExcludeByType, type ExcludeFromTuple, type FormRuleDeclaration, type InferRegleRule, type InferRegleStatusType, type InlinePromiseRuleDeclaration, type InlineRuleDeclaration, InternalRuleType, type LocalRegleBehaviourOptions, type Maybe, type MaybeNull, type ParamDecl, 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 ResolvedRegleBehaviourOptions, type UnrefTuple, type UnwrapRegleUniversalParams, createRule, defineRegleConfig, defineType, unwrapRuleParameters, useRegle };