diff --git a/examples/basic-forms/1-basic-form-naive/src/example.tsx b/examples/basic-forms/1-basic-form-naive/src/example.tsx
index 59ce94c..311043e 100644
--- a/examples/basic-forms/1-basic-form-naive/src/example.tsx
+++ b/examples/basic-forms/1-basic-form-naive/src/example.tsx
@@ -33,7 +33,7 @@ const Example: React.FC = () => {
         <input
           id={name.id}
           value={name.value}
-          onChange={e => name.setValue(e.target.value)}
+          onChange={name.handleChange}
           onBlur={name.handleBlur}
           autoComplete="off"
         />
@@ -45,9 +45,7 @@ const Example: React.FC = () => {
           type="number"
           id={age.id}
           value={age.value}
-          onChange={e =>
-            age.setValue(e.target.value === "" ? "" : +e.target.value)
-          }
+          onChange={age.handleChange}
           onBlur={age.handleBlur}
           autoComplete="off"
         />
diff --git a/examples/basic-forms/2-basic-form-improved/src/example.tsx b/examples/basic-forms/2-basic-form-improved/src/example.tsx
index 17e41d8..b374f96 100644
--- a/examples/basic-forms/2-basic-form-improved/src/example.tsx
+++ b/examples/basic-forms/2-basic-form-improved/src/example.tsx
@@ -42,7 +42,7 @@ const NameField: React.FC = () => {
       <input
         id={field.id}
         value={field.value}
-        onChange={e => field.setValue(e.target.value)}
+        onChange={field.handleChange}
         onBlur={field.handleBlur}
         autoComplete="off"
       />
@@ -60,9 +60,7 @@ const AgeField: React.FC = () => {
         type="number"
         id={field.id}
         value={field.value}
-        onChange={e =>
-          field.setValue(e.target.value === "" ? "" : +e.target.value)
-        }
+        onChange={field.handleChange}
         onBlur={field.handleBlur}
         autoComplete="off"
       />
diff --git a/examples/basic-forms/3-basic-form-validation/src/example.tsx b/examples/basic-forms/3-basic-form-validation/src/example.tsx
index e453d7b..217d8ad 100644
--- a/examples/basic-forms/3-basic-form-validation/src/example.tsx
+++ b/examples/basic-forms/3-basic-form-validation/src/example.tsx
@@ -61,7 +61,7 @@ const NameField: React.FC = () => {
       <input
         id={field.id}
         value={field.value}
-        onChange={e => field.setValue(e.target.value)}
+        onChange={field.handleChange}
         onBlur={field.handleBlur}
         autoComplete="off"
       />
@@ -80,9 +80,7 @@ const AgeField: React.FC = () => {
         type="number"
         id={field.id}
         value={field.value}
-        onChange={e =>
-          field.setValue(e.target.value === "" ? "" : +e.target.value)
-        }
+        onChange={field.handleChange}
         onBlur={field.handleBlur}
         autoComplete="off"
       />
diff --git a/examples/basic-forms/4-basic-form-mui/src/example.tsx b/examples/basic-forms/4-basic-form-mui/src/example.tsx
index ef2e4bc..e94fdc6 100644
--- a/examples/basic-forms/4-basic-form-mui/src/example.tsx
+++ b/examples/basic-forms/4-basic-form-mui/src/example.tsx
@@ -63,7 +63,7 @@ const NameField: React.FC = () => {
         label="Name:"
         id={field.id}
         value={field.value}
-        onChange={e => field.setValue(e.target.value)}
+        onChange={field.handleChange}
         onBlur={field.handleBlur}
         error={field.error != null}
         helperText={field.error}
@@ -83,9 +83,7 @@ const AgeField: React.FC = () => {
         label="Age:"
         id={field.id}
         value={field.value}
-        onChange={e =>
-          field.setValue(e.target.value === "" ? "" : +e.target.value)
-        }
+        onChange={field.handleChange}
         onBlur={field.handleBlur}
         error={field.error != null}
         helperText={field.error}
diff --git a/examples/inputs/checkbox-group-input/src/example.tsx b/examples/inputs/checkbox-group-input/src/example.tsx
index c5ff5f8..be6df5d 100644
--- a/examples/inputs/checkbox-group-input/src/example.tsx
+++ b/examples/inputs/checkbox-group-input/src/example.tsx
@@ -60,7 +60,7 @@ const ColorsCheckboxGroup: React.FC = () => {
             name={colors.id}
             checked={field.value}
             onBlur={field.handleBlur}
-            onChange={e => field.setValue(e.target.checked)}
+            onChange={field.handleChange}
           />
           <label htmlFor={field.id}>{labels[key]}</label>
         </div>
diff --git a/examples/inputs/field-array-input/src/example.tsx b/examples/inputs/field-array-input/src/example.tsx
index f272909..cac1d52 100644
--- a/examples/inputs/field-array-input/src/example.tsx
+++ b/examples/inputs/field-array-input/src/example.tsx
@@ -43,7 +43,7 @@ const PromoCodesArrayInput: React.FC = () => {
           <input
             key={field.id}
             value={field.value}
-            onChange={e => field.setValue(e.target.value)}
+            onChange={field.handleChange}
             onBlur={field.handleBlur}
             autoComplete="off"
           />
diff --git a/examples/inputs/mui-date-picker-input/src/example.tsx b/examples/inputs/mui-date-picker-input/src/example.tsx
index 3f13f02..3df53fd 100644
--- a/examples/inputs/mui-date-picker-input/src/example.tsx
+++ b/examples/inputs/mui-date-picker-input/src/example.tsx
@@ -17,7 +17,7 @@ import ReactDOM from "react-dom";
 import "../index.css";
 
 const Schema = createFormSchema(fields => ({
-  date: fields.instanceOf(Date),
+  date: fields.date(),
 }));
 
 const Example: React.FC = () => {
@@ -44,7 +44,8 @@ const DatePickerInput: React.FC = () => {
         variant="inline"
         label="Choose your favourite date"
         value={dateField.value}
-        onChange={date => dateField.setValue(date as Date)}
+        onChange={dateField.setValue}
+        onBlur={dateField.handleBlur}
         fullWidth
         autoOk
       />
diff --git a/examples/inputs/mui-multi-select-input/src/example.tsx b/examples/inputs/mui-multi-select-input/src/example.tsx
index c29ce4e..9579efd 100644
--- a/examples/inputs/mui-multi-select-input/src/example.tsx
+++ b/examples/inputs/mui-multi-select-input/src/example.tsx
@@ -56,10 +56,7 @@ const ColorsMultiSelectInput: React.FC = () => {
         <Select
           labelId={colors.id}
           value={colors.value}
-          onChange={e => {
-            // TODO: simplify when field.handleChange is implemented
-            colors.setValue(e.target.value as Array<"red" | "green" | "blue">);
-          }}
+          onChange={colors.handleChange}
           input={<Input />}
           renderValue={selected => (selected as string[]).join(", ")}
           multiple
diff --git a/examples/inputs/radio-group-input/src/example.tsx b/examples/inputs/radio-group-input/src/example.tsx
index 23c4422..4dbb441 100644
--- a/examples/inputs/radio-group-input/src/example.tsx
+++ b/examples/inputs/radio-group-input/src/example.tsx
@@ -42,14 +42,15 @@ const ColorsRadioGroup: React.FC = () => {
       <legend>Choose your favourite color:</legend>
 
       {Object.values(colors.options).map(option => (
-        <div key={colors.id}>
+        <div key={option}>
           <input
             id={option}
             type="radio"
             name={colors.id}
+            value={option}
             checked={colors.value === option}
             onBlur={colors.handleBlur}
-            onChange={e => e.target.checked && colors.setValue(option)}
+            onChange={colors.handleChange}
           />
           <label htmlFor={option}>{labels[option]}</label>
         </div>
diff --git a/examples/inputs/select-input/src/example.tsx b/examples/inputs/select-input/src/example.tsx
index d4f3e85..1f3db65 100644
--- a/examples/inputs/select-input/src/example.tsx
+++ b/examples/inputs/select-input/src/example.tsx
@@ -44,13 +44,9 @@ const ColorSelectInput: React.FC = () => {
       <select
         id={field.id}
         value={field.value}
-        onChange={e => field.setValue(e.target.value as Color)}
+        onChange={field.handleChange}
         onBlur={field.handleBlur}
       >
-        {/* 
-         we need custom-typed Object.keys in order for type of `option`
-         to be inferred properly to "red" | "green" | "blue" in this example 
-        */}
         {Object.values(field.options).map(option => (
           <option key={option} value={option}>
             {labels[option]}
diff --git a/src/core/builders/create-form-schema.spec.ts b/src/core/builders/create-form-schema.spec.ts
index 3235b65..cce3ef1 100644
--- a/src/core/builders/create-form-schema.spec.ts
+++ b/src/core/builders/create-form-schema.spec.ts
@@ -12,7 +12,7 @@ describe("createFormSchema", () => {
       choice: fields.choice("A", "B", "C"),
       num: fields.number(),
       bool: fields.bool(),
-      instance: fields.instanceOf(Date),
+      date: fields.date(),
       arrayString: fields.array(fields.string()),
       arrayChoice: fields.array(fields.choice("a", "b", "c")),
       arrayArrayString: fields.array(fields.array(fields.string())),
@@ -35,7 +35,7 @@ describe("createFormSchema", () => {
         choice: "A" | "B" | "C";
         num: number | "";
         bool: boolean;
-        instance: Date | null;
+        date: Date | null;
         arrayString: string[];
         arrayChoice: Array<"a" | "b" | "c">;
         arrayArrayString: string[][];
@@ -59,7 +59,7 @@ describe("createFormSchema", () => {
         choice: fields.choice("A", "B", "C"),
         num: fields.number(),
         bool: fields.bool(),
-        instance: fields.instanceOf(Date),
+        date: fields.date(),
         arrayString: fields.array(fields.string()),
         arrayChoice: fields.array(fields.choice("a", "b", "c")),
         arrayArrayString: fields.array(fields.array(fields.string())),
@@ -86,7 +86,7 @@ describe("createFormSchema", () => {
         choice: "A" | "B" | "C";
         num: number | "";
         bool: boolean;
-        instance: Date | null;
+        date: Date | null;
         arrayString: string[];
         arrayChoice: Array<"a" | "b" | "c">;
         arrayArrayString: string[][];
@@ -115,7 +115,7 @@ describe("createFormSchema", () => {
       choice: fields.choice("A", "B", "C"),
       num: fields.number(),
       bool: fields.bool(),
-      instance: fields.instanceOf(Date),
+      date: fields.date(),
       arrayString: fields.array(fields.string()),
       arrayChoice: fields.array(fields.choice("a", "b", "c")),
       arrayArrayString: fields.array(fields.array(fields.string())),
@@ -136,7 +136,7 @@ describe("createFormSchema", () => {
       "choice",
       "num",
       "bool",
-      "instance",
+      "date",
       "arrayString",
       "arrayChoice",
       "arrayArrayString",
@@ -153,7 +153,7 @@ describe("createFormSchema", () => {
       choice: fields.choice("A", "B", "C"),
       num: fields.number(),
       bool: fields.bool(),
-      instance: fields.instanceOf(Date),
+      date: fields.date(),
       arrayString: fields.array(fields.string()),
       arrayChoice: fields.array(fields.choice("a", "b", "c")),
       arrayArrayString: fields.array(fields.array(fields.string())),
@@ -174,7 +174,7 @@ describe("createFormSchema", () => {
       choice: expect.objectContaining({ __path: "choice" }),
       num: expect.objectContaining({ __path: "num" }),
       bool: expect.objectContaining({ __path: "bool" }),
-      instance: expect.objectContaining({ __path: "instance" }),
+      date: expect.objectContaining({ __path: "date" }),
       arrayString: expect.objectContaining({
         __path: "arrayString",
         nth: expect.any(Function),
@@ -227,7 +227,7 @@ describe("createFormSchema", () => {
     expect(descriptor.__decoder.fieldType).toBe("string");
     expect(descriptor.__decoder.init()).toBe("");
     expect(descriptor.__decoder.decode("foo").ok).toBe(true);
-    expect(descriptor.__decoder.decode(42).ok).toBe(false);
+    expect(descriptor.__decoder.decode({}).ok).toBe(false);
   });
 
   it("creates field descriptor for choice field", () => {
@@ -263,7 +263,7 @@ describe("createFormSchema", () => {
     expect(descriptor.__decoder.fieldType).toBe("number");
     expect(descriptor.__decoder.init()).toBe("");
     expect(descriptor.__decoder.decode(666).ok).toBe(true);
-    expect(descriptor.__decoder.decode("42").ok).toBe(false);
+    expect(descriptor.__decoder.decode("foo").ok).toBe(false);
   });
 
   it("creates field descriptor for bool field", () => {
@@ -277,25 +277,21 @@ describe("createFormSchema", () => {
     expect(descriptor.__decoder.fieldType).toBe("bool");
     expect(descriptor.__decoder.init()).toBe(false);
     expect(descriptor.__decoder.decode(true).ok).toBe(true);
-    expect(descriptor.__decoder.decode("true").ok).toBe(false);
+    expect(descriptor.__decoder.decode("foo").ok).toBe(false);
   });
 
-  it("creates field descriptor for instanceOf field", () => {
-    class MyClass {
-      constructor(public foo: string) {}
-    }
-
+  it("creates field descriptor for date field", () => {
     const Schema = createFormSchema(fields => ({
-      theClass: fields.instanceOf(MyClass),
+      theDate: fields.date(),
     }));
 
-    const descriptor = impl(Schema.theClass);
+    const descriptor = impl(Schema.theDate);
 
-    expect(descriptor.__path).toBe("theClass");
-    expect(descriptor.__decoder.fieldType).toBe("class");
+    expect(descriptor.__path).toBe("theDate");
+    expect(descriptor.__decoder.fieldType).toBe("date");
     expect(descriptor.__decoder.init()).toBe(null);
-    expect(descriptor.__decoder.decode(new MyClass("42")).ok).toBe(true);
-    expect(descriptor.__decoder.decode({ foo: "42" }).ok).toBe(false);
+    expect(descriptor.__decoder.decode(new Date()).ok).toBe(true);
+    expect(descriptor.__decoder.decode(new Date("foo")).ok).toBe(false);
   });
 
   it("creates field descriptor for array field", () => {
diff --git a/src/core/builders/create-form-schema.ts b/src/core/builders/create-form-schema.ts
index 01833b6..9cce00f 100644
--- a/src/core/builders/create-form-schema.ts
+++ b/src/core/builders/create-form-schema.ts
@@ -76,7 +76,7 @@ const createFieldDescriptor = (
     case "bool":
     case "number":
     case "string":
-    case "class":
+    case "date":
     case "choice":
       return rootDescriptor;
 
diff --git a/src/core/builders/create-form-validator.spec.ts b/src/core/builders/create-form-validator.spec.ts
index e2a4ab6..852e425 100644
--- a/src/core/builders/create-form-validator.spec.ts
+++ b/src/core/builders/create-form-validator.spec.ts
@@ -46,7 +46,7 @@ describe("createFormValidator", () => {
       string: fields.string(),
       number: fields.number(),
       choice: fields.choice("A", "B", "C"),
-      instance: fields.instanceOf(Date),
+      date: fields.date(),
       arrayString: fields.array(fields.string()),
       arrayChoice: fields.array(fields.choice("a", "b", "c")),
       arrayArrayString: fields.array(fields.array(fields.string())),
@@ -178,18 +178,18 @@ describe("createFormValidator", () => {
     expect(validation).toEqual([{ field: Schema.choice, error: null }]);
   });
 
-  it("should return ERR for failing single-rule on instance field ", async () => {
+  it("should return ERR for failing single-rule on date field ", async () => {
     const { validate } = createFormValidator(Schema, validate => [
       validate({
-        field: Schema.instance,
+        field: Schema.date,
         rules: () => [x => (x === null ? "REQUIRED" : null)],
       }),
     ]);
     const getValue = () => null as any;
 
-    const validation = await validate({ fields: [Schema.instance], getValue });
+    const validation = await validate({ fields: [Schema.date], getValue });
 
-    expect(validation).toEqual([{ field: Schema.instance, error: "REQUIRED" }]);
+    expect(validation).toEqual([{ field: Schema.date, error: "REQUIRED" }]);
   });
 
   it("should return ERR for failing multiple-rule on string array field ", async () => {
diff --git a/src/core/decoders/array.spec.ts b/src/core/decoders/array.spec.ts
index f52b511..32e7981 100644
--- a/src/core/decoders/array.spec.ts
+++ b/src/core/decoders/array.spec.ts
@@ -42,7 +42,7 @@ describe("array decoder", () => {
       const decoder = impl(array(string()));
       const value = [null, "foo", 42, "", []];
 
-      expect(decoder.decode(value)).toEqual({ ok: false, value });
+      expect(decoder.decode(value)).toEqual({ ok: false });
     });
   });
 
@@ -64,7 +64,7 @@ describe("array decoder", () => {
       const decoder = impl(array(string()));
       const value = [null, "foo", 42, "", []];
 
-      expect(decoder.decode(value)).toEqual({ ok: false, value });
+      expect(decoder.decode(value)).toEqual({ ok: false });
     });
   });
 
@@ -87,7 +87,7 @@ describe("array decoder", () => {
       const decoder = impl(array(string()));
       const value = [null, "foo", 42, "", []];
 
-      expect(decoder.decode(value)).toEqual({ ok: false, value });
+      expect(decoder.decode(value)).toEqual({ ok: false });
     });
   });
 });
diff --git a/src/core/decoders/array.ts b/src/core/decoders/array.ts
index abc68f1..ac05315 100644
--- a/src/core/decoders/array.ts
+++ b/src/core/decoders/array.ts
@@ -3,8 +3,8 @@ import { impl, opaque } from "../types/type-mapper-util";
 
 /**
  * Define array field with elements of type defined by provided `innerDecoder`.
- * Will check if value is array and if each element matches expected type at runtime.
  * Default initial value will be `[]`
+ * Accepts empty arrays and arrays containing elements which are valid in respect to rules imposed by `innerDecoder`.
  *
  * @example
  * ```
@@ -23,7 +23,7 @@ export const array = <E>(
     init: () => [],
 
     decode: value => {
-      if (Array.isArray(value)) {
+      if (value && Array.isArray(value)) {
         const decodeResults = value.map(impl(innerDecoder).decode);
         if (decodeResults.every(result => result.ok)) {
           return {
@@ -32,7 +32,7 @@ export const array = <E>(
           };
         }
       }
-      return { ok: false, value };
+      return { ok: false };
     },
   };
 
diff --git a/src/core/decoders/bool.spec.ts b/src/core/decoders/bool.spec.ts
index 413cdd0..9f75833 100644
--- a/src/core/decoders/bool.spec.ts
+++ b/src/core/decoders/bool.spec.ts
@@ -22,31 +22,33 @@ describe("bool decoder", () => {
     expect(decoder.decode(false)).toEqual({ ok: true, value: false });
   });
 
-  it("should NOT decode string values", () => {
+  it("should decode matching string values", () => {
     const decoder = impl(bool());
 
-    [
-      "",
-      " ",
-      "1",
-      "0",
-      "true",
-      "false",
-      "TRUE",
-      "FALSE",
-      "Yes",
-      "No",
-      "foo",
-    ].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
-    );
+    expect(decoder.decode("true")).toEqual({ ok: true, value: true });
+    expect(decoder.decode("True")).toEqual({ ok: true, value: true });
+    expect(decoder.decode("TRUE")).toEqual({ ok: true, value: true });
+    expect(decoder.decode("true ")).toEqual({ ok: true, value: true });
+
+    expect(decoder.decode("false")).toEqual({ ok: true, value: false });
+    expect(decoder.decode("False")).toEqual({ ok: true, value: false });
+    expect(decoder.decode("FALSE")).toEqual({ ok: true, value: false });
+    expect(decoder.decode("false ")).toEqual({ ok: true, value: false });
+
+    expect(decoder.decode("")).toEqual({ ok: false });
+    expect(decoder.decode("1")).toEqual({ ok: false });
+    expect(decoder.decode("0")).toEqual({ ok: false });
+
+    expect(decoder.decode("truee")).toEqual({ ok: false });
+    expect(decoder.decode("yes")).toEqual({ ok: false });
+    expect(decoder.decode("no")).toEqual({ ok: false });
   });
 
   it("should NOT decode numbers", () => {
     const decoder = impl(bool());
 
     [0, 666, NaN, +Infinity, -Infinity].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
+      expect(decoder.decode(value)).toEqual({ ok: false })
     );
   });
 
@@ -54,7 +56,7 @@ describe("bool decoder", () => {
     const decoder = impl(bool());
 
     [{}, { foo: "bar" }, new Error("error"), []].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
+      expect(decoder.decode(value)).toEqual({ ok: false })
     );
   });
 
@@ -62,7 +64,7 @@ describe("bool decoder", () => {
     const decoder = impl(bool());
 
     [null, undefined].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
+      expect(decoder.decode(value)).toEqual({ ok: false })
     );
   });
 });
diff --git a/src/core/decoders/bool.ts b/src/core/decoders/bool.ts
index bf5a8c4..df73138 100644
--- a/src/core/decoders/bool.ts
+++ b/src/core/decoders/bool.ts
@@ -4,6 +4,7 @@ import { opaque } from "../types/type-mapper-util";
 /**
  * Define field of type `boolean`.
  * Default initial value will be `false`.
+ * Accepts boolean values and string "true" | "false".
  *
  * @example
  * ```
@@ -22,8 +23,20 @@ export const bool = (): FieldDecoder<boolean> => {
       switch (typeof value) {
         case "boolean":
           return { ok: true, value };
+
+        case "string": {
+          switch (value.toLowerCase().trim()) {
+            case "true":
+              return { ok: true, value: true };
+            case "false":
+              return { ok: true, value: false };
+            default:
+              return { ok: false };
+          }
+        }
+
         default:
-          return { ok: false, value };
+          return { ok: false };
       }
     },
   };
diff --git a/src/core/decoders/choice.spec.ts b/src/core/decoders/choice.spec.ts
index 9f8be26..709c729 100644
--- a/src/core/decoders/choice.spec.ts
+++ b/src/core/decoders/choice.spec.ts
@@ -48,32 +48,23 @@ describe("number decoder", () => {
       " A ",
       "ABC",
       "foobar",
-    ].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
-    );
+    ].forEach(value => expect(decoder.decode(value)).toEqual({ ok: false }));
   });
 
-  it("should NOT decode number values", () => {
-    const decoder = impl(choice("A", "B", "C"));
+  it("should decode matching number values", () => {
+    const decoder = impl(choice("0", "1"));
 
-    [NaN, +Infinity, -Infinity].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
-    );
-  });
-
-  it("should NOT decode string values", () => {
-    const decoder = impl(choice("A", "B", "C"));
-
-    [" ", "foo", " BAR ", "🔥"].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
-    );
+    expect(decoder.decode(0)).toEqual({ ok: true, value: "0" });
+    expect(decoder.decode(1)).toEqual({ ok: true, value: "1" });
+    expect(decoder.decode(2)).toEqual({ ok: false });
+    expect(decoder.decode(NaN)).toEqual({ ok: false });
   });
 
   it("should NOT decode boolean values", () => {
-    const decoder = impl(choice("A", "B", "C"));
+    const decoder = impl(choice("true", "false", "foo"));
 
     [true, false].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
+      expect(decoder.decode(value)).toEqual({ ok: false })
     );
   });
 
@@ -81,7 +72,7 @@ describe("number decoder", () => {
     const decoder = impl(choice("A", "B", "C"));
 
     [{}, { foo: "bar" }, new Error("error"), []].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
+      expect(decoder.decode(value)).toEqual({ ok: false })
     );
   });
 
@@ -89,7 +80,7 @@ describe("number decoder", () => {
     const decoder = impl(choice("A", "B", "C"));
 
     [null, undefined].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
+      expect(decoder.decode(value)).toEqual({ ok: false })
     );
   });
 });
diff --git a/src/core/decoders/choice.ts b/src/core/decoders/choice.ts
index 76e8940..39bb12f 100644
--- a/src/core/decoders/choice.ts
+++ b/src/core/decoders/choice.ts
@@ -7,8 +7,8 @@ import { opaque } from "../types/type-mapper-util";
 
 /**
  * Define field of given string literal union type.
- * Will check values against provided whitelist.
  * Default initial value will be first option received.
+ * Accepts string and number values which are present on provided options list.
  *
  * **requires at least one option to be provided**
  *
@@ -44,12 +44,18 @@ export const choice = <Opts extends string>(
       switch (typeof value) {
         case "string": {
           const option = optionsDictionary[value];
-          return option != null
-            ? { ok: true, value: option }
-            : { ok: false, value };
+          return option != null ? { ok: true, value: option } : { ok: false };
+        }
+        case "number": {
+          if (Number.isFinite(value)) {
+            const option = optionsDictionary[value.toString()];
+            return option != null ? { ok: true, value: option } : { ok: false };
+          } else {
+            return { ok: false };
+          }
         }
         default:
-          return { ok: false, value };
+          return { ok: false };
       }
     },
   };
diff --git a/src/core/decoders/date.spec.ts b/src/core/decoders/date.spec.ts
new file mode 100644
index 0000000..6dc701f
--- /dev/null
+++ b/src/core/decoders/date.spec.ts
@@ -0,0 +1,84 @@
+import { impl } from "../types/type-mapper-util";
+
+import { date } from "./date";
+
+describe("date decoder", () => {
+  it("should provide it's field type", () => {
+    const decoder = impl(date());
+
+    expect(decoder.fieldType).toBe("date");
+  });
+
+  it("should provide initial field value", () => {
+    const decoder = impl(date());
+
+    expect(decoder.init()).toBe(null);
+  });
+
+  it("should decode null value", () => {
+    const decoder = impl(date());
+    const value = null;
+
+    expect(decoder.decode(value)).toEqual({ ok: true, value });
+  });
+
+  it("should decode valid date instance", () => {
+    const decoder = impl(date());
+    const value = new Date();
+
+    expect(decoder.decode(value)).toEqual({ ok: true, value });
+  });
+
+  it("should NOT decode invalid date instance", () => {
+    const decoder = impl(date());
+    const value = new Date("foobar");
+
+    expect(decoder.decode(value)).toEqual({ ok: false });
+  });
+
+  it("should decode date strings", () => {
+    const decoder = impl(date());
+
+    [
+      new Date().toISOString(),
+      new Date().toLocaleDateString(),
+      new Date().toUTCString(),
+      new Date().toString(),
+    ].forEach(string =>
+      expect(decoder.decode(string)).toEqual({
+        ok: true,
+        value: new Date(string),
+      })
+    );
+  });
+
+  it("should NOT decode random strings", () => {
+    const decoder = impl(date());
+
+    [
+      "",
+      "foo",
+      new Date().toISOString() + "foo",
+      "12414252135",
+      "May",
+    ].forEach(string => expect(decoder.decode(string)).toEqual({ ok: false }));
+  });
+
+  it("should decode numbers as timestamp values", () => {
+    const decoder = impl(date());
+
+    [0, -10000000, new Date().valueOf()].forEach(number =>
+      expect(decoder.decode(number)).toEqual({
+        ok: true,
+        value: new Date(number),
+      })
+    );
+  });
+
+  it("should NOT decode undefined value", () => {
+    const decoder = impl(date());
+    const value = undefined;
+
+    expect(decoder.decode(value)).toEqual({ ok: false });
+  });
+});
diff --git a/src/core/decoders/date.ts b/src/core/decoders/date.ts
new file mode 100644
index 0000000..007a26e
--- /dev/null
+++ b/src/core/decoders/date.ts
@@ -0,0 +1,50 @@
+import { isValidDate } from "../../utils";
+import {
+  FieldDecoder,
+  _FieldDecoderBaseImpl,
+  _FieldDecoderImpl,
+} from "../types/field-decoder";
+import { opaque } from "../types/type-mapper-util";
+
+/**
+ * Define field holding an instance of JS Date or `null`
+ * Will check that value is a valid date at runtime.
+ * Default initial value will be `null`
+ * Accepts valid Date instances and strings or numbers that create valid Date when passed into Date constructor.
+ *
+ * @example
+ * ```
+ * const Schema = createForm.schema(fields => ({
+ *   x: fields.date() // x: Date | null
+ * }));
+ * ```
+ */
+export const date = (): FieldDecoder<Date | null> => {
+  const decoder: _FieldDecoderBaseImpl<Date | null> = {
+    fieldType: "date",
+
+    init: () => null,
+
+    decode: value => {
+      switch (typeof value) {
+        case "object":
+          return value === null || isValidDate(value)
+            ? { ok: true, value }
+            : { ok: false };
+
+        case "string":
+        case "number": {
+          const valueAsDate = new Date(value);
+          return isValidDate(valueAsDate)
+            ? { ok: true, value: valueAsDate }
+            : { ok: false };
+        }
+
+        default:
+          return { ok: false };
+      }
+    },
+  };
+
+  return opaque(decoder as _FieldDecoderImpl<Date | null>);
+};
diff --git a/src/core/decoders/index.ts b/src/core/decoders/index.ts
index 03ebc0f..aa5b576 100644
--- a/src/core/decoders/index.ts
+++ b/src/core/decoders/index.ts
@@ -1,7 +1,7 @@
+export * from "./array";
 export * from "./bool";
-export * from "./string";
-export * from "./number";
 export * from "./choice";
-export * from "./instanceof";
-export * from "./array";
+export * from "./date";
+export * from "./number";
 export * from "./object";
+export * from "./string";
diff --git a/src/core/decoders/instanceof.spec.ts b/src/core/decoders/instanceof.spec.ts
deleted file mode 100644
index fa114ff..0000000
--- a/src/core/decoders/instanceof.spec.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-import { impl } from "../types/type-mapper-util";
-
-import { instanceOf } from "./instanceof";
-
-describe("instanceOf decoder", () => {
-  it("should provide it's field type", () => {
-    const decoder = impl(instanceOf(Set));
-
-    expect(decoder.fieldType).toBe("class");
-  });
-
-  it("should provide initial field value", () => {
-    const decoder = impl(instanceOf(Date));
-
-    expect(decoder.init()).toBeNull();
-  });
-
-  [Object, Array, String, Number, Boolean].forEach(constructor =>
-    it(`should fail to instantiate using ${constructor.name} constructor`, () => {
-      expect(() => instanceOf(constructor)).toThrowError();
-    })
-  );
-
-  describe("combined with Date constructor", () => {
-    it("should decode date instance", () => {
-      const decoder = impl(instanceOf(Date));
-      const value = new Date();
-
-      expect(decoder.decode(value)).toEqual({ ok: true, value });
-    });
-
-    it("should NOT decode strings", () => {
-      const decoder = impl(instanceOf(Date));
-      const value = Date();
-
-      expect(decoder.decode(value)).toEqual({ ok: false, value });
-    });
-
-    it("should NOT decode null", () => {
-      const decoder = impl(instanceOf(Date));
-      const value = null;
-
-      expect(decoder.decode(value)).toEqual({ ok: false, value });
-    });
-  });
-
-  describe("combined with custom class", () => {
-    class MyClass {
-      constructor(public classy: boolean) {}
-    }
-
-    it("should decode class instance", () => {
-      const decoder = impl(instanceOf(MyClass));
-      const value = new MyClass(true);
-
-      expect(decoder.decode(value)).toEqual({ ok: true, value });
-    });
-
-    it("should NOT decode class-like objects", () => {
-      const decoder = impl(instanceOf(MyClass));
-      const value: MyClass = { classy: false };
-
-      expect(decoder.decode(value)).toEqual({ ok: false, value });
-    });
-
-    it("should NOT decode null", () => {
-      const decoder = impl(instanceOf(MyClass));
-      const value = null;
-
-      expect(decoder.decode(value)).toEqual({ ok: false, value });
-    });
-  });
-});
diff --git a/src/core/decoders/instanceof.ts b/src/core/decoders/instanceof.ts
deleted file mode 100644
index ce0fc5b..0000000
--- a/src/core/decoders/instanceof.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import { Constructor } from "../../utils";
-import {
-  FieldDecoder,
-  _FieldDecoderBaseImpl,
-  _FieldDecoderImpl,
-} from "../types/field-decoder";
-import { opaque } from "../types/type-mapper-util";
-
-/**s
- * Define object field holding instance of specified type or `null`.
- * Will perform `instanceof` check at runtime.
- * Default initial value will be `null`
- *
- * @example
- * ```
- * const Schema = createForm.schema(fields => ({
- *   x: fields.instanceOf(Date) // x: Date | null
- * }));
- * ```
- */
-export const instanceOf = <T>(
-  constructor: Constructor<T>
-): FieldDecoder<T | null> => {
-  switch (constructor as Constructor<any>) {
-    case Object:
-    case Array:
-    case String:
-    case Number:
-    case Boolean:
-      throw new Error(
-        `instanceOf field: illegal constructor used: ${constructor.name}`
-      );
-  }
-
-  const decoder: _FieldDecoderBaseImpl<T | null> = {
-    fieldType: "class",
-
-    init: () => null,
-
-    decode: value =>
-      value instanceof constructor ? { ok: true, value } : { ok: false, value },
-  };
-
-  return opaque(decoder as _FieldDecoderImpl<T | null>);
-};
diff --git a/src/core/decoders/number.spec.ts b/src/core/decoders/number.spec.ts
index 3f44133..cb64038 100644
--- a/src/core/decoders/number.spec.ts
+++ b/src/core/decoders/number.spec.ts
@@ -18,7 +18,9 @@ describe("number decoder", () => {
   it("should decode empty string value", () => {
     const decoder = impl(number());
 
-    expect(decoder.decode("")).toEqual({ ok: true, value: "" });
+    ["", "  ", "    "].forEach(value =>
+      expect(decoder.decode(value)).toEqual({ ok: true, value: "" })
+    );
   });
 
   it("should decode finite number values", () => {
@@ -33,15 +35,23 @@ describe("number decoder", () => {
     const decoder = impl(number());
 
     [NaN, +Infinity, -Infinity].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
+      expect(decoder.decode(value)).toEqual({ ok: false })
     );
   });
 
-  it("should NOT decode string values", () => {
+  it("should decode string values parsable into numbers", () => {
     const decoder = impl(number());
 
-    [" ", "foo", " BAR ", "🔥"].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
+    ["0", "-42", "0.5", "10000", "10e-2"].forEach(value =>
+      expect(decoder.decode(value)).toEqual({ ok: true, value: Number(value) })
+    );
+  });
+
+  it("should NOT decode malformed string values", () => {
+    const decoder = impl(number());
+
+    ["foo", "🔥", "0,5", "123foo", "10 000"].forEach(value =>
+      expect(decoder.decode(value)).toEqual({ ok: false })
     );
   });
 
@@ -49,7 +59,7 @@ describe("number decoder", () => {
     const decoder = impl(number());
 
     [true, false].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
+      expect(decoder.decode(value)).toEqual({ ok: false })
     );
   });
 
@@ -57,15 +67,29 @@ describe("number decoder", () => {
     const decoder = impl(number());
 
     [{}, { foo: "bar" }, new Error("error"), []].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
+      expect(decoder.decode(value)).toEqual({ ok: false })
     );
   });
 
+  it("should decode valid Date instances", () => {
+    const decoder = impl(number());
+    const date = new Date();
+
+    expect(decoder.decode(date)).toEqual({ ok: true, value: date.valueOf() });
+  });
+
+  it("should NOT decode invalid Date instances", () => {
+    const decoder = impl(number());
+    const date = new Date("foobar");
+
+    expect(decoder.decode(date)).toEqual({ ok: false });
+  });
+
   it("should NOT decode nullable values", () => {
     const decoder = impl(number());
 
     [null, undefined].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
+      expect(decoder.decode(value)).toEqual({ ok: false })
     );
   });
 });
diff --git a/src/core/decoders/number.ts b/src/core/decoders/number.ts
index 0072308..73f7bd1 100644
--- a/src/core/decoders/number.ts
+++ b/src/core/decoders/number.ts
@@ -1,10 +1,11 @@
+import { isValidDate } from "../../utils";
 import { FieldDecoder, _FieldDecoderImpl } from "../types/field-decoder";
 import { opaque } from "../types/type-mapper-util";
 
 /**
  * Define field of type `number | ""` (empty string is needed to represent state of empty number inputs)
- * Does not accept infinite numbers: `Infinity`, `-Infinity`, `NaN`.
  * Default initial value will be `""`.
+ * Accepts finite numbers, strings representing finite numbers and valid Date instances
  *
  * @example
  * ```
@@ -22,16 +23,26 @@ export const number = (): FieldDecoder<number | ""> => {
     decode: value => {
       switch (typeof value) {
         case "number":
-          return Number.isFinite(value)
-            ? { ok: true, value }
-            : { ok: false, value };
+          return Number.isFinite(value) ? { ok: true, value } : { ok: false };
 
         case "string": {
-          return value === "" ? { ok: true, value } : { ok: false, value };
+          if (value.trim() === "") {
+            return { ok: true, value: "" };
+          }
+
+          const numValue = Number(value);
+          return Number.isNaN(numValue)
+            ? { ok: false }
+            : { ok: true, value: numValue };
         }
 
+        case "object":
+          return isValidDate(value)
+            ? { ok: true, value: value.valueOf() }
+            : { ok: false };
+
         default:
-          return { ok: false, value };
+          return { ok: false };
       }
     },
   };
diff --git a/src/core/decoders/object.spec.ts b/src/core/decoders/object.spec.ts
index eef2767..d3e4f29 100644
--- a/src/core/decoders/object.spec.ts
+++ b/src/core/decoders/object.spec.ts
@@ -5,7 +5,7 @@ import { impl } from "../types/type-mapper-util";
 import { array } from "./array";
 import { bool } from "./bool";
 import { choice } from "./choice";
-import { instanceOf } from "./instanceof";
+import { date } from "./date";
 import { number } from "./number";
 import { object } from "./object";
 import { string } from "./string";
@@ -63,7 +63,7 @@ describe("object decoder", () => {
           str: string(),
           num: number(),
           choice: choice("A", "B"),
-          instance: instanceOf(Date),
+          date: date(),
         })
       );
 
@@ -72,7 +72,7 @@ describe("object decoder", () => {
         str: "foo",
         num: 42,
         choice: "B",
-        instance: new Date(),
+        date: new Date(),
       };
 
       expect(decoder.decode(value)).toEqual({ ok: true, value });
@@ -85,7 +85,7 @@ describe("object decoder", () => {
           str: string(),
           num: number(),
           choice: choice("A", "B"),
-          instance: instanceOf(Date),
+          date: date(),
         })
       );
 
@@ -94,10 +94,10 @@ describe("object decoder", () => {
         str: "foo",
         num: 42,
         choice: "invalid choice",
-        instance: new Date(),
+        date: new Date(),
       };
 
-      expect(decoder.decode(value)).toEqual({ ok: false, value });
+      expect(decoder.decode(value)).toEqual({ ok: false });
     });
 
     it("should NOT decode empty object", () => {
@@ -107,13 +107,13 @@ describe("object decoder", () => {
           str: string(),
           num: number(),
           choice: choice("A", "B"),
-          instance: instanceOf(Date),
+          date: date(),
         })
       );
 
       const value = {};
 
-      expect(decoder.decode(value)).toEqual({ ok: false, value });
+      expect(decoder.decode(value)).toEqual({ ok: false });
     });
 
     it("should NOT decode nulls", () => {
@@ -123,13 +123,13 @@ describe("object decoder", () => {
           str: string(),
           num: number(),
           choice: choice("A", "B"),
-          instance: instanceOf(Date),
+          date: date(),
         })
       );
 
       const value = null;
 
-      expect(decoder.decode(value)).toEqual({ ok: false, value });
+      expect(decoder.decode(value)).toEqual({ ok: false });
     });
   });
 
@@ -163,7 +163,7 @@ describe("object decoder", () => {
         obj: { arr: [false, true] },
       };
 
-      expect(decoder.decode(value)).toEqual({ ok: false, value });
+      expect(decoder.decode(value)).toEqual({ ok: false });
     });
   });
 });
diff --git a/src/core/decoders/object.ts b/src/core/decoders/object.ts
index c5cad08..340c2d0 100644
--- a/src/core/decoders/object.ts
+++ b/src/core/decoders/object.ts
@@ -14,7 +14,7 @@ type ObjectFieldDecoderWithGuards<
 
 /**
  * Define nested object field with shape defined by `innerDecoders` param.
- * Will check if value is an object and if it contains all specified properties of the right types at runtime.
+ * Accepts any objects containing all specified properties which are valid in respect to rules imposed by their respective decoders.
  *
  * **Does not accept empty objects and objects with reserved 'root' property**
  *
@@ -47,7 +47,7 @@ export const object = <O extends object>(
 
     decode: value => {
       if (typeof value !== "object" || value == null) {
-        return { ok: false, value };
+        return { ok: false };
       }
 
       const decodedObject = {} as O;
@@ -56,7 +56,7 @@ export const object = <O extends object>(
           (value as O)[key as keyof O]
         );
         if (!result.ok) {
-          return { ok: false, value };
+          return { ok: false };
         } else {
           decodedObject[key as keyof O] = result.value;
         }
diff --git a/src/core/decoders/string.spec.ts b/src/core/decoders/string.spec.ts
index b0b5f92..fa845ee 100644
--- a/src/core/decoders/string.spec.ts
+++ b/src/core/decoders/string.spec.ts
@@ -23,27 +23,54 @@ describe("string decoder", () => {
     );
   });
 
-  it("should NOT decode boolean values", () => {
+  it("should decode valid Date instance values", () => {
     const decoder = impl(string());
+    const date = new Date();
 
-    [true, false].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
+    expect(decoder.decode(date)).toEqual({
+      ok: true,
+      value: date.toISOString(),
+    });
+  });
+
+  it("should NOT decode invalid Date instance values", () => {
+    const decoder = impl(string());
+    const date = new Date("foobar");
+
+    expect(decoder.decode(date)).toEqual({ ok: false });
+  });
+
+  it("should decode finite number values", () => {
+    const decoder = impl(string());
+
+    [-100, 0, 666.666, Number.MAX_SAFE_INTEGER, Number.EPSILON].forEach(value =>
+      expect(decoder.decode(value)).toEqual({
+        ok: true,
+        value: value.toString(),
+      })
     );
   });
 
-  it("should NOT decode number values", () => {
+  it("should NOT decode infinite number values", () => {
     const decoder = impl(string());
 
-    [-100, 0, 666.666, NaN, +Infinity, -Infinity].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
+    [NaN, +Infinity, -Infinity].forEach(value =>
+      expect(decoder.decode(value)).toEqual({ ok: false })
     );
   });
 
+  it("should decode boolean values", () => {
+    const decoder = impl(string());
+
+    expect(decoder.decode(true)).toEqual({ ok: true, value: "true" });
+    expect(decoder.decode(false)).toEqual({ ok: true, value: "false" });
+  });
+
   it("should NOT decode objects", () => {
     const decoder = impl(string());
 
     [{}, { foo: "bar" }, new Error("error"), []].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
+      expect(decoder.decode(value)).toEqual({ ok: false })
     );
   });
 
@@ -51,7 +78,7 @@ describe("string decoder", () => {
     const decoder = impl(string());
 
     [null, undefined].forEach(value =>
-      expect(decoder.decode(value)).toEqual({ ok: false, value })
+      expect(decoder.decode(value)).toEqual({ ok: false })
     );
   });
 });
diff --git a/src/core/decoders/string.ts b/src/core/decoders/string.ts
index 833d474..52116b5 100644
--- a/src/core/decoders/string.ts
+++ b/src/core/decoders/string.ts
@@ -1,9 +1,11 @@
+import { isValidDate } from "../../utils";
 import { FieldDecoder, _FieldDecoderImpl } from "../types/field-decoder";
 import { opaque } from "../types/type-mapper-util";
 
 /**
  * Define field of type `string`.
  * Default initial value will be `""`.
+ * Accepts strings, numbers, booleans and valid Date instances (which are serialized using toISOString method).
  *
  * @example
  * ```
@@ -22,8 +24,22 @@ export const string = (): FieldDecoder<string> => {
       switch (typeof value) {
         case "string":
           return { ok: true, value };
+
+        case "number":
+          return Number.isFinite(value)
+            ? { ok: true, value: value.toString() }
+            : { ok: false };
+
+        case "boolean":
+          return { ok: true, value: String(value) };
+
+        case "object":
+          return isValidDate(value)
+            ? { ok: true, value: value.toISOString() }
+            : { ok: false };
+
         default:
-          return { ok: false, value };
+          return { ok: false };
       }
     },
   };
diff --git a/src/core/helpers/decode-change-event.spec.ts b/src/core/helpers/decode-change-event.spec.ts
new file mode 100644
index 0000000..e10e237
--- /dev/null
+++ b/src/core/helpers/decode-change-event.spec.ts
@@ -0,0 +1,854 @@
+import * as Decoders from "../decoders";
+import { FieldDecoder, _FieldDecoderImpl } from "../types/field-decoder";
+import { impl } from "../types/type-mapper-util";
+
+import { decodeChangeEvent } from "./decode-change-event";
+
+namespace MockEvent {
+  export const textInput = (value: string) => ({
+    target: { type: "text", value },
+  });
+  export const passwordInput = (value: string) => ({
+    target: { type: "password", value },
+  });
+
+  export const numberInput = (value: "" | number) => ({
+    target: {
+      type: "number",
+      value: value.toString(),
+      valueAsNumber: value,
+    },
+  });
+
+  export const dateInput = (date: Date) => ({
+    target: {
+      type: "date",
+      value: date.toLocaleDateString("en-CA"),
+      valueAsNumber: date.valueOf(),
+    },
+  });
+  export const dateTimeInput = (date: Date) => ({
+    target: {
+      type: "datetime",
+      value: date.toLocaleString("en-CA"),
+      valueAsNumber: date.valueOf(),
+    },
+  });
+  export const dateTimeLocalInput = (date: Date) => ({
+    target: {
+      type: "datetime-local",
+      value: date.toLocaleString("en-CA"),
+      valueAsNumber: date.valueOf(),
+    },
+  });
+  export const monthInput = (date: Date) => ({
+    target: {
+      type: "month",
+      value: date.toLocaleDateString("en-CA"),
+      valueAsNumber: date.valueOf(),
+    },
+  });
+  export const timeInput = (date: Date) => ({
+    target: {
+      type: "time",
+      value: date.toLocaleTimeString("en-CA"),
+      valueAsNumber: date.valueOf(),
+    },
+  });
+
+  export const checkboxInput = (checked: boolean, value?: string) => ({
+    target: { type: "checkbox", value, checked },
+  });
+  export const radioInput = (checked: boolean, value?: string) => ({
+    target: { type: "radio", value, checked },
+  });
+
+  export const select = (value: string) => ({
+    target: { type: "select-one", value },
+  });
+  export const multiSelect = (
+    options: Array<{ value: string; selected: boolean }>
+  ) => ({
+    target: { type: "select-multiple", options },
+  });
+
+  export const custom = <T>(value: T) => ({
+    target: { value },
+  });
+}
+
+namespace Result {
+  export const success = <T>(value: T) => ({ ok: true as const, value });
+  export const failure = () => ({ ok: false as const });
+}
+
+describe("decodeChangeEvent", () => {
+  const getEventDecoder = <T>(fieldDecoder: FieldDecoder<T>, value: T) => (
+    event: any
+  ) =>
+    decodeChangeEvent({
+      fieldDecoder: impl(fieldDecoder),
+      getValue: () => value,
+      event,
+    });
+
+  describe("from text-like inputs", () => {
+    it("decodes matching events for string field", () => {
+      const decode = getEventDecoder(Decoders.string(), "");
+
+      expect(decode(MockEvent.textInput(""))).toEqual(Result.success(""));
+      expect(decode(MockEvent.textInput("foo"))).toEqual(Result.success("foo"));
+      expect(decode(MockEvent.textInput("42"))).toEqual(Result.success("42"));
+      expect(decode(MockEvent.passwordInput("bar"))).toEqual(
+        Result.success("bar")
+      );
+    });
+
+    it("decodes matching events for number field", () => {
+      const decode = getEventDecoder(Decoders.number(), 0);
+
+      expect(decode(MockEvent.textInput("foo"))).toEqual(Result.failure());
+
+      expect(decode(MockEvent.textInput(""))).toEqual(Result.success(""));
+      expect(decode(MockEvent.textInput("42"))).toEqual(Result.success(42));
+      expect(decode(MockEvent.textInput("10e-3"))).toEqual(
+        Result.success(0.01)
+      );
+    });
+
+    it("decodes matching events for choice field", () => {
+      const decode = getEventDecoder(Decoders.choice("A", "BB"), "A");
+
+      expect(decode(MockEvent.textInput(""))).toEqual(Result.failure());
+      expect(decode(MockEvent.textInput("a"))).toEqual(Result.failure());
+      expect(decode(MockEvent.textInput("B"))).toEqual(Result.failure());
+
+      expect(decode(MockEvent.textInput("A"))).toEqual(Result.success("A"));
+      expect(decode(MockEvent.textInput("BB"))).toEqual(Result.success("BB"));
+    });
+
+    it("decodes matching events for bool field", () => {
+      const decode = getEventDecoder(Decoders.bool(), true);
+
+      expect(decode(MockEvent.textInput(""))).toEqual(Result.failure());
+      expect(decode(MockEvent.textInput("foo"))).toEqual(Result.failure());
+      expect(decode(MockEvent.textInput("0"))).toEqual(Result.failure());
+      expect(decode(MockEvent.textInput("1"))).toEqual(Result.failure());
+
+      expect(decode(MockEvent.textInput("true"))).toEqual(Result.success(true));
+      expect(decode(MockEvent.textInput("false"))).toEqual(
+        Result.success(false)
+      );
+      expect(decode(MockEvent.textInput("TRUE"))).toEqual(Result.success(true));
+      expect(decode(MockEvent.textInput("FALSE"))).toEqual(
+        Result.success(false)
+      );
+      expect(decode(MockEvent.textInput("True"))).toEqual(Result.success(true));
+      expect(decode(MockEvent.textInput("False"))).toEqual(
+        Result.success(false)
+      );
+    });
+
+    it("fails decoding events for array field", () => {
+      const decode = getEventDecoder(Decoders.array(Decoders.string()), []);
+
+      expect(decode(MockEvent.textInput(""))).toEqual(Result.failure());
+      expect(decode(MockEvent.textInput("foo"))).toEqual(Result.failure());
+      expect(decode(MockEvent.textInput("a,b,c"))).toEqual(Result.failure());
+      expect(decode(MockEvent.textInput("[a,b,c]"))).toEqual(Result.failure());
+    });
+
+    it("fails decoding events for object field", () => {
+      const decode = getEventDecoder(
+        Decoders.object({ foo: Decoders.string() }),
+        { foo: "" }
+      );
+
+      expect(decode(MockEvent.textInput(""))).toEqual(Result.failure());
+      expect(decode(MockEvent.textInput("foo"))).toEqual(Result.failure());
+      expect(decode(MockEvent.textInput('{ foo: "" }'))).toEqual(
+        Result.failure()
+      );
+    });
+
+    it("decodes matching events for Date field", () => {
+      const decode = getEventDecoder(Decoders.date(), null);
+
+      expect(decode(MockEvent.textInput(""))).toEqual(Result.failure());
+      expect(decode(MockEvent.textInput("foo"))).toEqual(Result.failure());
+      expect(decode(MockEvent.textInput("12:00"))).toEqual(Result.failure());
+      expect(decode(MockEvent.textInput("1609290817207"))).toEqual(
+        Result.failure()
+      );
+      expect(decode(MockEvent.textInput("12:00"))).toEqual(Result.failure());
+
+      expect(decode(MockEvent.textInput("2020-12-24"))).toEqual(
+        Result.success(new Date("2020-12-24"))
+      );
+      expect(decode(MockEvent.textInput("2020-12-24T10:00"))).toEqual(
+        Result.success(new Date("2020-12-24T10:00"))
+      );
+      expect(decode(MockEvent.textInput("2020-12-24T12:00:00.000Z"))).toEqual(
+        Result.success(new Date("2020-12-24T12:00:00.000Z"))
+      );
+    });
+  });
+
+  describe("from number inputs", () => {
+    it("decodes matching events for string field", () => {
+      const decode = getEventDecoder(Decoders.string(), "");
+
+      expect(decode(MockEvent.numberInput(""))).toEqual(Result.success(""));
+      expect(decode(MockEvent.numberInput(42))).toEqual(Result.success("42"));
+      expect(decode(MockEvent.numberInput(-0.1))).toEqual(
+        Result.success("-0.1")
+      );
+    });
+
+    it("decodes matching events for number field", () => {
+      const decode = getEventDecoder(Decoders.number(), 0);
+
+      expect(decode(MockEvent.numberInput(""))).toEqual(Result.success(""));
+      expect(decode(MockEvent.numberInput(42))).toEqual(Result.success(42));
+      expect(decode(MockEvent.numberInput(-0.1))).toEqual(Result.success(-0.1));
+    });
+
+    it("decodes matching events for choice field", () => {
+      const decode = getEventDecoder(Decoders.choice("1", "2"), "1");
+
+      expect(decode(MockEvent.numberInput(1))).toEqual(Result.success("1"));
+      expect(decode(MockEvent.numberInput(2))).toEqual(Result.success("2"));
+
+      expect(decode(MockEvent.numberInput(""))).toEqual(Result.failure());
+      expect(decode(MockEvent.numberInput(42))).toEqual(Result.failure());
+    });
+
+    it("fails decoding events for bool field", () => {
+      const decode = getEventDecoder(Decoders.bool(), null);
+
+      expect(decode(MockEvent.numberInput(""))).toEqual(Result.failure());
+      expect(decode(MockEvent.numberInput(0))).toEqual(Result.failure());
+      expect(decode(MockEvent.numberInput(1))).toEqual(Result.failure());
+      expect(decode(MockEvent.numberInput(1609290817207))).toEqual(
+        Result.failure()
+      );
+    });
+
+    it("fails decoding events for array field", () => {
+      const decode = getEventDecoder(Decoders.array(Decoders.number()), []);
+
+      expect(decode(MockEvent.numberInput(""))).toEqual(Result.failure());
+      expect(decode(MockEvent.numberInput(42))).toEqual(Result.failure());
+    });
+
+    it("fails decoding events for object field", () => {
+      const decode = getEventDecoder(
+        Decoders.object({ foo: Decoders.number() }),
+        { foo: 1 }
+      );
+
+      expect(decode(MockEvent.numberInput(""))).toEqual(Result.failure());
+      expect(decode(MockEvent.numberInput(42))).toEqual(Result.failure());
+    });
+
+    it("fails decoding events for Date field", () => {
+      const decode = getEventDecoder(Decoders.date(), null);
+
+      expect(decode(MockEvent.numberInput(""))).toEqual(Result.failure());
+      expect(decode(MockEvent.numberInput(1609290817207))).toEqual(
+        Result.failure()
+      );
+    });
+  });
+
+  describe("from date-like inputs", () => {
+    it("decodes matching events for string field", () => {
+      const decode = getEventDecoder(Decoders.string(), "");
+      const someDate = new Date();
+
+      {
+        const event = MockEvent.dateInput(someDate);
+        expect(decode(event)).toEqual(Result.success(event.target.value));
+      }
+      {
+        const event = MockEvent.dateTimeInput(someDate);
+        expect(decode(event)).toEqual(Result.success(event.target.value));
+      }
+      {
+        const event = MockEvent.dateTimeLocalInput(someDate);
+        expect(decode(event)).toEqual(Result.success(event.target.value));
+      }
+      {
+        const event = MockEvent.monthInput(someDate);
+        expect(decode(event)).toEqual(Result.success(event.target.value));
+      }
+      {
+        const event = MockEvent.timeInput(someDate);
+        expect(decode(event)).toEqual(Result.success(event.target.value));
+      }
+    });
+
+    it("decodes matching events for number field", () => {
+      const decode = getEventDecoder(Decoders.number(), 0);
+      const someDate = new Date();
+
+      expect(decode(MockEvent.dateInput(someDate))).toEqual(
+        Result.success(someDate.valueOf())
+      );
+      expect(decode(MockEvent.dateTimeInput(someDate))).toEqual(
+        Result.success(someDate.valueOf())
+      );
+      expect(decode(MockEvent.dateTimeLocalInput(someDate))).toEqual(
+        Result.success(someDate.valueOf())
+      );
+      expect(decode(MockEvent.monthInput(someDate))).toEqual(
+        Result.success(someDate.valueOf())
+      );
+      expect(decode(MockEvent.timeInput(someDate))).toEqual(
+        Result.success(someDate.valueOf())
+      );
+    });
+
+    it("fails decoding events for choice field", () => {
+      const decode = getEventDecoder(Decoders.choice("A", "B"), "A");
+
+      const event = MockEvent.dateInput(new Date());
+      expect(decode(event)).toEqual(Result.failure());
+    });
+
+    it("fails decoding events for bool field", () => {
+      const decode = getEventDecoder(Decoders.bool(), false);
+
+      const event = MockEvent.dateInput(new Date());
+      expect(decode(event)).toEqual(Result.failure());
+    });
+
+    it("fails decoding events for array field", () => {
+      const decode = getEventDecoder(Decoders.array(Decoders.string()), []);
+
+      const event = MockEvent.dateInput(new Date());
+      expect(decode(event)).toEqual(Result.failure());
+    });
+
+    it("fails decoding events for object field", () => {
+      const decode = getEventDecoder(
+        Decoders.object({ foo: Decoders.string() }),
+        { foo: "" }
+      );
+
+      const event = MockEvent.dateInput(new Date());
+      expect(decode(event)).toEqual(Result.failure());
+    });
+
+    it("decodes matching events for Date field", () => {
+      const decode = getEventDecoder(Decoders.date(), null);
+      const someDate = new Date();
+
+      expect(decode(MockEvent.dateInput(someDate))).toEqual(
+        Result.success(someDate)
+      );
+      expect(decode(MockEvent.dateTimeInput(someDate))).toEqual(
+        Result.success(someDate)
+      );
+      expect(decode(MockEvent.dateTimeLocalInput(someDate))).toEqual(
+        Result.success(someDate)
+      );
+      expect(decode(MockEvent.monthInput(someDate))).toEqual(
+        Result.success(someDate)
+      );
+      expect(decode(MockEvent.timeInput(someDate))).toEqual(
+        Result.success(someDate)
+      );
+    });
+  });
+
+  describe("from checkbox inputs", () => {
+    it("fails decoding events for string field", () => {
+      const decode = getEventDecoder(Decoders.string(), "");
+
+      expect(decode(MockEvent.checkboxInput(true, "foo"))).toEqual(
+        Result.failure()
+      );
+    });
+
+    it("fails decoding events for number field", () => {
+      const decode = getEventDecoder(Decoders.number(), 0);
+
+      expect(decode(MockEvent.checkboxInput(true, "42"))).toEqual(
+        Result.failure()
+      );
+    });
+
+    it("fails decoding events for choice field", () => {
+      const decode = getEventDecoder(Decoders.choice("A", "B"), "A");
+
+      expect(decode(MockEvent.checkboxInput(true, "A"))).toEqual(
+        Result.failure()
+      );
+    });
+
+    it("decodes matching events for bool field", () => {
+      const decode = getEventDecoder(Decoders.bool(), false);
+
+      expect(decode(MockEvent.checkboxInput(true, "foo"))).toEqual(
+        Result.success(true)
+      );
+      expect(decode(MockEvent.checkboxInput(false, "foo"))).toEqual(
+        Result.success(false)
+      );
+    });
+
+    it("decodes matching events for array field", () => {
+      const decode = getEventDecoder(
+        Decoders.array(Decoders.choice("A", "B", "C")),
+        ["A", "B"]
+      );
+
+      expect(decode(MockEvent.checkboxInput(false, "A"))).toEqual(
+        Result.success(["B"])
+      );
+      expect(decode(MockEvent.checkboxInput(true, "C"))).toEqual(
+        Result.success(["A", "B", "C"])
+      );
+      expect(decode(MockEvent.checkboxInput(true, "D"))).toEqual(
+        Result.failure()
+      );
+    });
+
+    it("fails decoding events for object field", () => {
+      const decode = getEventDecoder(Decoders.object({ A: Decoders.bool() }), {
+        A: false,
+      });
+
+      expect(decode(MockEvent.checkboxInput(true, "A"))).toEqual(
+        Result.failure()
+      );
+    });
+
+    it("fails decoding events for Date field", () => {
+      const decode = getEventDecoder(Decoders.date(), null);
+
+      expect(decode(MockEvent.checkboxInput(true, "foo"))).toEqual(
+        Result.failure()
+      );
+    });
+  });
+
+  describe("from radio inputs", () => {
+    it("decodes matching events for string field", () => {
+      const decode = getEventDecoder(Decoders.string(), "");
+
+      expect(decode(MockEvent.radioInput(true, ""))).toEqual(
+        Result.success("")
+      );
+      expect(decode(MockEvent.radioInput(false, ""))).toEqual(Result.failure());
+      expect(decode(MockEvent.radioInput(true, "foo"))).toEqual(
+        Result.success("foo")
+      );
+      expect(decode(MockEvent.radioInput(false, "foo"))).toEqual(
+        Result.failure()
+      );
+    });
+
+    it("decodes matching events for number field", () => {
+      const decode = getEventDecoder(Decoders.number(), 0);
+
+      expect(decode(MockEvent.radioInput(true, ""))).toEqual(
+        Result.success("")
+      );
+      expect(decode(MockEvent.radioInput(false, ""))).toEqual(Result.failure());
+      expect(decode(MockEvent.radioInput(true, "foo"))).toEqual(
+        Result.failure()
+      );
+      expect(decode(MockEvent.radioInput(false, "foo"))).toEqual(
+        Result.failure()
+      );
+      expect(decode(MockEvent.radioInput(true, "42"))).toEqual(
+        Result.success(42)
+      );
+      expect(decode(MockEvent.radioInput(false, "42"))).toEqual(
+        Result.failure()
+      );
+    });
+
+    it("decodes matching events for choice field", () => {
+      const decode = getEventDecoder(Decoders.choice("A", "B"), "A");
+
+      expect(decode(MockEvent.radioInput(true, ""))).toEqual(Result.failure());
+      expect(decode(MockEvent.radioInput(false, ""))).toEqual(Result.failure());
+      expect(decode(MockEvent.radioInput(true, "A"))).toEqual(
+        Result.success("A")
+      );
+      expect(decode(MockEvent.radioInput(false, "A"))).toEqual(
+        Result.failure()
+      );
+    });
+
+    it("decodes matching events for bool field", () => {
+      const decode = getEventDecoder(Decoders.bool(), false);
+
+      expect(decode(MockEvent.radioInput(true, ""))).toEqual(Result.failure());
+      expect(decode(MockEvent.radioInput(false, ""))).toEqual(Result.failure());
+      expect(decode(MockEvent.radioInput(true, "true"))).toEqual(
+        Result.success(true)
+      );
+      expect(decode(MockEvent.radioInput(false, "true"))).toEqual(
+        Result.failure()
+      );
+      expect(decode(MockEvent.radioInput(true, "false"))).toEqual(
+        Result.success(false)
+      );
+      expect(decode(MockEvent.radioInput(false, "false"))).toEqual(
+        Result.failure()
+      );
+    });
+
+    it("fails decoding events for array field", () => {
+      const decode = getEventDecoder(Decoders.array(Decoders.string()), []);
+
+      expect(decode(MockEvent.radioInput(true, "foo"))).toEqual(
+        Result.failure()
+      );
+      expect(decode(MockEvent.radioInput(false, "foo"))).toEqual(
+        Result.failure()
+      );
+      expect(decode(MockEvent.radioInput(true, '["foo"]'))).toEqual(
+        Result.failure()
+      );
+      expect(decode(MockEvent.radioInput(false, '["foo"]'))).toEqual(
+        Result.failure()
+      );
+    });
+
+    it("fails decoding events for object field", () => {
+      const decode = getEventDecoder(
+        Decoders.object({ foo: Decoders.string() }),
+        { foo: "" }
+      );
+
+      expect(decode(MockEvent.radioInput(true, "foo"))).toEqual(
+        Result.failure()
+      );
+      expect(decode(MockEvent.radioInput(false, "foo"))).toEqual(
+        Result.failure()
+      );
+      expect(decode(MockEvent.radioInput(true, '{ foo: "" }'))).toEqual(
+        Result.failure()
+      );
+      expect(decode(MockEvent.radioInput(false, '{ foo: "" }'))).toEqual(
+        Result.failure()
+      );
+    });
+
+    it("decodes matching events for Date field", () => {
+      const decode = getEventDecoder(Decoders.date(), null);
+      const someDate = new Date();
+
+      expect(decode(MockEvent.radioInput(true, "foo"))).toEqual(
+        Result.failure()
+      );
+      expect(decode(MockEvent.radioInput(false, "foo"))).toEqual(
+        Result.failure()
+      );
+      expect(
+        decode(MockEvent.radioInput(true, someDate.toISOString()))
+      ).toEqual(Result.success(someDate));
+      expect(
+        decode(MockEvent.radioInput(false, someDate.toISOString()))
+      ).toEqual(Result.failure());
+    });
+  });
+
+  describe("from single-select inputs", () => {
+    it("decodes matching events for string field", () => {
+      const decode = getEventDecoder(Decoders.string(), "");
+
+      expect(decode(MockEvent.select(""))).toEqual(Result.success(""));
+      expect(decode(MockEvent.select("foo"))).toEqual(Result.success("foo"));
+    });
+
+    it("decodes matching events for number field", () => {
+      const decode = getEventDecoder(Decoders.number(), 0);
+
+      expect(decode(MockEvent.select(""))).toEqual(Result.success(""));
+      expect(decode(MockEvent.select("foo"))).toEqual(Result.failure());
+      expect(decode(MockEvent.select("42"))).toEqual(Result.success(42));
+    });
+
+    it("decodes matching events for choice field", () => {
+      const decode = getEventDecoder(Decoders.choice("A", "B"), "A");
+
+      expect(decode(MockEvent.select(""))).toEqual(Result.failure());
+      expect(decode(MockEvent.select("A"))).toEqual(Result.success("A"));
+      expect(decode(MockEvent.select("B"))).toEqual(Result.success("B"));
+      expect(decode(MockEvent.select("C"))).toEqual(Result.failure());
+    });
+
+    it("decodes matching events for bool field", () => {
+      const decode = getEventDecoder(Decoders.bool(), false);
+
+      expect(decode(MockEvent.select(""))).toEqual(Result.failure());
+      expect(decode(MockEvent.select("true"))).toEqual(Result.success(true));
+      expect(decode(MockEvent.select("false"))).toEqual(Result.success(false));
+    });
+
+    it("fails decoding events for array field", () => {
+      const decode = getEventDecoder(Decoders.array(Decoders.string()), []);
+
+      expect(decode(MockEvent.select("foo"))).toEqual(Result.failure());
+      expect(decode(MockEvent.select('["foo"]'))).toEqual(Result.failure());
+    });
+
+    it("fails decoding events for object field", () => {
+      const decode = getEventDecoder(
+        Decoders.object({ foo: Decoders.string() }),
+        { foo: "" }
+      );
+
+      expect(decode(MockEvent.select("foo"))).toEqual(Result.failure());
+      expect(decode(MockEvent.select('{ foo: "" }'))).toEqual(Result.failure());
+    });
+
+    it("decodes matching events for Date field", () => {
+      const decode = getEventDecoder(Decoders.date(), null);
+      const someDate = new Date();
+
+      expect(decode(MockEvent.select("foo"))).toEqual(Result.failure());
+      expect(decode(MockEvent.select(someDate.toISOString()))).toEqual(
+        Result.success(someDate)
+      );
+    });
+  });
+
+  describe("from multi-select inputs", () => {
+    it("fails decoding events for string field", () => {
+      const decode = getEventDecoder(Decoders.string(), "");
+
+      expect(
+        decode(MockEvent.multiSelect([{ selected: true, value: "foo" }]))
+      ).toEqual(Result.failure());
+    });
+
+    it("fails decoding events for number field", () => {
+      const decode = getEventDecoder(Decoders.number(), 0);
+
+      expect(
+        decode(MockEvent.multiSelect([{ selected: true, value: "42" }]))
+      ).toEqual(Result.failure());
+    });
+
+    it("fails decoding events for choice field", () => {
+      const decode = getEventDecoder(Decoders.choice("A", "B"), "A");
+
+      expect(
+        decode(MockEvent.multiSelect([{ selected: true, value: "A" }]))
+      ).toEqual(Result.failure());
+    });
+
+    it("fails decoding events for bool field", () => {
+      const decode = getEventDecoder(Decoders.bool(), false);
+
+      expect(
+        decode(MockEvent.multiSelect([{ selected: true, value: "true" }]))
+      ).toEqual(Result.failure());
+    });
+
+    it("decodes matching events for array field", () => {
+      const decode = getEventDecoder(
+        Decoders.array(Decoders.choice("A", "B", "C")),
+        []
+      );
+
+      expect(
+        decode(
+          MockEvent.multiSelect([
+            { selected: false, value: "A" },
+            { selected: false, value: "B" },
+          ])
+        )
+      ).toEqual(Result.success([]));
+
+      expect(
+        decode(
+          MockEvent.multiSelect([
+            { selected: true, value: "A" },
+            { selected: false, value: "B" },
+          ])
+        )
+      ).toEqual(Result.success(["A"]));
+
+      expect(
+        decode(
+          MockEvent.multiSelect([
+            { selected: true, value: "A" },
+            { selected: false, value: "B" },
+            { selected: true, value: "D" },
+          ])
+        )
+      ).toEqual(Result.failure());
+    });
+
+    it("fails decoding events for object field", () => {
+      const decode = getEventDecoder(
+        Decoders.object({ foo: Decoders.bool() }),
+        { foo: false }
+      );
+
+      expect(
+        decode(MockEvent.multiSelect([{ selected: true, value: "foo" }]))
+      ).toEqual(Result.failure());
+    });
+
+    it("fails decoding events for Date field", () => {
+      const decode = getEventDecoder(Decoders.date(), null);
+
+      expect(
+        decode(
+          MockEvent.multiSelect([
+            { selected: true, value: new Date().toISOString() },
+          ])
+        )
+      ).toEqual(Result.failure());
+    });
+  });
+
+  describe("from artificial source", () => {
+    it("decodes matching events for string field", () => {
+      const decode = getEventDecoder(Decoders.string(), "");
+      const someDate = new Date();
+
+      expect(decode(MockEvent.custom(""))).toEqual(Result.success(""));
+      expect(decode(MockEvent.custom("foo"))).toEqual(Result.success("foo"));
+      expect(decode(MockEvent.custom("42"))).toEqual(Result.success("42"));
+      expect(decode(MockEvent.custom(42))).toEqual(Result.success("42"));
+      expect(decode(MockEvent.custom(someDate))).toEqual(
+        Result.success(someDate.toISOString())
+      );
+      expect(decode(MockEvent.custom(true))).toEqual(Result.success("true"));
+      expect(decode(MockEvent.custom(false))).toEqual(Result.success("false"));
+
+      expect(decode(MockEvent.custom({ foo: "bar" }))).toEqual(
+        Result.failure()
+      );
+      expect(decode(MockEvent.custom(["a", "b"]))).toEqual(Result.failure());
+      expect(decode(MockEvent.custom(undefined))).toEqual(Result.failure());
+    });
+
+    it("decodes matching events for number field", () => {
+      const decode = getEventDecoder(Decoders.number(), 0);
+      const someDate = new Date();
+
+      expect(decode(MockEvent.custom(""))).toEqual(Result.success(""));
+      expect(decode(MockEvent.custom("foo"))).toEqual(Result.failure());
+      expect(decode(MockEvent.custom("42"))).toEqual(Result.success(42));
+      expect(decode(MockEvent.custom("10e-3"))).toEqual(Result.success(0.01));
+      expect(decode(MockEvent.custom(someDate))).toEqual(
+        Result.success(someDate.valueOf())
+      );
+      expect(decode(MockEvent.custom(true))).toEqual(Result.failure());
+      expect(decode(MockEvent.custom([1, 2]))).toEqual(Result.failure());
+      expect(decode(MockEvent.custom({ 1: 2 }))).toEqual(Result.failure());
+      expect(decode(MockEvent.custom(undefined))).toEqual(Result.failure());
+    });
+
+    it("decodes matching events for choice field", () => {
+      const decode = getEventDecoder(Decoders.choice("AA", "10"), "AA");
+
+      expect(decode(MockEvent.custom(""))).toEqual(Result.failure());
+      expect(decode(MockEvent.custom("A"))).toEqual(Result.failure());
+      expect(decode(MockEvent.custom("AA"))).toEqual(Result.success("AA"));
+      expect(decode(MockEvent.custom("AAA"))).toEqual(Result.failure());
+      expect(decode(MockEvent.custom(1))).toEqual(Result.failure());
+      expect(decode(MockEvent.custom(10))).toEqual(Result.success("10"));
+    });
+
+    it("decodes matching events for bool field", () => {
+      const decode = getEventDecoder(Decoders.bool(), false);
+
+      expect(decode(MockEvent.custom(""))).toEqual(Result.failure());
+      expect(decode(MockEvent.custom("true"))).toEqual(Result.success(true));
+      expect(decode(MockEvent.custom("false"))).toEqual(Result.success(false));
+      expect(decode(MockEvent.custom("True"))).toEqual(Result.success(true));
+      expect(decode(MockEvent.custom("False"))).toEqual(Result.success(false));
+      expect(decode(MockEvent.custom(true))).toEqual(Result.success(true));
+      expect(decode(MockEvent.custom(false))).toEqual(Result.success(false));
+      expect(decode(MockEvent.custom(1))).toEqual(Result.failure());
+      expect(decode(MockEvent.custom(0))).toEqual(Result.failure());
+    });
+
+    it("decodes matching events for object field", () => {
+      const decode = getEventDecoder(
+        Decoders.object({ foo: Decoders.object({ bar: Decoders.number() }) }),
+        { foo: { bar: 0 } }
+      );
+
+      expect(decode(MockEvent.custom({ foo: { bar: 42 } }))).toEqual(
+        Result.success({ foo: { bar: 42 } })
+      );
+      expect(
+        decode(MockEvent.custom({ foo: { bar: 42 }, foo2: "bar2" }))
+      ).toEqual(Result.success({ foo: { bar: 42 } }));
+      expect(decode(MockEvent.custom({ foo: { bar: "42" } }))).toEqual(
+        Result.success({ foo: { bar: 42 } })
+      );
+      expect(
+        decode(MockEvent.custom(JSON.stringify({ foo: { bar: 42 } })))
+      ).toEqual(Result.failure());
+      expect(decode(MockEvent.custom({ foo: { bar: undefined } }))).toEqual(
+        Result.failure()
+      );
+    });
+
+    it("decodes matching events for array field", () => {
+      const decode = getEventDecoder(Decoders.array(Decoders.number()), []);
+
+      expect(decode(MockEvent.custom([]))).toEqual(Result.success([]));
+      expect(decode(MockEvent.custom([1, 2, 3]))).toEqual(
+        Result.success([1, 2, 3])
+      );
+      expect(decode(MockEvent.custom(["1", "2", "3"]))).toEqual(
+        Result.success([1, 2, 3])
+      );
+      expect(decode(MockEvent.custom([1, 2, "3"]))).toEqual(
+        Result.success([1, 2, 3])
+      );
+      expect(decode(MockEvent.custom([1, 2, "c"]))).toEqual(Result.failure());
+      expect(decode(MockEvent.custom(JSON.stringify([1, 2, 3])))).toEqual(
+        Result.failure()
+      );
+    });
+
+    it("decodes matching events for date field", () => {
+      const decode = getEventDecoder(Decoders.date(), null);
+      const validDate = new Date();
+      const invalidDate = new Date("foobar");
+
+      expect(decode(MockEvent.custom(validDate))).toEqual(
+        Result.success(validDate)
+      );
+      expect(decode(MockEvent.custom(validDate.toISOString()))).toEqual(
+        Result.success(new Date(validDate.toISOString()))
+      );
+      expect(decode(MockEvent.custom(validDate.toLocaleString()))).toEqual(
+        Result.success(new Date(validDate.toLocaleString()))
+      );
+      expect(decode(MockEvent.custom(validDate.valueOf()))).toEqual(
+        Result.success(validDate)
+      );
+
+      expect(decode(MockEvent.custom(invalidDate))).toEqual(Result.failure());
+      expect(
+        decode(MockEvent.custom(validDate.toISOString() + "foobar"))
+      ).toEqual(Result.failure());
+      expect(decode(MockEvent.custom(invalidDate.valueOf()))).toEqual(
+        Result.failure()
+      );
+    });
+  });
+
+  it("fails decoding when event.target is missing", () => {
+    const decode = getEventDecoder(Decoders.string(), "");
+
+    expect(decode({})).toEqual(Result.failure());
+  });
+});
diff --git a/src/core/helpers/decode-change-event.ts b/src/core/helpers/decode-change-event.ts
new file mode 100644
index 0000000..d9cba20
--- /dev/null
+++ b/src/core/helpers/decode-change-event.ts
@@ -0,0 +1,140 @@
+import { ChangeEvent } from "react";
+
+import {
+  _FieldDecoderImpl,
+  DecoderResult,
+  _ArrayFieldDecoderImpl,
+  isArrayDecoder,
+} from "../types/field-decoder";
+
+enum HtmlInputTypes {
+  Radio = "radio",
+  Checkbox = "checkbox",
+
+  SelectOne = "select-one",
+  SelectMultiple = "select-multiple",
+
+  Date = "date",
+  DateTimeLocal = "datetime-local",
+  DateTime = "datetime",
+  Month = "month",
+  Time = "time",
+}
+
+type SimplifiedEventTarget = {
+  type: string;
+  value: unknown;
+  checked?: boolean;
+  valueAsNumber?: number;
+  options?: Array<{ selected: boolean; value: unknown }>;
+};
+
+type Input<T> = {
+  fieldDecoder: _FieldDecoderImpl<T>;
+  getValue: () => T;
+  event: ChangeEvent<unknown>;
+};
+
+export const decodeChangeEvent = <T>({
+  fieldDecoder,
+  getValue,
+  event,
+}: Input<T>): DecoderResult<T> => {
+  const target = parseEventTarget(event);
+
+  if (!target) {
+    return { ok: false };
+  }
+
+  switch (target.type) {
+    case HtmlInputTypes.Radio:
+      return target.checked ? fieldDecoder.decode(target.value) : { ok: false };
+
+    case HtmlInputTypes.Checkbox:
+      switch (fieldDecoder.fieldType) {
+        case "bool":
+          return fieldDecoder.decode(target.checked);
+        case "array": {
+          return fieldDecoder.decode(
+            resolveCheckboxArrayValue(target, fieldDecoder, getValue() as any)
+          );
+        }
+
+        default:
+          return { ok: false };
+      }
+
+    case HtmlInputTypes.SelectMultiple: {
+      switch (fieldDecoder.fieldType) {
+        case "array": {
+          return fieldDecoder.decode(
+            target.options?.filter(opt => opt.selected).map(opt => opt.value)
+          );
+        }
+
+        default:
+          return { ok: false };
+      }
+    }
+
+    case HtmlInputTypes.Date:
+    case HtmlInputTypes.DateTimeLocal:
+    case HtmlInputTypes.DateTime:
+    case HtmlInputTypes.Month:
+    case HtmlInputTypes.Time:
+      switch (fieldDecoder.fieldType) {
+        case "date":
+        case "number":
+          return fieldDecoder.decode(target.valueAsNumber);
+        default:
+          return fieldDecoder.decode(target.value);
+      }
+
+    default:
+      return fieldDecoder.decode(target.value);
+  }
+};
+
+const parseEventTarget = (
+  event?: ChangeEvent<any>
+): SimplifiedEventTarget | null =>
+  event?.target
+    ? {
+        type: event.target.type ?? "",
+        value: event.target.value,
+        checked: event.target.checked,
+        valueAsNumber: event.target.valueAsNumber,
+        options: event.target.options
+          ? parseSelectOptions(event.target.options)
+          : undefined,
+      }
+    : null;
+
+const parseSelectOptions = (options: HTMLOptionsCollection) =>
+  Array.from(options).map(it => ({
+    selected: it.selected,
+    value: it.value,
+  }));
+
+const resolveCheckboxArrayValue = <T>(
+  target: SimplifiedEventTarget,
+  decoder: _FieldDecoderImpl<unknown>,
+  currentValue: T[]
+): T[] | null => {
+  if (!isArrayDecoder(decoder)) {
+    return null;
+  }
+
+  const elementResult = decoder.inner.decode(target.value);
+
+  if (!elementResult.ok) {
+    return null;
+  }
+  const element = elementResult.value as T;
+
+  if (target.checked) {
+    return [...currentValue, element];
+  } else {
+    return currentValue.filter(it => it !== element);
+  }
+};
diff --git a/src/core/helpers/index.ts b/src/core/helpers/index.ts
index 6b93cdd..33e4163 100644
--- a/src/core/helpers/index.ts
+++ b/src/core/helpers/index.ts
@@ -1,4 +1,5 @@
 export * from "./create-initial-values";
+export * from "./decode-change-event";
 export * from "./make-touched-values";
 export * from "./make-validation-handlers";
 export * from "./resolve-is-valid";
diff --git a/src/core/helpers/make-touched-values.spec.ts b/src/core/helpers/make-touched-values.spec.ts
index ab150e3..d1335ec 100644
--- a/src/core/helpers/make-touched-values.spec.ts
+++ b/src/core/helpers/make-touched-values.spec.ts
@@ -51,7 +51,7 @@ describe("makeTouchedValues", () => {
     });
   });
 
-  it("should work for instance values", () => {
+  it("should work for date values", () => {
     const values = {
       empty: null as Date | null,
       instance: new Date() as Date | null,
@@ -145,7 +145,7 @@ describe("makeUntouchedValues", () => {
     });
   });
 
-  it("should work for instance values", () => {
+  it("should work for date values", () => {
     const values = {
       empty: null as Date | null,
       instance: new Date() as Date | null,
diff --git a/src/core/hooks/hooks.spec.tsx b/src/core/hooks/hooks.spec.tsx
index 5cad078..14efd58 100644
--- a/src/core/hooks/hooks.spec.tsx
+++ b/src/core/hooks/hooks.spec.tsx
@@ -16,7 +16,7 @@ const Schema = createFormSchema(
     theChoice: fields.choice("", "A", "B", "C"),
     theNum: fields.number(),
     theBool: fields.bool(),
-    theInstance: fields.instanceOf(Date),
+    theDate: fields.date(),
     theArray: fields.array(fields.string()),
     theObject: fields.object({
       foo: fields.string(),
@@ -67,7 +67,7 @@ describe("formts hooks API", () => {
         theChoice: "",
         theNum: "",
         theBool: false,
-        theInstance: null,
+        theDate: null,
         theArray: [],
         theObject: { foo: "" },
         theObjectArray: { arr: [] },
@@ -151,7 +151,7 @@ describe("formts hooks API", () => {
         theChoice: "",
         theNum: "",
         theBool: false,
-        theInstance: null,
+        theDate: null,
         theArray: [],
         theObject: { foo: "" },
         theObjectArray: { arr: [] },
@@ -210,7 +210,7 @@ describe("formts hooks API", () => {
       theChoice: "",
       theNum: "",
       theBool: false,
-      theInstance: null,
+      theDate: null,
       theArray: [],
       theObject: { foo: "" },
       theObjectArray: { arr: [] },
@@ -240,7 +240,7 @@ describe("formts hooks API", () => {
       theChoice: "C",
       theNum: 42,
       theBool: false,
-      theInstance: null,
+      theDate: null,
       theArray: ["here", "comes", "the", "sun"],
       theObject: { foo: "bar" },
       theObjectArray: { arr: [] },
@@ -346,7 +346,7 @@ describe("formts hooks API", () => {
         theChoice: "",
         theNum: "",
         theBool: false,
-        theInstance: null,
+        theDate: null,
         theArray: [],
         theObject: { foo: "" },
         theObjectArray: { arr: [] },
@@ -374,7 +374,7 @@ describe("formts hooks API", () => {
         theChoice: "",
         theNum: 42,
         theBool: false,
-        theInstance: null,
+        theDate: null,
         theArray: [],
         theObject: { foo: "" },
         theObjectArray: { arr: [] },
@@ -405,7 +405,7 @@ describe("formts hooks API", () => {
         theChoice: "",
         theNum: 42,
         theBool: false,
-        theInstance: null,
+        theDate: null,
         theArray: ["gumisie", "teletubisie"],
         theObject: { foo: "" },
         theObjectArray: { arr: [] },
@@ -433,7 +433,7 @@ describe("formts hooks API", () => {
         theChoice: "",
         theNum: 42,
         theBool: false,
-        theInstance: null,
+        theDate: null,
         theArray: ["gumisie", "teletubisie"],
         theObject: { foo: "42" },
         theObjectArray: { arr: [] },
@@ -450,6 +450,32 @@ describe("formts hooks API", () => {
     }
   });
 
+  it("allows for setting field values based on change events", () => {
+    const { result: controllerHook } = renderHook(() =>
+      useFormController({ Schema })
+    );
+
+    const {
+      result: numberFieldHook,
+      rerender: rerenderNumberFieldHook,
+    } = renderHook(() => useField(Schema.theNum, controllerHook.current));
+
+    {
+      expect(numberFieldHook.current.value).toEqual("");
+      expect(numberFieldHook.current.isTouched).toBe(false);
+    }
+
+    act(() => {
+      numberFieldHook.current.handleChange({ target: { value: "42" } } as any);
+      rerenderNumberFieldHook();
+    });
+
+    {
+      expect(numberFieldHook.current.value).toEqual(42);
+      expect(numberFieldHook.current.isTouched).toBe(true);
+    }
+  });
+
   it("allows for adding and removing array field items", () => {
     const { result: controllerHook } = renderHook(() =>
       useFormController({ Schema })
@@ -679,7 +705,7 @@ describe("formts hooks API", () => {
         theChoice: "",
         theNum: 666,
         theBool: false,
-        theInstance: null,
+        theDate: null,
         theArray: [],
         theObject: { foo: "bar" },
         theObjectArray: { arr: [] },
@@ -699,7 +725,7 @@ describe("formts hooks API", () => {
         theChoice: "",
         theNum: 42,
         theBool: false,
-        theInstance: null,
+        theDate: null,
         theArray: [],
         theObject: { foo: "" },
         theObjectArray: { arr: [] },
@@ -992,7 +1018,7 @@ describe("formts hooks API", () => {
         { path: "theChoice", error: "ERROR" },
         { path: "theNum", error: "ERROR" },
         { path: "theBool", error: "ERROR" },
-        { path: "theInstance", error: "ERROR" },
+        { path: "theDate", error: "ERROR" },
         { path: "theArray", error: "ERROR" },
         { path: "theObject", error: "ERROR" },
         { path: "theObjectArray", error: "ERROR" },
@@ -1012,7 +1038,7 @@ describe("formts hooks API", () => {
         theChoice: "",
         theNum: "",
         theBool: false,
-        theInstance: null,
+        theDate: null,
         theArray: [],
         theObject: { foo: "" },
         theObjectArray: { arr: [] },
diff --git a/src/core/hooks/use-field/use-field.ts b/src/core/hooks/use-field/use-field.ts
index b210180..94c29a5 100644
--- a/src/core/hooks/use-field/use-field.ts
+++ b/src/core/hooks/use-field/use-field.ts
@@ -113,6 +113,10 @@ const createFieldHandle = <T, Err>(
       return methods.setFieldValue(descriptor, val);
     },
 
+    handleChange: event => {
+      return methods.setFieldValueFromEvent(descriptor, event);
+    },
+
     setError: error => {
       methods.setFieldErrors({ field: descriptor, error });
     },
diff --git a/src/core/hooks/use-form-controller/formts-methods.ts b/src/core/hooks/use-form-controller/formts-methods.ts
index 41b12fa..673d146 100644
--- a/src/core/hooks/use-form-controller/formts-methods.ts
+++ b/src/core/hooks/use-form-controller/formts-methods.ts
@@ -1,13 +1,7 @@
 import React from "react";
 
 import { get, logger, values } from "../../../utils";
-import {
-  createInitialValues,
-  makeValidationHandlers,
-  resolveIsValid,
-  resolveIsValidating,
-  resolveTouched,
-} from "../../helpers";
+import * as Helpers from "../../helpers";
 import { FieldDescriptor } from "../../types/field-descriptor";
 import {
   ValidationResult,
@@ -43,13 +37,13 @@ export const createFormtsMethods = <Values extends object, Err>({
   };
 
   const isFieldTouched = <T>(field: FieldDescriptor<T, Err>) =>
-    resolveTouched(get(state.touched as object, impl(field).__path));
+    Helpers.resolveTouched(get(state.touched as object, impl(field).__path));
 
   const isFieldValid = <T>(field: FieldDescriptor<T, Err>) =>
-    resolveIsValid(state.errors, field);
+    Helpers.resolveIsValid(state.errors, field);
 
   const isFieldValidating = <T>(field: FieldDescriptor<T, Err>) =>
-    resolveIsValidating(state.validating, field);
+    Helpers.resolveIsValidating(state.validating, field);
 
   const validateField = <T>(
     field: FieldDescriptor<T, Err>,
@@ -61,7 +55,7 @@ export const createFormtsMethods = <Values extends object, Err>({
     const {
       onFieldValidationStart,
       onFieldValidationEnd,
-    } = makeValidationHandlers(dispatch);
+    } = Helpers.makeValidationHandlers(dispatch);
 
     return options.validator
       .validate({
@@ -84,7 +78,7 @@ export const createFormtsMethods = <Values extends object, Err>({
     const {
       onFieldValidationStart,
       onFieldValidationEnd,
-    } = makeValidationHandlers(dispatch);
+    } = Helpers.makeValidationHandlers(dispatch);
 
     return options.validator
       .validate({
@@ -103,16 +97,46 @@ export const createFormtsMethods = <Values extends object, Err>({
     field: FieldDescriptor<T, Err>,
     value: T
   ): Promise<void> => {
-    const decodeResult = impl(field).__decoder.decode(value);
+    const { __decoder, __path } = impl(field);
+    const decodeResult = __decoder.decode(value);
+
+    if (!decodeResult.ok) {
+      logger.warn(
+        `Can not set field value for: '${__path}' [${__decoder.fieldType}] - illegal value type.`,
+        value
+      );
+      return Promise.resolve();
+    }
+
+    return _setDecodedFieldValue(field, decodeResult.value);
+  };
+
+  const setFieldValueFromEvent = <T>(
+    field: FieldDescriptor<T, Err>,
+    event: React.ChangeEvent<unknown>
+  ) => {
+    const { __decoder, __path } = impl(field);
+    const decodeResult = Helpers.decodeChangeEvent({
+      event,
+      fieldDecoder: __decoder,
+      getValue: () => getField(field),
+    });
+
     if (!decodeResult.ok) {
       logger.warn(
-        `Field ${impl(field).__path} received illegal value: ${JSON.stringify(
-          value
-        )}`
+        `Can not set field value for: '${__path}' [${__decoder.fieldType}] - failed to extract valid value from event.target.`,
+        event?.target
       );
       return Promise.resolve();
     }
 
+    return _setDecodedFieldValue(field, decodeResult.value);
+  };
+
+  const _setDecodedFieldValue = <T>(
+    field: FieldDescriptor<T, Err>,
+    value: T
+  ): Promise<void> => {
     const validateAfterChange = () => {
       if (!options.validator) {
         return Promise.resolve();
@@ -122,9 +146,12 @@ export const createFormtsMethods = <Values extends object, Err>({
       const modifiedGetField = <T>(
         fieldToValidate: FieldDescriptor<T, Err> | string
       ): T => {
-        const path = typeof field === "string" ? field : impl(field).__path;
+        const path =
+          typeof fieldToValidate === "string"
+            ? fieldToValidate
+            : impl(fieldToValidate).__path;
         if (impl(field).__path === path) {
-          return decodeResult.value as any;
+          return value as any;
         }
         return getField(fieldToValidate);
       };
@@ -132,7 +159,7 @@ export const createFormtsMethods = <Values extends object, Err>({
       const {
         onFieldValidationStart,
         onFieldValidationEnd,
-      } = makeValidationHandlers(dispatch);
+      } = Helpers.makeValidationHandlers(dispatch);
 
       return options.validator
         .validate({
@@ -149,7 +176,7 @@ export const createFormtsMethods = <Values extends object, Err>({
 
     dispatch({
       type: "setValue",
-      payload: { path: impl(field).__path, value: decodeResult.value },
+      payload: { path: impl(field).__path, value },
     });
     return validateAfterChange();
   };
@@ -175,7 +202,10 @@ export const createFormtsMethods = <Values extends object, Err>({
     dispatch({
       type: "reset",
       payload: {
-        values: createInitialValues(options.Schema, options.initialValues),
+        values: Helpers.createInitialValues(
+          options.Schema,
+          options.initialValues
+        ),
       },
     });
   };
@@ -218,6 +248,7 @@ export const createFormtsMethods = <Values extends object, Err>({
     validateField,
     validateForm,
     setFieldValue,
+    setFieldValueFromEvent,
     touchField,
     setFieldErrors,
     resetForm,
diff --git a/src/core/types/field-decoder.spec.ts b/src/core/types/field-decoder.spec.ts
index d8b2066..6a82a4c 100644
--- a/src/core/types/field-decoder.spec.ts
+++ b/src/core/types/field-decoder.spec.ts
@@ -48,6 +48,17 @@ describe("_FieldDecoderImpl type", () => {
     assert<IsExact<Actual, Expected>>(true);
   });
 
+  it("handles date fields", () => {
+    type Actual = _FieldDecoderImpl<Date | null>;
+    type Expected = {
+      fieldType: FieldType;
+      init: () => Date | null;
+      decode: (val: unknown) => DecoderResult<Date | null>;
+    };
+
+    assert<IsExact<Actual, Expected>>(true);
+  });
+
   it("handles array fields", () => {
     type Actual = _FieldDecoderImpl<string[]>;
     type Expected = {
diff --git a/src/core/types/field-decoder.ts b/src/core/types/field-decoder.ts
index 22351d3..6e28487 100644
--- a/src/core/types/field-decoder.ts
+++ b/src/core/types/field-decoder.ts
@@ -7,7 +7,7 @@ export type _FieldDecoderImpl<T> = [T] extends [Array<any>]
     ? _ObjectFieldDecoderImpl<T>
     : IsStringUnion<T> extends true
       ? _ChoiceFieldDecoderImpl<T>
-      : _FieldDecoderBaseImpl<T>;
+      : _FieldDecoderBaseImpl<T>
 
 export type _FieldDecoderBaseImpl<T> = {
   fieldType: FieldType;
@@ -57,9 +57,9 @@ export type FieldType =
   | "choice"
   | "bool"
   | "array"
-  | "class"
+  | "date"
   | "object";
 
 export type DecoderResult<T> =
   | { ok: true; value: T }
-  | { ok: false; value: unknown };
+  | { ok: false; value?: undefined };
diff --git a/src/core/types/field-handle.ts b/src/core/types/field-handle.ts
index 5184c81..981b42d 100644
--- a/src/core/types/field-handle.ts
+++ b/src/core/types/field-handle.ts
@@ -1,3 +1,5 @@
+import { ChangeEvent } from "react";
+
 import { ArrayElement, IdentityDict, IsUnion } from "../../utils";
 
 import { FieldDescriptor } from "./field-descriptor";
@@ -49,11 +51,20 @@ type BaseFieldHandle<T, Err> = {
   descriptor: FieldDescriptor<T, Err>;
 
   /**
-   * Direct field value setter.
+   * Sets field value.
    * Will cause field validation to run with the `change` trigger.
    * Will set `isTouched` to `true`.
+   * If value is not of the desired type there is no effect.
    */
-  setValue: SetValue<T>;
+  setValue: (value: T) => void;
+
+  /**
+   * Attempts to extract value out of the event based on field type and `event.target`.
+   * Will cause field validation to run with the `change` trigger.
+   * Will set `isTouched` to `true`.
+   * If value of the desired type can't be extracted there is no effect.
+   */
+  handleChange: (event: ChangeEvent<unknown>) => void;
 
   /** Sets field error, affecting `isValid` flag */
   setError: (error: null | Err) => void;
@@ -61,14 +72,6 @@ type BaseFieldHandle<T, Err> = {
   /** runs all validation rules of the field, regardless of their validation triggers */
   validate: () => void;
 
-  /**
-   * Attempts to extract value out of React.ChangeEvent based on field type and event.target.
-   * Will cause field validation to run with the `change` trigger.
-   * Will set `isTouched` to `true`.
-   * If value of desired type can't be extracted there is no effect (other than console warning in development mode)
-   */
-  // handleChange: (event: any) => void;
-
   /**
    * Will cause field validation to run with the `blur` trigger.
    * Will set `isTouched` to `true`.
@@ -116,8 +119,3 @@ type ChoiceFieldHandle<T> = [T] extends [string]
       }
     : void
   : void;
-
-type SetValue<T> = {
-  (value: T): void;
-  // (setter: (current: T) => T): void;
-};
diff --git a/src/core/types/form-schema.spec.ts b/src/core/types/form-schema.spec.ts
index 13a77f2..4492eb3 100644
--- a/src/core/types/form-schema.spec.ts
+++ b/src/core/types/form-schema.spec.ts
@@ -15,7 +15,7 @@ type SomeValues = {
   objObj: { nested: { num: number | "" } };
   objObjArray: { nested: { arrayString: string[] } };
   arrayObj: Array<{ string: string }>;
-  instance: Date | null;
+  date: Date | null;
 };
 
 type SomeErr = "err1" | "err2";
@@ -37,7 +37,7 @@ describe("FormSchema type", () => {
       | "objObj"
       | "objObjArray"
       | "arrayObj"
-      | "instance";
+      | "date";
 
     assert<IsExact<Actual, Expected>>(true);
   });
@@ -150,8 +150,8 @@ describe("FormSchema type", () => {
     assert<IsExact<Actual, Expected>>(true);
   });
 
-  it("handles class fields", () => {
-    type Actual = Schema["instance"];
+  it("handles date fields", () => {
+    type Actual = Schema["date"];
 
     type Expected = FieldDescriptor<Date | null, SomeErr>;
 
diff --git a/src/core/types/formts-context.ts b/src/core/types/formts-context.ts
index d2dd099..f506fa7 100644
--- a/src/core/types/formts-context.ts
+++ b/src/core/types/formts-context.ts
@@ -1,3 +1,5 @@
+import { ChangeEvent } from "react";
+
 import { FieldDescriptor } from "./field-descriptor";
 import { FieldError } from "./form-handle";
 import { ValidationResult, ValidationTrigger } from "./form-validator";
@@ -20,6 +22,10 @@ export type InternalFormtsMethods<Values extends object, Err> = {
   ) => Promise<void>;
   validateForm: () => Promise<ValidationResult<Err>>;
   setFieldValue: <T>(field: FieldDescriptor<T, Err>, value: T) => Promise<void>;
+  setFieldValueFromEvent: <T>(
+    field: FieldDescriptor<T, Err>,
+    event: ChangeEvent<unknown>
+  ) => Promise<void>;
   touchField: <T>(field: FieldDescriptor<T, Err>) => void;
   setFieldErrors: (...fields: ValidationResult<Err>) => void;
   resetForm: () => void;
diff --git a/src/core/types/formts-state.spec.ts b/src/core/types/formts-state.spec.ts
index 43b562d..6a56023 100644
--- a/src/core/types/formts-state.spec.ts
+++ b/src/core/types/formts-state.spec.ts
@@ -14,7 +14,7 @@ type SomeValues = {
   objObj: { nested: { num: number | "" } };
   objObjArray: { nested: { arrayString: string[] } };
   arrayObj: Array<{ string: string }>;
-  instance: Date | null;
+  date: Date | null;
 };
 
 describe("TouchedValues type", () => {
@@ -34,7 +34,7 @@ describe("TouchedValues type", () => {
       | "objObj"
       | "objObjArray"
       | "arrayObj"
-      | "instance";
+      | "date";
 
     assert<IsExact<Actual, Expected>>(true);
   });
@@ -109,8 +109,8 @@ describe("TouchedValues type", () => {
     assert<IsExact<Actual, Expected>>(true);
   });
 
-  it("handles class fields", () => {
-    type Actual = Touched["instance"];
+  it("handles date fields", () => {
+    type Actual = Touched["date"];
     type Expected = boolean;
 
     assert<IsExact<Actual, Expected>>(true);
diff --git a/src/utils/misc-utils.ts b/src/utils/misc-utils.ts
index 344137e..d9b28a4 100644
--- a/src/utils/misc-utils.ts
+++ b/src/utils/misc-utils.ts
@@ -15,3 +15,6 @@ export const range = (start: number, end: number): number[] => {
 
   return result;
 };
+
+export const isValidDate = (val: unknown): val is Date =>
+  val instanceof Date && !Number.isNaN(val.valueOf());
diff --git a/src/validators/validators.spec.ts b/src/validators/validators.spec.ts
index b47a301..f960379 100644
--- a/src/validators/validators.spec.ts
+++ b/src/validators/validators.spec.ts
@@ -320,24 +320,6 @@ describe("validators", () => {
     );
   });
 
-  describe("validDate", () => {
-    [
-      { value: new Date(), ok: true },
-      { value: new Date("2016-05-24T23:00:00"), ok: true },
-      { value: new Date("2016-13-24T23:00:00"), ok: false },
-      { value: new Date("huh?"), ok: false },
-      { value: null, ok: false },
-    ].forEach(({ value, ok }) =>
-      it(`validDate()(${value?.toDateString() ?? "null"}) -> ${
-        ok ? "OK" : "ERROR"
-      }`, () => {
-        const validator = validators.validDate();
-
-        expect(validator(value)).toEqual(ok ? null : { code: "validDate" });
-      })
-    );
-  });
-
   describe("minDate", () => {
     const min = new Date("2016-05-24T23:00:00");
 
diff --git a/src/validators/validators.ts b/src/validators/validators.ts
index b23f9b8..95b619e 100644
--- a/src/validators/validators.ts
+++ b/src/validators/validators.ts
@@ -123,13 +123,6 @@ export const exactLength = (
 
 // dates
 
-/** checks if date value is valid */
-export const validDate = (): Validator.Sync<
-  Date | null,
-  BaseErrors.ValidDate
-> => date =>
-  date == null || Number.isNaN(date.valueOf()) ? { code: "validDate" } : null;
-
 /** compares date value against provided minimum */
 export const minDate = (
   min: Date