@regle/core 0.0.6 → 0.0.7

package/dist/index.cjs

@@ -22,8 +22,10 @@ var src_exports = {};
 __export(src_exports, {
   InternalRuleType: () => InternalRuleType,
   createRule: () => createRule,
-  defineRegleOptions: () => defineRegleOptions,
-  unwrapRuleParameters: () => unwrapRuleParameters
+  defineRegleConfig: () => defineRegleConfig,
+  defineType: () => defineType,
+  unwrapRuleParameters: () => unwrapRuleParameters,
+  useRegle: () => useRegle
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -47,29 +49,47 @@ function createReactiveParams(params) {
     return (0, import_vue.toRef)(() => param);
   });
 }
+function getFunctionParametersLength(func) {
+  const funcStr = func.toString();
+  const params = funcStr.slice(funcStr.indexOf("(") + 1, funcStr.indexOf(")")).split(",").map((param) => param.trim());
+  const defaults = params.filter((param) => param.includes("="));
+  return defaults.length + func.length;
+}
 
 // src/core/createRule/defineRuleProcessors.ts
 function defineRuleProcessors(definition, ...params) {
   const { message, validator, active, ...properties } = definition;
   const isAsync = validator.constructor.name === "AsyncFunction";
-  const processors = {
-    message(value, ...args) {
+  const defaultProcessors = {
+    validator(value, ...args) {
+      return definition.validator(value, ...unwrapRuleParameters(args.length ? args : params));
+    },
+    message(value, metadata) {
       if (typeof definition.message === "function") {
-        return definition.message(value, ...args.length ? args : params);
+        return definition.message(value, {
+          ...metadata,
+          $params: unwrapRuleParameters(metadata.$params?.length ? metadata.$params : params)
+        });
       } else {
         return definition.message;
       }
     },
-    validator(value, ...args) {
-      return definition.validator(value, ...args.length ? args : params);
-    },
-    active(value, ...args) {
+    active(value, metadata) {
       if (typeof definition.active === "function") {
-        return definition.active(value, ...args.length ? args : params);
+        return definition.active(value, {
+          ...metadata,
+          $params: unwrapRuleParameters(metadata.$params?.length ? metadata.$params : params)
+        });
       } else {
         return definition.active ?? true;
       }
     },
+    exec(value) {
+      return definition.validator(value, ...unwrapRuleParameters(params));
+    }
+  };
+  const processors = {
+    ...defaultProcessors,
     ...properties,
     ...{
       _validator: definition.validator,
@@ -90,7 +110,7 @@ function createRule(definition) {
     let fakeParams = [];
     const staticProcessors = defineRuleProcessors(definition, ...fakeParams);
     const isAsync = definition.validator.constructor.name === "AsyncFunction";
-    if (definition.validator.length > 1) {
+    if (getFunctionParametersLength(definition.validator) > 1) {
       const ruleFactory = function(...params) {
         return defineRuleProcessors(definition, ...params);
       };
@@ -98,9 +118,10 @@ function createRule(definition) {
       ruleFactory.message = staticProcessors.message;
       ruleFactory.active = staticProcessors.active;
       ruleFactory.type = staticProcessors.type;
-      ruleFactory._validator = definition.validator;
-      ruleFactory._message = definition.message;
-      ruleFactory._active = definition.active;
+      ruleFactory.exec = staticProcessors.exec;
+      ruleFactory._validator = staticProcessors.validator;
+      ruleFactory._message = staticProcessors.message;
+      ruleFactory._active = staticProcessors.active;
       ruleFactory._type = definition.type;
       ruleFactory._patched = false;
       ruleFactory._async = isAsync;
@@ -111,6 +132,9 @@ function createRule(definition) {
   }
   throw new Error("Validator must be a function");
 }
+function defineType(ruleName) {
+  return ruleName;
+}
 
 // src/core/useRegle/useRegle.ts
 var import_vue10 = require("vue");
@@ -208,10 +232,19 @@ function useStorage() {
     } else {
       const $pending = (0, import_vue2.ref)(false);
       const $valid = (0, import_vue2.ref)(true);
-      ruleStatusStorage.value.set(path, { $pending, $valid });
-      return { $pending, $valid };
+      const $metadata = (0, import_vue2.ref)({});
+      ruleStatusStorage.value.set(path, { $pending, $valid, $metadata });
+      return { $pending, $valid, $metadata };
     }
   }
+  (0, import_vue2.onScopeDispose)(() => {
+    ruleDeclStorage.value.clear();
+    fieldsStorage.value.clear();
+    collectionsStorage.value.clear();
+    dirtyStorage.value.clear();
+    ruleStatusStorage.value.clear();
+    arrayStatusStorage.value.clear();
+  });
   return {
     addRuleDeclEntry,
     setDirtyEntry,
@@ -394,13 +427,18 @@ function createReactiveRuleStatus({
 }) {
   let scope = (0, import_vue5.effectScope)();
   let scopeState;
-  const { $pending, $valid } = storage.trySetRuleStatusRef(`${path}.${ruleKey}`);
+  const { $pending, $valid, $metadata } = storage.trySetRuleStatusRef(`${path}.${ruleKey}`);
   function $watch() {
     scopeState = scope.run(() => {
+      const $defaultMetadata = (0, import_vue5.computed)(() => ({
+        $invalid: !$valid.value,
+        $params: $params.value,
+        ...$metadata.value
+      }));
       const $active = (0, import_vue5.computed)(() => {
         if (isFormRuleDefinition(rule)) {
           if (typeof rule.value.active === "function") {
-            return rule.value.active(state.value, ...$params.value);
+            return rule.value.active(state.value, $defaultMetadata.value);
           } else {
             return rule.value.active;
           }
@@ -413,7 +451,7 @@ function createReactiveRuleStatus({
         const customMessageRule = customMessages ? customMessages[ruleKey]?.message : void 0;
         if (customMessageRule) {
           if (typeof customMessageRule === "function") {
-            message = customMessageRule(state.value, ...$params.value);
+            message = customMessageRule(state.value, $defaultMetadata.value);
           } else {
             message = customMessageRule;
           }
@@ -421,7 +459,7 @@ function createReactiveRuleStatus({
         if (isFormRuleDefinition(rule)) {
           if (!(customMessageRule && !rule.value._patched)) {
             if (typeof rule.value.message === "function") {
-              message = rule.value.message(state.value, ...$params.value);
+              message = rule.value.message(state.value, $defaultMetadata.value);
             } else {
               message = rule.value.message;
             }
@@ -434,7 +472,7 @@ function createReactiveRuleStatus({
         return message;
       });
       const $type = (0, import_vue5.computed)(() => {
-        if (isFormRuleDefinition(rule)) {
+        if (isFormRuleDefinition(rule) && rule.value.type) {
           return Object.values(InternalRuleType).includes(rule.value.type) ? ruleKey : rule.value.type;
         } else {
           return ruleKey;
@@ -478,7 +516,13 @@ function createReactiveRuleStatus({
           $valid.value = true;
           $pending.value = true;
           const promiseResult = await resultOrPromise;
-          ruleResult = promiseResult;
+          if (typeof promiseResult === "boolean") {
+            ruleResult = promiseResult;
+          } else {
+            const { $valid: $valid2, ...rest } = promiseResult;
+            ruleResult = $valid2;
+            $metadata.value = rest;
+          }
         } catch (e) {
           ruleResult = false;
         } finally {
@@ -486,7 +530,15 @@ function createReactiveRuleStatus({
         }
       }
     } else {
-      ruleResult = resultOrPromise;
+      if (resultOrPromise != null) {
+        if (typeof resultOrPromise === "boolean") {
+          ruleResult = resultOrPromise;
+        } else {
+          const { $valid: $valid2, ...rest } = resultOrPromise;
+          ruleResult = $valid2;
+          $metadata.value = rest;
+        }
+      }
     }
     $valid.value = ruleResult;
     if (options.$externalErrors) {
@@ -577,7 +629,6 @@ function createReactiveFieldStatus({
       $commit();
     }
     $externalErrors.value = [];
-    console.log($externalErrors.value);
   });
   function $unwatch() {
     if ($rules.value) {
@@ -711,7 +762,7 @@ function createCollectionElement({
     });
   }
   const $state = (0, import_vue7.toRefs)(value);
-  const $externalErrors = (0, import_vue7.toRefs)(externalErrors.value ?? (0, import_vue7.reactive)([void 0]));
+  const $externalErrors = (0, import_vue7.toRef)(() => externalErrors.value?.[index]);
   const $status = createReactiveChildrenStatus({
     state: $state[index],
     rulesDef: (0, import_vue7.toRef)(() => rules),
@@ -719,7 +770,7 @@ function createCollectionElement({
     path: $path,
     storage,
     options,
-    externalErrors: $externalErrors?.[index]
+    externalErrors: $externalErrors
   });
   if ($status) {
     $status.$id = value[index].$id ?? $id;
@@ -1151,8 +1202,8 @@ function createUseRegleComposable(customRules, options) {
 }
 var useRegle = createUseRegleComposable();
 
-// src/core/defineRegleOptions.ts
-function defineRegleOptions({
+// src/core/defineRegleConfig.ts
+function defineRegleConfig({
   rules,
   options
 }) {
@@ -1163,6 +1214,8 @@ function defineRegleOptions({
 0 && (module.exports = {
   InternalRuleType,
   createRule,
-  defineRegleOptions,
-  unwrapRuleParameters
+  defineRegleConfig,
+  defineType,
+  unwrapRuleParameters,
+  useRegle
 });

package/dist/index.d.cts

@@ -1,6 +1,7 @@
 import * as vue from 'vue';
 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]>;
@@ -294,11 +361,10 @@ interface $InternalRegleRuleStatus {
     $path: string;
     $externalErrors?: string[];
     $params?: any[];
-    $validator(value: any, ...args: any[]): boolean | Promise<boolean>;
+    $validator(value: any, ...args: any[]): RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>;
     $validate(): Promise<boolean>;
     $unwatch(): void;
     $watch(): void;
-    $clearExternalErrors(): void;
 }
 /**
  * @public
@@ -343,9 +409,9 @@ declare global {
 }
 
 /**
-Matches any primitive, `Date`, or `RegExp` value.
+Matches any primitive, `void`, `Date`, or `RegExp` value.
 */
-type BuiltIns = Primitive | Date | RegExp;
+type BuiltIns = Primitive | void | Date | RegExp;
 
 /**
 Test if the given function has multiple call signatures.
@@ -421,7 +487,7 @@ const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
 @category Set
 @category Map
 */
-type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends BuiltIns
+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>
@@ -431,19 +497,17 @@ type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends BuiltIn
 				? PartialReadonlyMapDeep<KeyType, ValueType, Options>
 				: T extends ReadonlySet<infer ItemType>
 					? PartialReadonlySetDeep<ItemType, Options>
-					: T extends ((...arguments_: any[]) => unknown)
-						? T | undefined
-						: 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;
+					: 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`.
@@ -595,7 +659,42 @@ interface LocalRegleBehaviourOptions<TState extends Record<string, any>> {
 }
 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
@@ -603,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
  *
@@ -610,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> | DeepReactiveState<TState>, rulesFactory: vue.ComputedRef<TRules> | (() => TRules), options?: (Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<TState>) | undefined) => Regle<TState, TRules>;
 
-export { $InternalExternalRegleErrors, $InternalFormPropertyTypes, $InternalRegleCollectionRuleDecl, $InternalRegleCollectionStatus, $InternalRegleErrors, $InternalRegleFieldStatus, $InternalReglePartialValidationTree, $InternalRegleRuleDecl, $InternalRegleRuleStatus, $InternalRegleStatus, $InternalRegleStatusType, AllRulesDeclarations, ArrayElement, CustomRulesDeclarationTree, DataType, DeepMaybeRef, ExcludeFromTuple, FormRuleDeclaration, InferRegleRule, InferRegleStatusType, InlineRuleDeclaration, InternalRuleType, LocalRegleBehaviourOptions, Maybe, MaybeNull, ParamDecl, Regle, RegleBehaviourOptions, RegleCollectionErrors, RegleCollectionRuleDecl, RegleCollectionRuleDefinition, RegleCollectionStatus, RegleCommonStatus, RegleErrorTree, RegleExternalCollectionErrors, RegleExternalErrorTree, RegleExternalValidationErrors, RegleFieldStatus, RegleFormPropertyType, RegleInternalRuleDefs, ReglePartialValidationTree, RegleRuleDecl, RegleRuleDefinition, RegleRuleDefinitionProcessor, RegleRuleInit, RegleRuleRaw, RegleRuleStatus, RegleRuleWithParamsDefinition, RegleStatus, RegleUniversalParams, RegleValidationErrors, ResolvedRegleBehaviourOptions, 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 };