@regle/core 0.6.1 → 0.7.1-beta.1

package/dist/regle-core.cjs

@@ -4,7 +4,7 @@ var vue = require('vue');
 
 // ../shared/utils/isEmpty.ts
 function isEmpty(value) {
-  if (value === void 0 || value === null) {
+  if (value === undefined || value === null) {
     return true;
   }
   if (value instanceof Date) {
@@ -310,7 +310,7 @@ function useStorage() {
   }
   function checkRuleDeclEntry($path, newRules) {
     const storedRulesDefs = ruleDeclStorage.value.get($path);
-    if (!storedRulesDefs) return void 0;
+    if (!storedRulesDefs) return undefined;
     const storedRules = storedRulesDefs;
     const isValidCache = areRulesChanged(newRules, storedRules);
     if (!isValidCache) return { valid: false };
@@ -405,7 +405,7 @@ function debounce(func, wait, immediate) {
   const debouncedFn = (...args) => new Promise((resolve) => {
     clearTimeout(timeout);
     timeout = setTimeout(() => {
-      timeout = void 0;
+      timeout = undefined;
       {
         Promise.resolve(func.apply(this, [...args])).then(resolve);
       }
@@ -413,7 +413,7 @@ function debounce(func, wait, immediate) {
   });
   debouncedFn.cancel = () => {
     clearTimeout(timeout);
-    timeout = void 0;
+    timeout = undefined;
   };
   return debouncedFn;
 }
@@ -475,10 +475,10 @@ function extractRulesErrors({
   field,
   silent = false
 }) {
-  return Object.entries(field.$rules ?? {}).map(([ruleKey, rule]) => {
+  return Object.entries(field.$rules ?? {}).map(([_, rule]) => {
     if (silent) {
       return rule.$message;
-    } else if (!rule.$valid && field.$dirty && !rule.$validating) {
+    } else if (!rule.$valid && field.$error && !rule.$validating) {
       return rule.$message;
     }
     return null;
@@ -488,10 +488,10 @@ function extractRulesErrors({
     } else {
       return acc?.concat(value);
     }
-  }, []).concat(field.$dirty ? field.$externalErrors ?? [] : []);
+  }, []).concat(field.$error ? field.$externalErrors ?? [] : []).concat(field.$error ? field.$schemaErrors ?? [] : []);
 }
 function extractRulesTooltips({ field }) {
-  return Object.entries(field.$rules ?? {}).map(([ruleKey, rule]) => rule.$tooltip).filter((tooltip) => !!tooltip).reduce((acc, value) => {
+  return Object.entries(field.$rules ?? {}).map(([_, rule]) => rule.$tooltip).filter((tooltip) => !!tooltip).reduce((acc, value) => {
     if (typeof value === "string") {
       return acc?.concat([value]);
     } else {
@@ -546,7 +546,7 @@ function createReactiveRuleStatus({
       });
       function computeRuleProcessor(key) {
         let result = "";
-        const customProcessor = customMessages ? customMessages[ruleKey]?.[key] : void 0;
+        const customProcessor = customMessages ? customMessages[ruleKey]?.[key] : undefined;
         if (customProcessor) {
           if (typeof customProcessor === "function") {
             result = customProcessor($defaultMetadata.value);
@@ -720,6 +720,8 @@ function createReactiveFieldStatus({
   storage,
   options,
   externalErrors,
+  schemaErrors,
+  schemaMode,
   onUnwatch,
   $isArray,
   initialState,
@@ -812,7 +814,7 @@ function createReactiveFieldStatus({
     }
     scopeState = scope.run(() => {
       const $dirty = vue.ref(false);
-      const triggerPunishment = vue.ref(false);
+      const triggerPunishment2 = vue.ref(false);
       const $anyDirty = vue.computed(() => $dirty.value);
       const $debounce2 = vue.computed(() => {
         return $localOptions.value.$debounce;
@@ -868,16 +870,25 @@ function createReactiveFieldStatus({
         return $invalid.value && !$pending.value && $dirty.value;
       });
       const $errors = vue.computed(() => {
-        if ($error.value) {
-          return extractRulesErrors({
-            field: {
-              $dirty: $dirty.value,
-              $externalErrors: externalErrors?.value,
-              $rules: $rules.value
-            }
-          });
-        }
-        return [];
+        return extractRulesErrors({
+          field: {
+            $error: $error.value,
+            $externalErrors: externalErrors?.value,
+            $schemaErrors: schemaErrors?.value,
+            $rules: $rules.value
+          }
+        });
+      });
+      const $silentErrors = vue.computed(() => {
+        return extractRulesErrors({
+          field: {
+            $error: true,
+            $externalErrors: externalErrors?.value,
+            $schemaErrors: schemaErrors?.value,
+            $rules: $rules.value
+          },
+          silent: true
+        });
       });
       const $edited = vue.computed(() => {
         if ($dirty.value) {
@@ -902,16 +913,6 @@ function createReactiveFieldStatus({
           }
         });
       });
-      const $silentErrors = vue.computed(() => {
-        return extractRulesErrors({
-          field: {
-            $dirty: $dirty.value,
-            $externalErrors: externalErrors?.value,
-            $rules: $rules.value
-          },
-          silent: true
-        });
-      });
       const $ready = vue.computed(() => {
         if (!$autoDirty2.value) {
           return !($invalid.value || $pending.value);
@@ -919,7 +920,7 @@ function createReactiveFieldStatus({
         return $anyDirty.value && !($invalid.value || $pending.value);
       });
       const $pending = vue.computed(() => {
-        if (triggerPunishment.value || !$rewardEarly2.value) {
+        if (triggerPunishment2.value || !$rewardEarly2.value) {
           return Object.entries($rules.value).some(([key, ruleResult]) => {
             return ruleResult.$pending;
           });
@@ -927,11 +928,11 @@ function createReactiveFieldStatus({
         return false;
       });
       const $invalid = vue.computed(() => {
-        if (externalErrors?.value?.length) {
+        if (externalErrors?.value?.length || schemaErrors?.value?.length) {
           return true;
-        } else if (isEmpty($rules.value)) {
+        } else if ($inactive.value) {
           return false;
-        } else if (!$rewardEarly2.value || $rewardEarly2.value && triggerPunishment.value) {
+        } else if (!$rewardEarly2.value || $rewardEarly2.value && triggerPunishment2.value) {
           return Object.entries($rules.value).some(([_, ruleResult]) => {
             return !ruleResult.$valid;
           });
@@ -940,7 +941,7 @@ function createReactiveFieldStatus({
       });
       const $name = vue.computed(() => fieldName);
       const $inactive = vue.computed(() => {
-        if (isEmpty($rules.value)) {
+        if (isEmpty($rules.value) && !schemaMode) {
           return true;
         }
         return false;
@@ -951,9 +952,13 @@ function createReactiveFieldStatus({
         } else if ($inactive.value) {
           return false;
         } else if ($dirty.value && !isEmpty(state.value) && !$validating2.value) {
-          return Object.values($rules.value).every((ruleResult) => {
-            return ruleResult.$valid && ruleResult.$active;
-          });
+          if (schemaMode) {
+            return !schemaErrors?.value?.length;
+          } else {
+            return Object.values($rules.value).every((ruleResult) => {
+              return ruleResult.$valid && ruleResult.$active;
+            });
+          }
         }
         return false;
       });
@@ -1001,7 +1006,7 @@ function createReactiveFieldStatus({
       const $shortcuts2 = {};
       vue.watch($invalid, (value) => {
         if (!value) {
-          triggerPunishment.value = false;
+          triggerPunishment2.value = false;
         }
       });
       return {
@@ -1026,7 +1031,7 @@ function createReactiveFieldStatus({
         $validating: $validating2,
         $tooltips,
         $dirty,
-        triggerPunishment,
+        triggerPunishment: triggerPunishment2,
         processShortcuts,
         $silentValue,
         $inactive
@@ -1109,7 +1114,9 @@ function createReactiveFieldStatus({
       } else if (scopeState.$autoDirty.value && scopeState.$dirty.value && !scopeState.$pending.value) {
         return { result: !scopeState.$error.value, data };
       }
-      if (isEmpty($rules.value)) {
+      if (schemaMode) {
+        return { result: !schemaErrors?.value?.length, data };
+      } else if (isEmpty($rules.value)) {
         return { result: true, data };
       }
       const results = await Promise.allSettled(
@@ -1160,6 +1167,7 @@ function createReactiveFieldStatus({
     $haveAnyAsyncRule,
     $debounce,
     $lazy,
+    triggerPunishment,
     ...restScope
   } = scopeState;
   return vue.reactive({
@@ -1188,9 +1196,11 @@ function createCollectionElement({
   customMessages,
   rules,
   externalErrors,
+  schemaErrors,
   initialState,
   shortcuts,
-  fieldName
+  fieldName,
+  schemaMode
 }) {
   const $fieldId = rules.$key ? rules.$key : randomId();
   let $path = `${path}.${String($fieldId)}`;
@@ -1208,6 +1218,8 @@ function createCollectionElement({
       $path = `${path}.${stateValue.value.$id}`;
     }
   }
+  const $externalErrors = vue.toRef(externalErrors?.value ?? [], index);
+  const $schemaErrors = vue.computed(() => schemaErrors?.value?.[index]);
   const $status = createReactiveChildrenStatus({
     state: stateValue,
     rulesDef: vue.toRef(() => rules),
@@ -1215,10 +1227,12 @@ function createCollectionElement({
     path: $path,
     storage,
     options,
-    externalErrors: vue.toRef(externalErrors?.value ?? [], index),
+    externalErrors: $externalErrors,
+    schemaErrors: $schemaErrors,
     initialState,
     shortcuts,
-    fieldName
+    fieldName,
+    schemaMode
   });
   if ($status) {
     const valueId = stateValue.value?.$id;
@@ -1237,6 +1251,8 @@ function createReactiveCollectionStatus({
   storage,
   options,
   externalErrors,
+  schemaErrors,
+  schemaMode,
   initialState,
   shortcuts,
   fieldName
@@ -1247,7 +1263,7 @@ function createReactiveCollectionStatus({
   let immediateScopeState;
   let collectionScopes = [];
   if (!Array.isArray(state.value) && !rulesDef.value.$each) {
-    return void 0;
+    return undefined;
   }
   const $id = vue.ref();
   const $value = vue.ref(state.value);
@@ -1300,6 +1316,8 @@ function createReactiveCollectionStatus({
           collectionScopes.push(scope2);
         }
         const initialStateRef = vue.toRef(initialState.value ?? [], index);
+        const $externalErrors = vue.toRef(externalErrors?.value ?? {}, `$each`);
+        const $schemaErrors = vue.computed(() => schemaErrors?.value?.$each);
         const element = createCollectionElement({
           $id: $id.value,
           path,
@@ -1309,10 +1327,12 @@ function createReactiveCollectionStatus({
           index,
           options,
           storage,
-          externalErrors: vue.toRef(externalErrors?.value ?? {}, `$each`),
+          externalErrors: $externalErrors,
+          schemaErrors: $schemaErrors,
           initialState: initialStateRef,
           shortcuts,
-          fieldName
+          fieldName,
+          schemaMode
         });
         if (element) {
           return element;
@@ -1330,10 +1350,12 @@ function createReactiveCollectionStatus({
       storage,
       options,
       externalErrors: vue.toRef(externalErrors?.value ?? {}, `$self`),
+      schemaErrors: vue.computed(() => schemaErrors?.value?.$self),
       $isArray: true,
       initialState,
       shortcuts,
-      fieldName
+      fieldName,
+      schemaMode
     });
   }
   function updateStatus() {
@@ -1353,26 +1375,28 @@ function createReactiveCollectionStatus({
           if (scope2) {
             collectionScopes.push(scope2);
           }
-          if (unwrapped) {
-            const element = createCollectionElement({
-              $id: $id.value,
-              path,
-              customMessages,
-              rules: unwrapped,
-              stateValue: currentValue,
-              index,
-              options,
-              storage,
-              externalErrors: vue.toRef(externalErrors?.value ?? {}, `$each`),
-              initialState: vue.toRef(initialState.value ?? [], index),
-              shortcuts,
-              fieldName
-            });
-            if (element) {
-              return element;
-            }
-            return null;
+          const $externalErrors = vue.toRef(externalErrors?.value ?? {}, `$each`);
+          const $schemaErrors = vue.computed(() => schemaErrors?.value?.$each ?? []);
+          const element = createCollectionElement({
+            $id: $id.value,
+            path,
+            customMessages,
+            rules: unwrapped ?? {},
+            stateValue: currentValue,
+            index,
+            options,
+            storage,
+            externalErrors: $externalErrors,
+            schemaErrors: $schemaErrors,
+            initialState: vue.toRef(initialState.value ?? [], index),
+            shortcuts,
+            fieldName,
+            schemaMode
+          });
+          if (element) {
+            return element;
           }
+          return null;
         }
       }).filter((each) => !!each);
       previousStatus.filter(($each) => !state.value?.find((f) => $each.$id === f.$id)).forEach((_, index) => {
@@ -1628,6 +1652,8 @@ function createReactiveNestedStatus({
   path = "",
   rootRules,
   externalErrors,
+  schemaErrors,
+  rootSchemaErrors,
   validationGroups,
   initialState,
   fieldName,
@@ -1637,6 +1663,7 @@ function createReactiveNestedStatus({
   let scopeState;
   let nestedScopes = [];
   let $unwatchRules = null;
+  let $unwatchSchemaErrors = null;
   let $unwatchExternalErrors = null;
   let $unwatchState = null;
   async function createReactiveFieldsStatus(watchSources = true) {
@@ -1647,6 +1674,7 @@ function createReactiveNestedStatus({
           const stateRef = vue.toRef(state.value ?? {}, statePropKey);
           const statePropRulesRef = vue.toRef(() => statePropRules);
           const $externalErrors = vue.toRef(externalErrors?.value ?? {}, statePropKey);
+          const $schemaErrors = vue.computed(() => schemaErrors?.value?.[statePropKey]);
           const initialStateRef = vue.toRef(initialState?.value ?? {}, statePropKey);
           return [
             statePropKey,
@@ -1655,6 +1683,7 @@ function createReactiveNestedStatus({
               rulesDef: statePropRulesRef,
               path: path ? `${path}.${statePropKey}` : statePropKey,
               externalErrors: $externalErrors,
+              schemaErrors: $schemaErrors,
               initialState: initialStateRef,
               fieldName: statePropKey,
               ...commonArgs
@@ -1667,6 +1696,8 @@ function createReactiveNestedStatus({
     const externalRulesStatus = Object.fromEntries(
       Object.entries(vue.unref(externalErrors) ?? {}).filter(([key, errors]) => !(key in rulesDef.value) && !!errors).map(([key]) => {
         const stateRef = vue.toRef(state.value ?? {}, key);
+        const $externalErrors = vue.toRef(externalErrors?.value ?? {}, key);
+        const $schemaErrors = vue.computed(() => schemaErrors?.value?.[key]);
         const initialStateRef = vue.toRef(initialState?.value ?? {}, key);
         return [
           key,
@@ -1674,7 +1705,29 @@ function createReactiveNestedStatus({
             state: stateRef,
             rulesDef: vue.computed(() => ({})),
             path: path ? `${path}.${key}` : key,
-            externalErrors: vue.toRef(externalErrors?.value ?? {}, key),
+            externalErrors: $externalErrors,
+            schemaErrors: $schemaErrors,
+            initialState: initialStateRef,
+            fieldName: key,
+            ...commonArgs
+          })
+        ];
+      })
+    );
+    const schemasRulesStatus = Object.fromEntries(
+      Object.entries(vue.unref(schemaErrors) ?? {}).map(([key]) => {
+        const stateRef = vue.toRef(state.value ?? {}, key);
+        const $externalErrors = vue.toRef(externalErrors?.value ?? {}, key);
+        const $schemaErrors = vue.computed(() => schemaErrors?.value?.[key]);
+        const initialStateRef = vue.toRef(initialState?.value ?? {}, key);
+        return [
+          key,
+          createReactiveChildrenStatus({
+            state: stateRef,
+            rulesDef: vue.computed(() => ({})),
+            path: path ? `${path}.${key}` : key,
+            externalErrors: $externalErrors,
+            schemaErrors: $schemaErrors,
             initialState: initialStateRef,
             fieldName: key,
             ...commonArgs
@@ -1683,8 +1736,12 @@ function createReactiveNestedStatus({
       })
     );
     const statesWithNoRules = Object.fromEntries(
-      Object.entries(state.value ?? {}).filter(([key]) => !(key in rulesDef.value) && !(key in (externalRulesStatus.value ?? {}))).map(([key]) => {
+      Object.entries(state.value ?? {}).filter(
+        ([key]) => !(key in rulesDef.value) && !(key in (externalRulesStatus ?? {})) && !(key in (schemasRulesStatus ?? {}))
+      ).map(([key]) => {
         const stateRef = vue.toRef(state.value ?? {}, key);
+        const $externalErrors = vue.toRef(externalErrors?.value ?? {}, key);
+        const $schemaErrors = vue.computed(() => schemaErrors?.value?.[key]);
         const initialStateRef = vue.toRef(initialState?.value ?? {}, key);
         return [
           key,
@@ -1692,7 +1749,8 @@ function createReactiveNestedStatus({
             state: stateRef,
             rulesDef: vue.computed(() => ({})),
             path: path ? `${path}.${key}` : key,
-            externalErrors: vue.toRef(externalErrors?.value ?? {}, key),
+            externalErrors: $externalErrors,
+            schemaErrors: $schemaErrors,
             initialState: initialStateRef,
             fieldName: key,
             ...commonArgs
@@ -1703,6 +1761,7 @@ function createReactiveNestedStatus({
     $fields.value = {
       ...scopedRulesStatus,
       ...externalRulesStatus,
+      ...schemasRulesStatus,
       ...statesWithNoRules
     };
     if (watchSources) {
@@ -1725,7 +1784,7 @@ function createReactiveNestedStatus({
     });
   }
   function define$WatchExternalErrors() {
-    if (externalErrors?.value) {
+    if (externalErrors) {
       $unwatchExternalErrors = vue.watch(
         externalErrors,
         () => {
@@ -1760,6 +1819,17 @@ function createReactiveNestedStatus({
       );
       define$WatchExternalErrors();
     }
+    if (rootSchemaErrors) {
+      $unwatchSchemaErrors?.();
+      $unwatchSchemaErrors = vue.watch(
+        rootSchemaErrors,
+        () => {
+          $unwatch();
+          createReactiveFieldsStatus();
+        },
+        { deep: true, flush: "post" }
+      );
+    }
     define$watchState();
     scope = vue.effectScope();
     scopeState = scope.run(() => {
@@ -1821,8 +1891,9 @@ function createReactiveNestedStatus({
         }
         return $anyDirty.value && !($invalid.value || $pending.value);
       });
+      const $localPending2 = vue.ref(false);
       const $pending = vue.computed(() => {
-        return Object.entries($fields.value).some(([key, statusOrField]) => {
+        return $localPending2.value || Object.entries($fields.value).some(([key, statusOrField]) => {
           return statusOrField?.$pending;
         });
       });
@@ -1934,7 +2005,8 @@ function createReactiveNestedStatus({
         $groups,
         $silentValue,
         $edited,
-        $anyEdited
+        $anyEdited,
+        $localPending: $localPending2
       };
     });
   }
@@ -1984,25 +2056,37 @@ function createReactiveNestedStatus({
   }
   async function $validate() {
     try {
-      const data = state.value;
-      const results = await Promise.allSettled(
-        Object.values($fields.value).map((statusOrField) => {
-          return statusOrField.$validate();
-        })
-      );
-      const validationResults = results.every((value) => {
-        if (value.status === "fulfilled") {
-          return value.value.result === true;
+      if (commonArgs.schemaMode) {
+        if (commonArgs.onValidate) {
+          $touch(false);
+          scopeState.$localPending.value = true;
+          return commonArgs.onValidate();
         } else {
-          return false;
+          return { result: false, data: state.value };
         }
-      });
-      return { result: validationResults, data };
+      } else {
+        const data = state.value;
+        const results = await Promise.allSettled(
+          Object.values($fields.value).map((statusOrField) => {
+            return statusOrField.$validate();
+          })
+        );
+        const validationResults = results.every((value) => {
+          if (value.status === "fulfilled") {
+            return value.value.result === true;
+          } else {
+            return false;
+          }
+        });
+        return { result: validationResults, data };
+      }
     } catch (e) {
       return { result: false, data: state.value };
+    } finally {
+      scopeState.$localPending.value = false;
     }
   }
-  const { $shortcuts, ...restScopeState } = scopeState;
+  const { $shortcuts, $localPending, ...restScopeState } = scopeState;
   return vue.reactive({
     ...restScopeState,
     ...$shortcuts,
@@ -2020,20 +2104,17 @@ function createReactiveNestedStatus({
 }
 function createReactiveChildrenStatus({
   rulesDef,
-  externalErrors,
   ...properties
 }) {
   if (isCollectionRulesDef(rulesDef, properties.state)) {
     return createReactiveCollectionStatus({
       rulesDef,
-      externalErrors,
       ...properties
     });
   } else if (isNestedRulesDef(properties.state, rulesDef)) {
     if (isRefObject(properties.state)) {
       return createReactiveNestedStatus({
         rulesDef,
-        externalErrors,
         ...properties
       });
     } else {
@@ -2059,7 +2140,6 @@ function createReactiveChildrenStatus({
       const { state, ...restProperties } = properties;
       return createReactiveNestedStatus({
         rulesDef,
-        externalErrors,
         ...restProperties,
         state: scopeState.fakeState
       });
@@ -2067,11 +2147,10 @@ function createReactiveChildrenStatus({
   } else if (isValidatorRulesDef(rulesDef)) {
     return createReactiveFieldStatus({
       rulesDef,
-      externalErrors,
       ...properties
     });
   }
-  return void 0;
+  return undefined;
 }
 
 // src/core/useRegle/root/useRootStorage.ts
@@ -2081,7 +2160,10 @@ function useRootStorage({
   scopeRules,
   state,
   customRules,
-  shortcuts
+  shortcuts,
+  schemaErrors,
+  schemaMode = false,
+  onValidate
 }) {
   const storage = useStorage();
   const regle = vue.ref();
@@ -2097,7 +2179,11 @@ function useRootStorage({
     initialState,
     shortcuts,
     fieldName: "root",
-    path: ""
+    path: "",
+    schemaErrors,
+    rootSchemaErrors: schemaErrors,
+    schemaMode,
+    onValidate
   });
   if (vue.getCurrentScope()) {
     vue.onScopeDispose(() => {

package/dist/regle-core.d.cts

@@ -1,4 +1,4 @@
-import { MaybeRef, Ref, UnwrapRef, UnwrapNestedRefs, Raw, MaybeRefOrGetter, ComputedRef } from 'vue';
+import { MaybeRef, Ref, UnwrapRef, UnwrapNestedRefs, Raw, MaybeRefOrGetter } from 'vue';
 
 type Prettify<T> = T extends infer R ? {
     [K in keyof R]: R[K];
@@ -591,7 +591,7 @@ type useRegleFn<TCustomRules extends Partial<AllRulesDeclarations>, TShortcuts e
 declare const useRegle: useRegleFn<Partial<AllRulesDeclarations>, RegleShortcutDefinition<any>>;
 
 interface inferRulesFn<TCustomRules extends Partial<AllRulesDeclarations>> {
-    <TState extends Record<string, any>, TRules extends ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules> & TValid, TValid = isDeepExact<NoInferLegacy<TRules>, ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules>> extends true ? {} : never>(state: MaybeRef<TState> | DeepReactiveState<TState> | undefined, rulesFactory: TRules): NoInferLegacy<TRules>;
+    <TState extends Record<string, any>, TRules extends ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules> & TValid, TValid = isDeepExact<NoInferLegacy<TRules>, ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules>> extends true ? {} : MismatchInfo<NoInferLegacy<TRules>, ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules>>>(state: MaybeRef<TState> | DeepReactiveState<TState> | undefined, rulesFactory: TRules): NoInferLegacy<TRules>;
     <TState extends PrimitiveTypes, TRules extends RegleRuleDecl>(state: MaybeRef<TState>, rulesFactory: TRules): NoInferLegacy<TRules>;
 }
 /**
@@ -603,13 +603,16 @@ interface inferRulesFn<TCustomRules extends Partial<AllRulesDeclarations>> {
  */
 declare const inferRules: inferRulesFn<Partial<AllRulesDeclarations>>;
 
-declare function useRootStorage({ initialState, options, scopeRules, state, customRules, shortcuts, }: {
-    scopeRules: ComputedRef<$InternalReglePartialRuleTree>;
+declare function useRootStorage({ initialState, options, scopeRules, state, customRules, shortcuts, schemaErrors, schemaMode, onValidate, }: {
+    scopeRules: Ref<$InternalReglePartialRuleTree>;
     state: Ref<Record<string, any>>;
     options: ResolvedRegleBehaviourOptions;
     initialState: Ref<Record<string, any>>;
     customRules?: () => CustomRulesDeclarationTree;
     shortcuts: RegleShortcutDefinition | undefined;
+    schemaErrors?: Ref<Partial<$InternalRegleErrorTree> | undefined>;
+    schemaMode?: boolean;
+    onValidate?: () => Promise<$InternalRegleResult>;
 }): {
     regle: $InternalRegleStatus | undefined;
 };
@@ -1688,4 +1691,4 @@ declare function defineRegleConfig<TShortcuts extends RegleShortcutDefinition<TC
     inferRules: inferRulesFn<TCustomRules>;
 };
 
-export { type $InternalRegleStatus, type AllRulesDeclarations, type DeepMaybeRef, type DeepReactiveState, type FormRuleDeclaration, type InferRegleRoot, type InferRegleRule, type InferRegleRules, type InferRegleShortcuts, type InferRegleStatusType, type InlineRuleDeclaration, InternalRuleType, type JoinDiscriminatedUnions, type LocalRegleBehaviourOptions, type Maybe, type NoInferLegacy, type PrimitiveTypes, type Regle, type RegleBehaviourOptions, type RegleCollectionErrors, type RegleCollectionRuleDecl, type RegleCollectionRuleDefinition, type RegleCollectionStatus, type RegleCommonStatus, type RegleComputedRules, type RegleEnforceCustomRequiredRules, type RegleEnforceRequiredRules, type RegleErrorTree, type RegleExternalCollectionErrors, type RegleExternalErrorTree, type RegleFieldStatus, type RegleFormPropertyType, type RegleInternalRuleDefs, type ReglePartialRuleTree, type RegleResult, type RegleRoot, type RegleRuleCore, type RegleRuleDecl, type RegleRuleDefinition, type RegleRuleDefinitionProcessor, type RegleRuleDefinitionWithMetadataProcessor, type RegleRuleInit, type RegleRuleMetadataConsumer, type RegleRuleMetadataDefinition, type RegleRuleMetadataExtended, type RegleRuleRaw, type RegleRuleStatus, type RegleRuleTypeReturn, type RegleRuleWithParamsDefinition, type RegleShortcutDefinition, type RegleStatus, type RegleUniversalParams, type RegleValidationErrors, type RegleValidationGroupEntry, type RegleValidationGroupOutput, type RegleRuleTree as RegleValidationTree, type ResolvedRegleBehaviourOptions, type Unwrap, type UnwrapRegleUniversalParams, type UnwrapRuleWithParams, createRule, defineRegleConfig, inferRules, unwrapRuleParameters, useRegle, useRootStorage };
+export { type $InternalRegleStatus, type AllRulesDeclarations, type DeepMaybeRef, type DeepReactiveState, type FormRuleDeclaration, type InferRegleRoot, type InferRegleRule, type InferRegleRules, type InferRegleShortcuts, type InferRegleStatusType, type InlineRuleDeclaration, InternalRuleType, type JoinDiscriminatedUnions, type LocalRegleBehaviourOptions, type Maybe, type MismatchInfo, type NoInferLegacy, type PrimitiveTypes, type Regle, type RegleBehaviourOptions, type RegleCollectionErrors, type RegleCollectionRuleDecl, type RegleCollectionRuleDefinition, type RegleCollectionStatus, type RegleCommonStatus, type RegleComputedRules, type RegleEnforceCustomRequiredRules, type RegleEnforceRequiredRules, type RegleErrorTree, type RegleExternalCollectionErrors, type RegleExternalErrorTree, type RegleFieldStatus, type RegleFormPropertyType, type RegleInternalRuleDefs, type ReglePartialRuleTree, type RegleResult, type RegleRoot, type RegleRuleCore, type RegleRuleDecl, type RegleRuleDefinition, type RegleRuleDefinitionProcessor, type RegleRuleDefinitionWithMetadataProcessor, type RegleRuleInit, type RegleRuleMetadataConsumer, type RegleRuleMetadataDefinition, type RegleRuleMetadataExtended, type RegleRuleRaw, type RegleRuleStatus, type RegleRuleTypeReturn, type RegleRuleWithParamsDefinition, type RegleShortcutDefinition, type RegleStatus, type RegleUniversalParams, type RegleValidationErrors, type RegleValidationGroupEntry, type RegleValidationGroupOutput, type RegleRuleTree as RegleValidationTree, type ResolvedRegleBehaviourOptions, type Unwrap, type UnwrapRegleUniversalParams, type UnwrapRuleWithParams, createRule, defineRegleConfig, inferRules, unwrapRuleParameters, useRegle, useRootStorage };