@strictly/react-form 0.0.24 → 0.0.26

package/.turbo/turbo-build.log

@@ -7,12 +7,12 @@ $ tsup
 CLI Target: es6
 CJS Build start
 ESM Build start
-CJS dist/index.cjs 60.74 KB
-CJS ⚡️ Build success in 148ms
-ESM dist/index.js 56.72 KB
-ESM ⚡️ Build success in 148ms
+ESM dist/index.js 59.53 KB
+ESM ⚡️ Build success in 105ms
+CJS dist/index.cjs 63.62 KB
+CJS ⚡️ Build success in 110ms
 DTS Build start
-DTS ⚡️ Build success in 31697ms
-DTS dist/index.d.cts 37.27 KB
-DTS dist/index.d.ts  37.27 KB
-Done in 32.89s.
+DTS ⚡️ Build success in 30914ms
+DTS dist/index.d.cts 38.03 KB
+DTS dist/index.d.ts  38.03 KB
+Done in 32.12s.

package/.turbo/turbo-check-types.log

@@ -1,3 +1,3 @@
 yarn run v1.22.22
 $ tsc -b
-Done in 0.41s.
+Done in 0.43s.

package/.turbo/turbo-release$colon$exports.log

@@ -1,3 +1,3 @@
 yarn run v1.22.22
 $ json -f package.json -f package.exports.json --merge > package.release.json
-Done in 0.12s.
+Done in 0.11s.

package/core/mobx/form_model.ts

@@ -12,6 +12,7 @@ import {
 import {
   type Accessor,
   type AnyValueType,
+  equals,
   flattenAccessorsOfType,
   type FlattenedValuesOfType,
   flattenTypesOfType,
@@ -88,6 +89,12 @@ type FlattenedFieldOverrides<
   >
 }
 
+type FlattenedErrorOverrides<
+  ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>,
+> = {
+  -readonly [K in keyof ValuePathsToAdapters]?: ErrorOfFieldAdapter<ValuePathsToAdapters[K]>
+}
+
 export enum Validation {
   None = 0,
   Changed = 1,
@@ -144,6 +151,8 @@ export abstract class FormModel<
   @observable.shallow
   accessor fieldOverrides: FlattenedFieldOverrides<ValuePathsToAdapters>
   @observable.shallow
+  accessor errorOverrides: FlattenedErrorOverrides<ValuePathsToAdapters> = {}
+  @observable.shallow
   accessor validation: FlattenedValidation<ValuePathsToAdapters> = {}
 
   private readonly flattenedTypeDefs: Readonly<Record<string, Type>>
@@ -273,7 +282,7 @@ export abstract class FormModel<
     return this.synthesizeFieldByPaths(valuePath, typePath)
   }
 
-  private synthesizeFieldByPaths(valuePath: keyof ValuePathsToAdapters, typePath: keyof TypePathsToAdapters) {
+  private getField(valuePath: keyof ValuePathsToAdapters, typePath: keyof TypePathsToAdapters) {
     const adapter = this.adapters[typePath]
     if (adapter == null) {
       // invalid path, which can happen
@@ -311,43 +320,74 @@ export abstract class FormModel<
       valuePath as string,
       context,
     )
-    let error: unknown = undefined
     const displayedValue = fieldOverride != null ? fieldOverride[0] : value
+
+    return {
+      context,
+      convert,
+      create,
+      revert,
+      displayedValue,
+      // value,
+      required,
+      readonly,
+      defaultValue,
+    }
+  }
+
+  private synthesizeFieldByPaths(valuePath: keyof ValuePathsToAdapters, typePath: keyof TypePathsToAdapters) {
+    const field = this.getField(valuePath, typePath)
+    if (field == null) {
+      return
+    }
+    const {
+      context,
+      convert,
+      revert,
+      displayedValue,
+      required,
+      readonly,
+      defaultValue,
+    } = field
     const validation = this.validation[valuePath] ?? Validation.None
-    switch (validation) {
-      case Validation.None:
-        // skip validation
-        break
-      case Validation.Changed:
-        if (revert != null) {
-          const originalValue = valuePath in this.originalValues
+    let error: unknown = this.errorOverrides[valuePath]
+    if (error == null) {
+      switch (validation) {
+        case Validation.None:
+          // skip validation
+          break
+        case Validation.Changed:
+          if (revert != null) {
+            const originalValue = valuePath in this.originalValues
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              ? this.originalValues[valuePath as string]
+              : defaultValue
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            ? this.originalValues[valuePath as string]
-            : defaultValue
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          const { value: originalDisplayedValue } = convert(originalValue, valuePath as string, context)
-          // TODO better comparisons, displayed values can still be complex
-          if (displayedValue !== originalDisplayedValue) {
-            const revertResult = revert(displayedValue, valuePath, context)
+            const { value: originalDisplayedValue } = convert(originalValue, valuePath as string, context)
+            // TODO better comparisons, displayed values can still be complex
+            if (displayedValue !== originalDisplayedValue) {
+              const revertResult = revert(displayedValue, valuePath, context)
+              if (revertResult?.type === UnreliableFieldConversionType.Failure) {
+                ;({ error } = revertResult)
+              }
+            }
+          }
+          break
+        case Validation.Always:
+          {
+            const revertResult = revert?.(displayedValue, valuePath, context)
             if (revertResult?.type === UnreliableFieldConversionType.Failure) {
               ;({ error } = revertResult)
             }
           }
-        }
-        break
-      case Validation.Always:
-        {
-          const revertResult = revert?.(displayedValue, valuePath, context)
-          if (revertResult?.type === UnreliableFieldConversionType.Failure) {
-            ;({ error } = revertResult)
-          }
-        }
-        break
-      default:
-        throw new UnreachableError(validation)
+          break
+        default:
+          throw new UnreachableError(validation)
+      }
     }
+
     return {
-      value: fieldOverride != null ? fieldOverride[0] : value,
+      value: displayedValue,
       error,
       readonly: readonly && !this.forceMutableFields,
       required,
@@ -386,6 +426,14 @@ export abstract class FormModel<
     )
   }
 
+  @computed
+  get dirty() {
+    return Object.keys(this.accessors).some((valuePath) => {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return this.isFieldDirty(valuePath as keyof ValuePathsToAdapters)
+    })
+  }
+
   typePath<K extends keyof ValueToTypePaths>(valuePath: K): ValueToTypePaths[K] {
     return valuePathToTypePath<ValueToTypePaths, K>(this.type, valuePath, true)
   }
@@ -574,6 +622,7 @@ export abstract class FormModel<
     const accessor = this.getAccessorForValuePath(valuePath)
     return runInAction(() => {
       this.fieldOverrides[valuePath] = [value]
+      delete this.errorOverrides[valuePath]
       if (validation != null) {
         this.validation[valuePath] = validation
       }
@@ -592,11 +641,30 @@ export abstract class FormModel<
     })
   }
 
+  /**
+   * Forces an error onto a field. Error will be removed if the field value changes
+   * @param valuePath the field to display an error for
+   * @param error the error to display
+   */
+  overrideFieldError<K extends keyof ValuePathsToAdapters>(
+    valuePath: K,
+    error?: ErrorOfFieldAdapter<ValuePathsToAdapters[K]>,
+  ) {
+    runInAction(() => {
+      if (error) {
+        this.errorOverrides[valuePath] = error
+      } else {
+        delete this.errorOverrides[valuePath]
+      }
+    })
+  }
+
   clearFieldError<K extends keyof ValuePathsToAdapters>(valuePath: K) {
     const fieldOverride = this.fieldOverrides[valuePath]
     if (fieldOverride != null) {
       runInAction(() => {
         delete this.validation[valuePath]
+        delete this.errorOverrides[valuePath]
       })
     }
   }
@@ -623,6 +691,7 @@ export abstract class FormModel<
     runInAction(() => {
       this.fieldOverrides[key] = [displayValue]
       delete this.validation[key]
+      delete this.errorOverrides[key]
     })
   }
 
@@ -631,6 +700,7 @@ export abstract class FormModel<
       this.validation = {}
       // TODO this isn't correct, should reload from value
       this.fieldOverrides = {}
+      this.errorOverrides = {}
       this.value = mobxCopy(this.type, value)
     })
   }
@@ -646,12 +716,59 @@ export abstract class FormModel<
     return this.validation[valuePath] ?? Validation.None
   }
 
+  isFieldDirty<K extends keyof ValuePathsToAdapters>(valuePath: K): boolean {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const typePath = valuePathToTypePath<ValueToTypePaths, keyof ValueToTypePaths>(
+      this.type,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      valuePath as keyof ValueToTypePaths,
+      true,
+    ) as keyof TypePathsToAdapters
+    const field = this.getField(valuePath, typePath)
+
+    if (field == null) {
+      return false
+    }
+
+    const {
+      displayedValue,
+      convert,
+      revert,
+      context,
+      defaultValue,
+    } = field
+
+    // if either the display value, or the stored value, match the original, then assume it's not dirty
+    const originalValue = valuePath in this.originalValues
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      ? this.originalValues[valuePath as string]
+      : defaultValue
+    if (revert != null) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const typeDef = this.flattenedTypeDefs[typePath as string]
+      const {
+        value,
+        type,
+      } = revert(displayedValue, valuePath, context)
+      if (type === UnreliableFieldConversionType.Success) {
+        if (equals(typeDef, originalValue, value)) {
+          return false
+        }
+      }
+    }
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const { value: originalDisplayedValue } = convert(originalValue, valuePath as string, context)
+    // try to compare the displayed values directly if we can't revert the displayed value
+    return displayedValue !== originalDisplayedValue
+  }
+
   validateField<K extends keyof ValuePathsToAdapters>(
     valuePath: K,
     validation: Validation = Validation.Always,
   ): boolean {
     runInAction(() => {
       this.validation[valuePath] = validation
+      delete this.errorOverrides[valuePath]
     })
     return this.fields[valuePath].error == null
   }
@@ -673,4 +790,8 @@ export abstract class FormModel<
       },
     )
   }
+
+  validateSubmit() {
+    return this.validateAll()
+  }
 }

package/core/mobx/hooks.tsx

@@ -41,8 +41,8 @@ export function useDefaultMobxFormHooks<
       path: Path,
       value: ValueTypeOfField<F[Path]>,
     ) {
-      // clear validation once there are no errors for the field
-      model.setFieldValue<Path>(path, value)
+      const validation = Math.min(model.getValidation(path), Validation.Changed)
+      model.setFieldValue<Path>(path, value, validation)
     },
     [model],
   )
@@ -66,7 +66,8 @@ export function useDefaultMobxFormHooks<
       // (e.g. changing a discriminator)
       // TODO debounce?
       setTimeout(function () {
-        if (model.isValuePathActive(path)) {
+        // only start validation if the user has changed the field
+        if (model.isValuePathActive(path) && model.isFieldDirty(path)) {
           // further workaround to make sure we don't downgrade the existing validation
           model.validateField(path, Math.max(Validation.Changed, model.getValidation(path)))
         }
@@ -77,7 +78,7 @@ export function useDefaultMobxFormHooks<
 
   const onFormSubmit = useCallback(
     function () {
-      if (model.validateAll()) {
+      if (model.validateSubmit()) {
         onValidFormSubmit?.(model.value)
       }
     },

package/dist/index.cjs

@@ -363,8 +363,8 @@ var Validation = /* @__PURE__ */ ((Validation2) => {
   Validation2[Validation2["Always"] = 2] = "Always";
   return Validation2;
 })(Validation || {});
-var _accessors_dec, _knownFields_dec, _fields_dec, _validation_dec, _fieldOverrides_dec, _value_dec, _init, _value, _fieldOverrides, _validation;
-_value_dec = [import_mobx.observable.ref], _fieldOverrides_dec = [import_mobx.observable.shallow], _validation_dec = [import_mobx.observable.shallow], _fields_dec = [import_mobx.computed], _knownFields_dec = [import_mobx.computed], _accessors_dec = [import_mobx.computed];
+var _dirty_dec, _accessors_dec, _knownFields_dec, _fields_dec, _validation_dec, _errorOverrides_dec, _fieldOverrides_dec, _value_dec, _init, _value, _fieldOverrides, _errorOverrides, _validation;
+_value_dec = [import_mobx.observable.ref], _fieldOverrides_dec = [import_mobx.observable.shallow], _errorOverrides_dec = [import_mobx.observable.shallow], _validation_dec = [import_mobx.observable.shallow], _fields_dec = [import_mobx.computed], _knownFields_dec = [import_mobx.computed], _accessors_dec = [import_mobx.computed], _dirty_dec = [import_mobx.computed];
 var FormModel = class {
   constructor(type, originalValue, adapters, mode) {
     this.type = type;
@@ -373,7 +373,8 @@ var FormModel = class {
     __runInitializers(_init, 5, this);
     __privateAdd(this, _value, __runInitializers(_init, 8, this)), __runInitializers(_init, 11, this);
     __privateAdd(this, _fieldOverrides, __runInitializers(_init, 12, this)), __runInitializers(_init, 15, this);
-    __privateAdd(this, _validation, __runInitializers(_init, 16, this, {})), __runInitializers(_init, 19, this);
+    __privateAdd(this, _errorOverrides, __runInitializers(_init, 16, this, {})), __runInitializers(_init, 19, this);
+    __privateAdd(this, _validation, __runInitializers(_init, 20, this, {})), __runInitializers(_init, 23, this);
     __publicField(this, "flattenedTypeDefs");
     // cannot be type safe
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -463,8 +464,7 @@ var FormModel = class {
     }
     return this.synthesizeFieldByPaths(valuePath, typePath);
   }
-  synthesizeFieldByPaths(valuePath, typePath) {
-    var _a;
+  getField(valuePath, typePath) {
     const adapter2 = this.adapters[typePath];
     if (adapter2 == null) {
       return;
@@ -492,39 +492,68 @@ var FormModel = class {
       valuePath,
       context
     );
-    let error = void 0;
     const displayedValue = fieldOverride != null ? fieldOverride[0] : value;
+    return {
+      context,
+      convert,
+      create,
+      revert,
+      displayedValue,
+      // value,
+      required,
+      readonly,
+      defaultValue
+    };
+  }
+  synthesizeFieldByPaths(valuePath, typePath) {
+    var _a;
+    const field = this.getField(valuePath, typePath);
+    if (field == null) {
+      return;
+    }
+    const {
+      context,
+      convert,
+      revert,
+      displayedValue,
+      required,
+      readonly,
+      defaultValue
+    } = field;
     const validation = (_a = this.validation[valuePath]) != null ? _a : 0 /* None */;
-    switch (validation) {
-      case 0 /* None */:
-        break;
-      case 1 /* Changed */:
-        if (revert != null) {
-          const originalValue = valuePath in this.originalValues ? this.originalValues[valuePath] : defaultValue;
-          const { value: originalDisplayedValue } = convert(originalValue, valuePath, context);
-          if (displayedValue !== originalDisplayedValue) {
-            const revertResult = revert(displayedValue, valuePath, context);
+    let error = this.errorOverrides[valuePath];
+    if (error == null) {
+      switch (validation) {
+        case 0 /* None */:
+          break;
+        case 1 /* Changed */:
+          if (revert != null) {
+            const originalValue = valuePath in this.originalValues ? this.originalValues[valuePath] : defaultValue;
+            const { value: originalDisplayedValue } = convert(originalValue, valuePath, context);
+            if (displayedValue !== originalDisplayedValue) {
+              const revertResult = revert(displayedValue, valuePath, context);
+              if ((revertResult == null ? void 0 : revertResult.type) === 1 /* Failure */) {
+                ;
+                ({ error } = revertResult);
+              }
+            }
+          }
+          break;
+        case 2 /* Always */:
+          {
+            const revertResult = revert == null ? void 0 : revert(displayedValue, valuePath, context);
             if ((revertResult == null ? void 0 : revertResult.type) === 1 /* Failure */) {
               ;
               ({ error } = revertResult);
             }
           }
-        }
-        break;
-      case 2 /* Always */:
-        {
-          const revertResult = revert == null ? void 0 : revert(displayedValue, valuePath, context);
-          if ((revertResult == null ? void 0 : revertResult.type) === 1 /* Failure */) {
-            ;
-            ({ error } = revertResult);
-          }
-        }
-        break;
-      default:
-        throw new import_base2.UnreachableError(validation);
+          break;
+        default:
+          throw new import_base2.UnreachableError(validation);
+      }
     }
     return {
-      value: fieldOverride != null ? fieldOverride[0] : value,
+      value: displayedValue,
       error,
       readonly: readonly && !this.forceMutableFields,
       required
@@ -554,6 +583,11 @@ var FormModel = class {
       valuePath
     );
   }
+  get dirty() {
+    return Object.keys(this.accessors).some((valuePath) => {
+      return this.isFieldDirty(valuePath);
+    });
+  }
   typePath(valuePath) {
     return (0, import_define.valuePathToTypePath)(this.type, valuePath, true);
   }
@@ -699,6 +733,7 @@ var FormModel = class {
     const accessor = this.getAccessorForValuePath(valuePath);
     return (0, import_mobx.runInAction)(() => {
       this.fieldOverrides[valuePath] = [value];
+      delete this.errorOverrides[valuePath];
       if (validation != null) {
         this.validation[valuePath] = validation;
       }
@@ -716,11 +751,26 @@ var FormModel = class {
       }
     });
   }
+  /**
+   * Forces an error onto a field. Error will be removed if the field value changes
+   * @param valuePath the field to display an error for
+   * @param error the error to display
+   */
+  overrideFieldError(valuePath, error) {
+    (0, import_mobx.runInAction)(() => {
+      if (error) {
+        this.errorOverrides[valuePath] = error;
+      } else {
+        delete this.errorOverrides[valuePath];
+      }
+    });
+  }
   clearFieldError(valuePath) {
     const fieldOverride = this.fieldOverrides[valuePath];
     if (fieldOverride != null) {
       (0, import_mobx.runInAction)(() => {
         delete this.validation[valuePath];
+        delete this.errorOverrides[valuePath];
       });
     }
   }
@@ -743,12 +793,14 @@ var FormModel = class {
     (0, import_mobx.runInAction)(() => {
       this.fieldOverrides[key] = [displayValue];
       delete this.validation[key];
+      delete this.errorOverrides[key];
     });
   }
   clearAll(value) {
     (0, import_mobx.runInAction)(() => {
       this.validation = {};
       this.fieldOverrides = {};
+      this.errorOverrides = {};
       this.value = (0, import_define.mobxCopy)(this.type, value);
     });
   }
@@ -761,9 +813,44 @@ var FormModel = class {
     var _a;
     return (_a = this.validation[valuePath]) != null ? _a : 0 /* None */;
   }
+  isFieldDirty(valuePath) {
+    const typePath = (0, import_define.valuePathToTypePath)(
+      this.type,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      valuePath,
+      true
+    );
+    const field = this.getField(valuePath, typePath);
+    if (field == null) {
+      return false;
+    }
+    const {
+      displayedValue,
+      convert,
+      revert,
+      context,
+      defaultValue
+    } = field;
+    const originalValue = valuePath in this.originalValues ? this.originalValues[valuePath] : defaultValue;
+    if (revert != null) {
+      const typeDef = this.flattenedTypeDefs[typePath];
+      const {
+        value,
+        type
+      } = revert(displayedValue, valuePath, context);
+      if (type === 0 /* Success */) {
+        if ((0, import_define.equals)(typeDef, originalValue, value)) {
+          return false;
+        }
+      }
+    }
+    const { value: originalDisplayedValue } = convert(originalValue, valuePath, context);
+    return displayedValue !== originalDisplayedValue;
+  }
   validateField(valuePath, validation = 2 /* Always */) {
     (0, import_mobx.runInAction)(() => {
       this.validation[valuePath] = validation;
+      delete this.errorOverrides[valuePath];
     });
     return this.fields[valuePath].error == null;
   }
@@ -781,17 +868,23 @@ var FormModel = class {
       }
     );
   }
+  validateSubmit() {
+    return this.validateAll();
+  }
 };
 _init = __decoratorStart(null);
 _value = new WeakMap();
 _fieldOverrides = new WeakMap();
+_errorOverrides = new WeakMap();
 _validation = new WeakMap();
 __decorateElement(_init, 4, "value", _value_dec, FormModel, _value);
 __decorateElement(_init, 4, "fieldOverrides", _fieldOverrides_dec, FormModel, _fieldOverrides);
+__decorateElement(_init, 4, "errorOverrides", _errorOverrides_dec, FormModel, _errorOverrides);
 __decorateElement(_init, 4, "validation", _validation_dec, FormModel, _validation);
 __decorateElement(_init, 2, "fields", _fields_dec, FormModel);
 __decorateElement(_init, 2, "knownFields", _knownFields_dec, FormModel);
 __decorateElement(_init, 2, "accessors", _accessors_dec, FormModel);
+__decorateElement(_init, 2, "dirty", _dirty_dec, FormModel);
 __decoratorMetadata(_init, FormModel);
 
 // core/mobx/hooks.tsx
@@ -802,7 +895,8 @@ function useDefaultMobxFormHooks(model, {
 } = {}) {
   const onFieldValueChange = (0, import_react.useCallback)(
     function(path, value) {
-      model.setFieldValue(path, value);
+      const validation = Math.min(model.getValidation(path), 1 /* Changed */);
+      model.setFieldValue(path, value, validation);
     },
     [model]
   );
@@ -821,7 +915,7 @@ function useDefaultMobxFormHooks(model, {
   const onFieldBlur = (0, import_react.useCallback)(
     function(path) {
       setTimeout(function() {
-        if (model.isValuePathActive(path)) {
+        if (model.isValuePathActive(path) && model.isFieldDirty(path)) {
           model.validateField(path, Math.max(1 /* Changed */, model.getValidation(path)));
         }
       }, 100);
@@ -830,7 +924,7 @@ function useDefaultMobxFormHooks(model, {
   );
   const onFormSubmit = (0, import_react.useCallback)(
     function() {
-      if (model.validateAll()) {
+      if (model.validateSubmit()) {
         onValidFormSubmit == null ? void 0 : onValidFormSubmit(model.value);
       }
     },

package/dist/index.d.cts

@@ -112,6 +112,9 @@ type FieldOverride<V = any> = Maybe<V>;
 type FlattenedFieldOverrides<ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>> = {
     -readonly [K in keyof ValuePathsToAdapters]?: FieldOverride<ToOfFieldAdapter<ValuePathsToAdapters[K]>>;
 };
+type FlattenedErrorOverrides<ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>> = {
+    -readonly [K in keyof ValuePathsToAdapters]?: ErrorOfFieldAdapter<ValuePathsToAdapters[K]>;
+};
 declare enum Validation {
     None = 0,
     Changed = 1,
@@ -133,6 +136,7 @@ declare abstract class FormModel<T extends Type, ValueToTypePaths extends Readon
     protected readonly mode: FormMode;
     accessor value: MobxValueOfType<T>;
     accessor fieldOverrides: FlattenedFieldOverrides<ValuePathsToAdapters>;
+    accessor errorOverrides: FlattenedErrorOverrides<ValuePathsToAdapters>;
     accessor validation: FlattenedValidation<ValuePathsToAdapters>;
     private readonly flattenedTypeDefs;
     private readonly originalValues;
@@ -142,23 +146,33 @@ declare abstract class FormModel<T extends Type, ValueToTypePaths extends Readon
     get fields(): SimplifyDeep<FlattenedConvertedFieldsOf<ValuePathsToAdapters>>;
     private get knownFields();
     private maybeSynthesizeFieldByValuePath;
+    private getField;
     private synthesizeFieldByPaths;
     getAccessorForValuePath(valuePath: keyof ValuePathsToAdapters): Accessor | undefined;
     get accessors(): Readonly<Record<string, Accessor>>;
     private maybeGetAdapterForValuePath;
     private getAdapterForValuePath;
+    get dirty(): boolean;
     typePath<K extends keyof ValueToTypePaths>(valuePath: K): ValueToTypePaths[K];
     setFieldValue<K extends keyof ValuePathsToAdapters>(valuePath: K, value: ToOfFieldAdapter<ValuePathsToAdapters[K]>, validation?: Validation): boolean;
     addListItem<K extends keyof FlattenedListTypesOfType<T>>(valuePath: K, elementValue?: Maybe<ElementOfArray<FlattenedValuesOfType<T>[K]>>, index?: number): void;
     removeListItem<K extends keyof FlattenedListTypesOfType<T>>(...elementValuePaths: readonly `${K}.${number}`[]): void;
     private internalSetFieldValue;
+    /**
+     * Forces an error onto a field. Error will be removed if the field value changes
+     * @param valuePath the field to display an error for
+     * @param error the error to display
+     */
+    overrideFieldError<K extends keyof ValuePathsToAdapters>(valuePath: K, error?: ErrorOfFieldAdapter<ValuePathsToAdapters[K]>): void;
     clearFieldError<K extends keyof ValuePathsToAdapters>(valuePath: K): void;
     clearFieldValue<K extends StringKeyOf<ValuePathsToAdapters>>(valuePath: K): void;
     clearAll(value: ValueOfType<T>): void;
     isValuePathActive<K extends keyof ValuePathsToAdapters>(valuePath: K): boolean;
     getValidation<K extends keyof ValuePathsToAdapters>(valuePath: K): Validation;
+    isFieldDirty<K extends keyof ValuePathsToAdapters>(valuePath: K): boolean;
     validateField<K extends keyof ValuePathsToAdapters>(valuePath: K, validation?: Validation): boolean;
     validateAll(validation?: Validation): boolean;
+    validateSubmit(): boolean;
 }
 
 type ValueOfModel<M extends FormModel<any, any, any, any, any>> = M extends FormModel<infer T, any, any, any, any> ? ValueOfType<ReadonlyTypeOfType<T>> : never;