diff --git a/apps/docs/.vitepress/config.mts b/apps/docs/.vitepress/config.mts
index ba7b598..992094c 100644
--- a/apps/docs/.vitepress/config.mts
+++ b/apps/docs/.vitepress/config.mts
@@ -1,5 +1,6 @@
 import { defineConfig } from 'vitepress'
 import { groupIconMdPlugin, groupIconVitePlugin } from 'vitepress-plugin-group-icons'
+import { tabsMarkdownPlugin } from 'vitepress-plugin-tabs'
 import path from 'path'
 
 // https://vitepress.dev/reference/site-config
@@ -11,6 +12,7 @@ export default defineConfig({
   markdown: {
     config(md) {
       md.use(groupIconMdPlugin)
+      md.use(tabsMarkdownPlugin)
     }
   },
   themeConfig: {
@@ -41,7 +43,8 @@ export default defineConfig({
           { text: 'useFieldEmits', link: '/guide/composables/useFieldEmits' },
           { text: 'useFieldProps', link: '/guide/composables/useFieldProps' },
           { text: 'useFieldValidate', link: '/guide/composables/useFieldValidate' },
-          { text: 'useFormModel', link: '/guide/composables/useFormModel' }
+          { text: 'useFormModel', link: '/guide/composables/useFormModel' },
+          { text: 'useValidation', link: '/guide/composables/useValidation' }
         ]
       },
       {
diff --git a/apps/docs/.vitepress/theme/index.js b/apps/docs/.vitepress/theme/index.js
index ea4628c..b63094d 100644
--- a/apps/docs/.vitepress/theme/index.js
+++ b/apps/docs/.vitepress/theme/index.js
@@ -1,6 +1,8 @@
 import DefaultTheme from 'vitepress/theme'
 import VueFormGenerator from '@/index'
 
+import { enhanceAppWithTabs } from 'vitepress-plugin-tabs/client'
+
 import './index.css'
 import '@/scss/themes/basic.scss'
 import 'virtual:group-icons.css'
@@ -8,6 +10,7 @@ import 'virtual:group-icons.css'
 export default {
   extends: DefaultTheme,
   enhanceApp({ app }) {
+    enhanceAppWithTabs(app)
     app.use(VueFormGenerator, {
       messages: {
         productCodeValidator: 'Your product code is invalid'
diff --git a/apps/docs/guide/composables/useFieldEmits.md b/apps/docs/guide/composables/useFieldEmits.md
index 1eadcf9..a3f80d5 100644
--- a/apps/docs/guide/composables/useFieldEmits.md
+++ b/apps/docs/guide/composables/useFieldEmits.md
@@ -13,6 +13,15 @@ const emits = defineEmits(useFieldEmits())
 </script>
 ```
 
+## TypeScript alternative
+```vue
+<script setup lang="ts">
+import type { FieldEmits } from '@kevinkosterr/vue3-form-generator'
+  
+const emits = defineEmits<FieldEmits>()
+</script>
+```
+
 ## Emits
 
 ### `onInput`
diff --git a/apps/docs/guide/composables/useFieldProps.md b/apps/docs/guide/composables/useFieldProps.md
index c0ce97a..1907d14 100644
--- a/apps/docs/guide/composables/useFieldProps.md
+++ b/apps/docs/guide/composables/useFieldProps.md
@@ -16,6 +16,20 @@ const { field, model } = toRefs(props)
 </script>
 ```
 
+## TypeScript alternative
+```vue
+<script setup lang="ts">
+import { toRefs } from 'vue'
+import type { FieldProps, FieldBase, FieldPropRefs } from '@kevinkosterr/vue3-form-generator'
+
+type CustomField = FieldBase & {}
+
+const props = defineProps<FieldProps<CustomField>>()
+  
+const { field, model }: FieldPropRefs<CustomField> = toRefs(props)
+</script>
+```
+
 ## Props
 
 ### `id` <Badge type="info" text="String"/>
diff --git a/apps/docs/guide/composables/useFieldValidate.md b/apps/docs/guide/composables/useFieldValidate.md
index 8219462..8aeee7c 100644
--- a/apps/docs/guide/composables/useFieldValidate.md
+++ b/apps/docs/guide/composables/useFieldValidate.md
@@ -1,8 +1,11 @@
 ---
 outline: [2,3]
 ---
-# useFieldValidate <Badge type="tip" text="2.0.0+"/>
-> Used to validate a field against validators defined in a fields schema
+# useFieldValidate <Badge type="tip" text="2.0.0+"/> <Badge type="warning" text="deprecated"/>
+> Used to validate a field against validators defined in a field's schema
+::: warning
+This composable is deprecated, please use [`useValidation`](/guide/composables/useValidation) instead
+:::
 
 ## Usage
 ```vue
diff --git a/apps/docs/guide/composables/useValidation.md b/apps/docs/guide/composables/useValidation.md
new file mode 100644
index 0000000..cd7f97a
--- /dev/null
+++ b/apps/docs/guide/composables/useValidation.md
@@ -0,0 +1,119 @@
+---
+outline: [2,3]
+---
+# useValidation <Badge type="tip" text=">=2.7.0"/>
+> Used to validate a field against validators defined in a field's schema
+
+## Usage
+::: code-group
+```Vue [Vue]
+<script setup>
+import { toRefs } from 'vue'
+import { 
+  useValidation, 
+  useFieldProps,
+  useFormModel,
+  useFieldEmits,
+  useFieldAttributes
+} from '@kevinkosterr/vue3-form-generator'
+
+const props = defineProps(useFieldProps())
+const emits = defineEmits(useFieldEmits())
+
+const { field, model } = toRefs(props)
+const { isRequired, isDisabled, isReadonly } = useFieldAttributes(model.value, field.value)
+const { currentModelValue } = useFormModel(model.value, field.value)
+  
+const { validate, errors, onChanged, onBlur } = useValidation(
+    model.value,
+    field.value,
+    currentModelValue,
+    props.formOptions,
+    emits,
+    isDisabled.value,
+    isRequired.value,
+    isReadonly.value
+)
+</script>
+```
+```Vue [Vue TS]
+<script setup lang="ts">
+import { toRefs } from 'vue'
+import { 
+  type FieldEmits, 
+  type FieldProps, 
+  type FieldBase,
+  type FieldPropRefs,
+  useValidation,
+  useFieldAttributes,
+  useFormModel
+} from '@kevinkosterr/vue3-form-generator'
+
+type CustomField = FieldBase & {
+  customAttr: string
+}
+
+const props = defineProps<FieldProps<CustomField>>()
+const emits = defineEmits<FieldEmits>()
+  
+const { field, model }: FieldPropRefs<CustomField> = toRefs(props)
+const { isRequired, isDisabled, isReadonly } = useFieldAttributes(model.value, field.value)
+const { currentModelValue } = useFormModel(model.value, field.value)
+
+const { validate, errors, onChanged, onBlur } = useValidation(
+    model.value,
+    field.value,
+    currentModelValue,
+    props.formOptions,
+    emits,
+    isDisabled.value,
+    isRequired.value,
+    isReadonly.value
+)
+</script>
+```
+:::
+
+## Arguments
+
+### `model` <Badge type="info" text="Object"/>
+Model object, as returned by the props
+
+### `field` <Badge type="info" text="Object"/>
+Field schema object, as returned by the props
+
+### `currentModelValue` <Badge type="info" text="Ref<any>"/>
+`Ref` of the current value from the field. Returned by [`useFormModel`](/guide/composables/useFormModel).
+
+### `formOptions` <Badge type="info" text="Object"/>
+Form options object, as returned by the props.
+
+### `emits` <Badge type="info" text="EmitFn<FieldEmits>"/>
+Emit function as returned by `defineEmits()`
+
+### `isDisabled` <Badge type="info" text="Boolean"/>
+Whether the field is disabled, can be obtained from [`useFieldAttributes()`](/guide/composables/useFieldAttributes)
+
+### `isRequired` <Badge type="info" text="Boolean"/>
+Whether the field is required, can be obtained from [`useFieldAttributes()`](/guide/composables/useFieldAttributes)
+
+### `isReadonly` <Badge type="info" text="Boolean"/>
+Whether the field is readonly, can be obtained from [`useFieldAttributes()`](/guide/composables/useFieldAttributes)
+
+## Returns
+
+### `errors` <Badge type="info" text="string[]"/>
+An array of errors for the current field. Will be auto-updated on every validation cycle. Must be cleared
+manually when the value of a field has changed.
+
+### `validate` <Badge type="info" text="Function"/>
+A validation function, meant to be called when a validation has to take place. Used when a field is always validated
+at the same moment and isn't affected by validation triggers, such as `'onChanged'` or `'onBlur'`.
+
+### `onChanged` <Badge type="info" text="Function"/>
+A wrapped validation function, only validates when `'onChanged'` validation is enabled. Should always be called if the value is changed, unless the field is unaffected by
+validation triggers.
+
+### `onBlur` <Badge type="info" text="Function"/>
+A wrapped validation function, only validates when `'onBlur'` validation is enabled (which is the default behavior). Should always be called if the value is changed, unless the field is unaffected by
+validation triggers.
diff --git a/apps/docs/guide/customization/custom-components.md b/apps/docs/guide/customization/custom-components.md
index 77f05f3..68f0b99 100644
--- a/apps/docs/guide/customization/custom-components.md
+++ b/apps/docs/guide/customization/custom-components.md
@@ -15,35 +15,21 @@ To create a field component you make use of different composables ([?](https://v
 get the behaviour you want the component to have. Different composables handle different functionality inside the field
 component.
 
+:::tabs
+== JavaScript
 Every component must at least use these composables to work properly:
 - [`useFieldEmits`](/guide/composables/useFieldEmits) - returns all events emitted by a field component;
 - [`useFieldProps`](/guide/composables/useFieldProps) - returns all props used by a field component;
 - [`useFormModel`](/guide/composables/useFormModel) - used to get the current model value for this field component.
 
 Optional:
-- [`useFieldValidate`](/guide/composables/useFieldValidate) - used for validation of the field;
+- [`useValidation`](/guide/composables/useValidation) - used for validation of the field;
 - [`useFieldAttributes`](/guide/composables/useFieldAttributes) - holds different dynamic field attributes like `required` and `readonly`.
 
 
 ### Basic example
 ::: code-group
-```vue [template]
-<template>
-  <input
-    :id="id"
-    class="field-input"
-    type="text"
-    :name="field.name"
-    :required="isRequired"
-    :disabled="isDisabled"
-    :placeholder="field.placeholder"
-    :autocomplete="field.autocomplete || 'off'"
-    :value="currentModelValue"
-    @input="onFieldValueChanged"
-    @blur="onBlur"
-  >
-</template>
-```
+<!--@include: @/parts/customization/custom-components-template-example.md-->
 
 ```vue [script setup]
 <script setup>
@@ -79,16 +65,62 @@ const onFieldValueChanged = ({ target }) => {
   errors.value = []
   emits('onInput', target.value)
 }
+<script/>
+```
+
+==TypeScript
+You'll only need one composable to create a custom component:
+- [`useFormModel`](/guide/composables/useFormModel) - used to get the current model value for this field component.
+
+Optional:
+- [`useValidation`](/guide/composables/useValidation) - used for validation of the field;
+- [`useFieldAttributes`](/guide/composables/useFieldAttributes) - holds different dynamic field attributes like `required` and `readonly`.
+
+When using TypeScript you won't need the other composables to define proper emits and props. You'll be able to use types
+for that. 
+
+### Basic example
+:::code-group
+<!--@include: @/parts/customization/custom-components-template-example.md-->
+
+```vue [script setup]
+<script setup lang="ts">
+import { toRefs } from 'vue'
+import type { FieldBase, FieldEmits, FieldProps, FieldPropRefs } from '@kevinkosterr/vue3-form-generator'
+import { useValidation, useFormModel, useFieldAttributes } from '@kevinkosterr/vue3-form-generator'  
+
+type CustomFieldType = FieldBase & {
+  customAttribute: boolean
+}
+
+const props = defineProps<FieldProps<CustomFieldType>>()
+const emits = defineEmits<FieldEmits>()
+const { model, field }: FieldPropRefs<CustomFieldType> = toRefs(props)
+
+const { isDisabled, isRequired, isReadonly } = useFieldAttributes(model.value, field.value)
+const { currentModelValue } = useFormModel(model.value, field.value)
+const { errors, validate, onChanged: onFieldValueChanged, onBlur } = useValidation(
+    model.value,
+    field.value,
+    currentModelValue,
+    props.formOptions,
+    emits,
+    isDisabled.value,
+    isRequired.value,
+    isReadonly.value
+)
+</script>
 ```
 :::
 
+
 ### Advanced example
 For a more advanced example, you can take a look at the [`FieldSelect`](/guide/fields/FieldSelect) ([source](https://github.com/kevinkosterr/vue3-form-generator/blob/69cb6aeb8e8c82926ec3598e7d73be2d1146a3f2/src/fields/core/FieldSelect.vue)) component.
 
 ## Compatibility with validation
 ::: info
 If you want your component to be compatible with validation, you'll need to expose the `errors` value that is returned
-by [`useFieldValidate`](/guide/composables/useFieldValidate)
+by [`useValidation`](/guide/composables/useValidation)
 :::
 
 ## Registering your component
diff --git a/apps/docs/guide/form-generator/props.md b/apps/docs/guide/form-generator/props.md
index 14e8c28..f67b8e9 100644
--- a/apps/docs/guide/form-generator/props.md
+++ b/apps/docs/guide/form-generator/props.md
@@ -12,9 +12,10 @@ outline: [ 2,3 ]
 | `idPrefix`    | `string` | Prefix for all the generated ids in the form         |
 
 ## `formOptions`
-| Property          | Type     | Description                                          |
-|---------------|----------|------------------------------------------------------|
-| `idPrefix` | `string` | Prefix for all the generated ids in the form |
+| Property   | Type                     | Default | Description                                                                                         |
+|------------|--------------------------|--------|-----------------------------------------------------------------------------------------------------|
+| `idPrefix` | `string`                 |        | Prefix for all the generated ids in the form                                                        |
+| `validate` | `'onChanged'` \| `'onBlur'` | `onBlur` | Method of validation, can be overwritten by individual fields. Can be either `onChanged` or `onBlur` |
 
 ## `model`
 Type: `Object`
diff --git a/apps/docs/parts/customization/custom-components-template-example.md b/apps/docs/parts/customization/custom-components-template-example.md
new file mode 100644
index 0000000..16f4308
--- /dev/null
+++ b/apps/docs/parts/customization/custom-components-template-example.md
@@ -0,0 +1,17 @@
+```vue [template]
+<template>
+  <input
+    :id="id"
+    class="field-input"
+    type="text"
+    :name="field.name"
+    :required="isRequired"
+    :disabled="isDisabled"
+    :placeholder="field.placeholder"
+    :autocomplete="field.autocomplete || 'off'"
+    :value="currentModelValue"
+    @input="onFieldValueChanged"
+    @blur="onBlur"
+  >
+</template>
+```
\ No newline at end of file
diff --git a/apps/docs/parts/shared-field-properties.md b/apps/docs/parts/shared-field-properties.md
index c857ba8..dcc9da8 100644
--- a/apps/docs/parts/shared-field-properties.md
+++ b/apps/docs/parts/shared-field-properties.md
@@ -1,17 +1,18 @@
-| Property    | Default    | Type                                        | Description                                                                                     |
-|-------------|------------|---------------------------------------------|-------------------------------------------------------------------------------------------------|
-| name        | -          | `string`                                    | Name of the field                                                                               |
-| model       | -          | `string`                                    | Key of model in the form schema model                                                           |
-| label       | -          | `string`                                    | Label for the field                                                                             |
-| type        | -          | `string`                                    | Type of field, generally `input` if the field is an input.                                      |
-| inputType   | -          | `string`                                    | Type of input, only required when `type === 'input'`                                             |
+| Property    | Default   | Type                                        | Description                                                                                     |
+|-------------|-----------|---------------------------------------------|-------------------------------------------------------------------------------------------------|
+| name        | -         | `string`                                    | Name of the field                                                                               |
+| model       | -         | `string`                                    | Key of model in the form schema model                                                           |
+| label       | -         | `string`                                    | Label for the field                                                                             |
+| type        | -         | `string`                                    | Type of field, generally `input` if the field is an input.                                      |
+| inputType   | -         | `string`                                    | Type of input, only required when `type === 'input'`                                            |
 | id          | _computed_ | `string`                                    | `id` of the field                                                                               |
-| visible     | `true`     | `Boolean \| Function`                       | Whether the field is visible, method will be passed the `model`, `field` and field component*   |
-| required    | `false`    | `Boolean \| Function`                       | Whether the field is required, method will be passed the `model`, `field` and field component*  |
-| readonly    | `false`    | `Boolean \| Function`                       | Whether the field is read only, method will be passed the `model`, `field` and field component* |
-| disabled    | `false`    | `Boolean \| Function`                       | Whether the field is disabled, method will be passed the `model`, `field` and field component*  |
-| hint        | -          | `string \| Function`                        | Hint to display underneath the field, can be passed a method*                                   |
+| visible     | `true`    | `Boolean \| Function`                       | Whether the field is visible, method will be passed the `model`, `field` and field component*   |
+| required    | `false`   | `Boolean \| Function`                       | Whether the field is required, method will be passed the `model`, `field` and field component*  |
+| readonly    | `false`   | `Boolean \| Function`                       | Whether the field is read only, method will be passed the `model`, `field` and field component* |
+| disabled    | `false`   | `Boolean \| Function`                       | Whether the field is disabled, method will be passed the `model`, `field` and field component*  |
+| hint        | -         | `string \| Function`                        | Hint to display underneath the field, can be passed a method*                                   |
 | validator   | _computed_ | `Array<Function> \| Function  \| undefined` | A (list of) validator(s) to be validating the field against.                                    |
-| onValidated | -          | `Function  \| undefined`                    | Method to be called after validation has been completed.                                        |
+| validate    | `onBlur`   | `'onChanged'` \| `'onBlur'`                       | Method of validation for the field.                                                             |
+| onValidated | -         | `Function  \| undefined`                    | Method to be called after validation has been completed.                                        |
 
 _*_ see [determineDynamicAttribute()](/guide/mixins/abstractField#determinedynamicattribute) for more information.
\ No newline at end of file
diff --git a/package.json b/package.json
index dbc5e92..8294b37 100644
--- a/package.json
+++ b/package.json
@@ -70,6 +70,7 @@
     "vite-plugin-dts": "^4.3.0",
     "vitepress": "^1.6.3",
     "vitepress-plugin-group-icons": "^1.5.5",
+    "vitepress-plugin-tabs": "^0.7.1",
     "vitest": "^2.1.1",
     "vue": "^3.5.6",
     "vue-eslint-parser": "^9.4.3",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 65c15ee..50515c5 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -83,6 +83,9 @@ importers:
       vitepress-plugin-group-icons:
         specifier: ^1.5.5
         version: 1.5.5(markdown-it@14.1.0)(vite@5.4.19(sass@1.82.0)(terser@5.37.0))
+      vitepress-plugin-tabs:
+        specifier: ^0.7.1
+        version: 0.7.1(vitepress@1.6.3(@algolia/client-search@5.25.0)(postcss@8.4.49)(sass@1.82.0)(search-insights@2.17.3)(terser@5.37.0)(typescript@5.7.2))(vue@3.5.13(typescript@5.7.2))
       vitest:
         specifier: '>=2.1.9'
         version: 3.1.3(jsdom@25.0.1)(sass@1.82.0)(terser@5.37.0)
@@ -3040,6 +3043,12 @@ packages:
       markdown-it: '>=14'
       vite: '>=3'
 
+  vitepress-plugin-tabs@0.7.1:
+    resolution: {integrity: sha512-jxJvsicxnMSIYX9b8mAFLD2nwyKUcMO10dEt4nDSbinZhM8cGvAmMFOHPdf6TBX6gYZRl+/++/iYHtoM14fERQ==}
+    peerDependencies:
+      vitepress: ^1.0.0
+      vue: ^3.5.0
+
   vitepress@1.6.3:
     resolution: {integrity: sha512-fCkfdOk8yRZT8GD9BFqusW3+GggWYZ/rYncOfmgcDtP3ualNHCAg+Robxp2/6xfH1WwPHtGpPwv7mbA3qomtBw==}
     hasBin: true
@@ -6188,6 +6197,11 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  vitepress-plugin-tabs@0.7.1(vitepress@1.6.3(@algolia/client-search@5.25.0)(postcss@8.4.49)(sass@1.82.0)(search-insights@2.17.3)(terser@5.37.0)(typescript@5.7.2))(vue@3.5.13(typescript@5.7.2)):
+    dependencies:
+      vitepress: 1.6.3(@algolia/client-search@5.25.0)(postcss@8.4.49)(sass@1.82.0)(search-insights@2.17.3)(terser@5.37.0)(typescript@5.7.2)
+      vue: 3.5.13(typescript@5.7.2)
+
   vitepress@1.6.3(@algolia/client-search@5.25.0)(postcss@8.4.49)(sass@1.82.0)(search-insights@2.17.3)(terser@5.37.0)(typescript@5.7.2):
     dependencies:
       '@docsearch/css': 3.8.2
diff --git a/src/FormGenerator.vue b/src/FormGenerator.vue
index 19e0934..141579f 100644
--- a/src/FormGenerator.vue
+++ b/src/FormGenerator.vue
@@ -51,7 +51,9 @@ const props = withDefaults(defineProps<FormGeneratorProps>(), {
   enctype: 'application/x-www-form-urlencoded',
   id: '',
   idPrefix: '', // Kept for compatibility reasons.
-  options: () => ({})
+  options: () => ({
+    validate: 'onBlur' // Always validate onBlur by default.
+  })
 })
 
 type FormGroupInstance = ComponentPublicInstance<InstanceType<typeof FormGroup>>
diff --git a/src/composables/index.ts b/src/composables/index.ts
index ef00f9b..61a9cac 100644
--- a/src/composables/index.ts
+++ b/src/composables/index.ts
@@ -3,11 +3,15 @@ import { useFieldValidate } from '@/composables/useFieldValidate'
 import { useFieldAttributes } from '@/composables/useFieldAttributes'
 import { useFieldProps } from '@/composables/useFieldProps'
 import { useFieldEmits } from '@/composables/useFieldEmits'
+import { useValidationWrapper } from '@/composables/useValidationWrapper'
+import { useValidation } from '@/composables/useValidation'
 
 export {
   useFormModel,
   useFieldValidate,
   useFieldAttributes,
   useFieldProps,
-  useFieldEmits
+  useFieldEmits,
+  useValidationWrapper,
+  useValidation
 }
\ No newline at end of file
diff --git a/src/composables/useFieldEmits.ts b/src/composables/useFieldEmits.ts
index 760b8c1..fb36aa9 100644
--- a/src/composables/useFieldEmits.ts
+++ b/src/composables/useFieldEmits.ts
@@ -1,3 +1,5 @@
-export function useFieldEmits (): string[] {
+import type { FieldEmits } from '@/resources/types/field/fields'
+
+export function useFieldEmits (): (keyof FieldEmits)[] {
   return [ 'onInput', 'validated' ]
 }
\ No newline at end of file
diff --git a/src/composables/useFieldValidate.ts b/src/composables/useFieldValidate.ts
index a169fc8..c49c7d9 100644
--- a/src/composables/useFieldValidate.ts
+++ b/src/composables/useFieldValidate.ts
@@ -1,32 +1,14 @@
 import { ref, Ref, computed, ComputedRef } from 'vue'
 import { getMessage } from '@/validators/messages'
-import { isFunction, isString, toUniqueArray } from '@/helpers'
+import { isFunction, toUniqueArray, getValidator } from '@/helpers'
 import { TValidatorFunction } from '@/resources/types/functions'
-import { ValidatorMap } from '@/resources/types/generic'
 import type { FormModel } from '@/resources/types/fieldAttributes'
 import type { Field } from '@/resources/types/field/fields'
 import validators from '@/validators'
 
 /**
- * Get the corresponding validator function for a given string, or function. If a function is passed, the function is
- * assumed to be the validator to use and thus return. If no argument is passed, we'll just return a function that
- * will always return true, thus assuming the value is always valid.
- * @param validator
+ * @deprecated will be removed in 3.0.0, use `useValidation` instead.
  */
-function getValidator (validator: string | TValidatorFunction | undefined): TValidatorFunction {
-  if (validator === undefined) return (): boolean => true
-
-  if (isFunction(validator)) return <TValidatorFunction>validator
-
-  if (isString(validator)) {
-    if ((validators as ValidatorMap)[<string>validator] === undefined) {
-      throw new Error('Invalid validator: ' + validator)
-    }
-    return (validators as ValidatorMap)[<string>validator]
-  }
-  return (): boolean => true
-}
-
 export function useFieldValidate (
   model: FormModel,
   field: Field,
diff --git a/src/composables/useValidation.ts b/src/composables/useValidation.ts
new file mode 100644
index 0000000..5ed69eb
--- /dev/null
+++ b/src/composables/useValidation.ts
@@ -0,0 +1,124 @@
+import type { Field, FieldEmits } from '@/resources/types/field/fields'
+import type { FormModel } from '@/resources/types/fieldAttributes'
+import type { FormOptions, ValidationTrigger } from '@/resources/types/generic'
+import { type Ref, type ComputedRef, type EmitFn, computed, ref } from 'vue'
+
+import { isFunction, toUniqueArray, getValidator } from '@/helpers'
+import { getMessage } from '@/validators/messages'
+import { useValidationWrapper } from '@/composables/useValidationWrapper'
+import { TValidatorFunction } from '@/resources/types/functions'
+
+import validators from '@/validators'
+
+/**
+ * Composable for validation of the value(s) from a field.
+ * Houses all the necessary logic for performing a validation and handles the emitted events.
+ * @param model - model object from the form.
+ * @param field - field schema object.
+ * @param currentModelValue - current model value Ref.
+ * @param formOptions
+ * @param emits
+ * @param isDisabled
+ * @param isRequired
+ * @param isReadOnly
+ */
+export function useValidation(
+  model: FormModel,
+  field: Field,
+  currentModelValue: Ref<any>,
+  formOptions: FormOptions,
+  emits: EmitFn<FieldEmits>,
+  isDisabled: boolean,
+  isRequired: boolean,
+  isReadOnly: boolean
+) {
+
+  const errors: Ref<string[]> = ref([])
+
+  /**
+   * The method of validation determined by this field.
+   * Can be either 'onChanged', 'onBlur' or undefined.
+   */
+  const validationMethod: ComputedRef<ValidationTrigger | undefined> = computed(() => {
+    return field.validate
+  })
+
+  /**
+   * Compute all validators that should be present by default.
+   */
+  const defaultValidators: ComputedRef<TValidatorFunction[]> = computed(() => {
+    const fieldValidators: TValidatorFunction[] = []
+    if (!isDisabled && !isReadOnly) {
+      if (isRequired && !fieldValidators.includes(validators.required)) {
+        fieldValidators.push(validators.required)
+      }
+
+      if ('min' in field && field.min) {
+        fieldValidators.push(validators.min)
+      }
+
+      if ('max' in field && field.max) {
+        fieldValidators.push(validators.max)
+      }
+    }
+    return fieldValidators
+  })
+
+  /**
+   * Emit the 'validated' event.
+   * @param isValid - whether the field value is valid.
+   * @param errors - errors found during validation.
+   * @param field - field object.
+   */
+  const emitValidated = (isValid: boolean, errors: string[], field: Field): void => {
+    emits('validated', isValid, errors, field)
+  }
+
+  /**
+   * Validate the field against given validators, plus the validators that are put there by default.
+   */
+  const validate = async (): Promise<void> => {
+    if (!('validator' in field)) {
+      emitValidated(true, [], field)
+      return
+    }
+
+    const results: string[] = []
+    const fieldValidators: TValidatorFunction[] = [ ...defaultValidators.value ]
+
+    if (Array.isArray(field.validator)) {
+      field.validator.forEach((validator: any) => fieldValidators.push(getValidator(validator)))
+    } else {
+      fieldValidators.push(getValidator(field.validator))
+    }
+
+    fieldValidators.forEach((validator: TValidatorFunction): void => {
+      const isValid: boolean = validator(currentModelValue.value, field, model)
+      if (!isValid) results.push(getMessage(validator.name))
+    })
+
+    const uniqueResults = toUniqueArray(results)
+
+    if ('onValidated' in field && field.onValidated) {
+      if (isFunction(field.onValidated)) {
+        field.onValidated.call(null, model, uniqueResults, field)
+      } else {
+        throw new Error('onValidated property must be of type `function` on field: ' + field.name)
+      }
+    }
+
+    errors.value = uniqueResults
+    emitValidated(uniqueResults.length === 0, uniqueResults, field)
+  }
+
+  const onChanged = useValidationWrapper(validate, 'onChanged', validationMethod.value, formOptions.validate)
+  const onBlur = useValidationWrapper(validate, 'onBlur', validationMethod.value, formOptions.validate)
+
+  return {
+    errors,
+    validate,
+    onChanged,
+    onBlur
+  }
+
+}
\ No newline at end of file
diff --git a/src/composables/useValidationWrapper.ts b/src/composables/useValidationWrapper.ts
new file mode 100644
index 0000000..a2be833
--- /dev/null
+++ b/src/composables/useValidationWrapper.ts
@@ -0,0 +1,30 @@
+import { type ValidationTrigger } from '@/resources/types/generic'
+
+
+/**
+ * Use a provided validator function when the trigger of that validator matches
+ * the validation method used for the current form or form field.
+ * @param {Function} fn - validator function to execute upon meeting conditions
+ * @param {ValidationTrigger} trigger - trigger for the validation, 'onBlur' or 'onChanged'
+ * @param {string | undefined} fieldValidationMethod - validation method as set by the field schema, can be undefined.
+ * @param {string | undefined} formValidationMethod - validation method as set by the form options, can be undefined.
+ */
+export function useValidationWrapper(
+  fn: (...args: any[]) => void,
+  trigger: ValidationTrigger,
+  fieldValidationMethod: string | undefined,
+  formValidationMethod: string | undefined
+) {
+  return (...args: any[]) => {
+    if (fieldValidationMethod !== undefined) {
+      return fieldValidationMethod === trigger ? fn(...args) : undefined
+    }
+
+    if (formValidationMethod !== undefined) {
+      return formValidationMethod === trigger ? fn(...args) : undefined
+    }
+
+    return trigger === 'onBlur' ? fn(...args) : undefined
+  }
+
+}
\ No newline at end of file
diff --git a/src/fields/core/FieldColor.vue b/src/fields/core/FieldColor.vue
index 8a7570a..28d41ca 100644
--- a/src/fields/core/FieldColor.vue
+++ b/src/fields/core/FieldColor.vue
@@ -7,6 +7,9 @@
       type="text"
       :value="currentModelValue"
       placeholder="#ffffff"
+      :required="isRequired"
+      :readonly="isReadonly"
+      :disabled="isDisabled"
       @input="onFieldValueChanged"
       @blur="onBlur"
     >
@@ -17,6 +20,8 @@
       :name="props.field.name"
       :value="currentModelValue"
       :required="isRequired"
+      :readonly="isReadonly"
+      :disabled="isDisabled"
       @input="onFieldValueChanged"
       @blur="onBlur"
     >
@@ -29,14 +34,13 @@ import { toRefs, onBeforeMount } from 'vue'
 import {
   useFormModel,
   useFieldAttributes,
-  useFieldValidate,
-  useFieldEmits
+  useValidation
 } from '@/composables'
 import { vMaska } from 'maska/vue'
-import type { ColorField, FieldPropRefs, FieldProps } from '@/resources/types/field/fields'
+import type { ColorField, FieldEmits, FieldPropRefs, FieldProps } from '@/resources/types/field/fields'
 import type { MaskOptions } from 'maska'
 
-const emits = defineEmits(useFieldEmits())
+const emits = defineEmits<FieldEmits>()
 const props = defineProps<FieldProps<ColorField>>()
 
 const maskOptions: Readonly<MaskOptions> = {
@@ -51,31 +55,25 @@ const maskOptions: Readonly<MaskOptions> = {
 const { field, model }: FieldPropRefs<ColorField> = toRefs(props)
 
 const { currentModelValue } = useFormModel(model.value, field.value)
-const { isRequired, isVisible, hint } = useFieldAttributes(model.value, field.value)
-const { errors, validate } = useFieldValidate(
+const { isRequired, isVisible, isDisabled, isReadonly, hint } = useFieldAttributes(model.value, field.value)
+const { errors, onChanged, onBlur } = useValidation(
   model.value,
   field.value,
-  false,
+  currentModelValue,
+  props.formOptions,
+  emits,
+  isDisabled.value,
   isRequired.value,
-  false
+  isReadonly.value
 )
 
-const onBlur = () => {
-  validate(currentModelValue.value).then((validationErrors) => {
-    emits('validated',
-      validationErrors.length === 0,
-      validationErrors,
-      field.value
-    )
-  })
-}
-
 const onFieldValueChanged = (event: Event) => {
   const target = event.target as HTMLInputElement
   errors.value = []
   // Ensure a change doesn't emit twice; we need this because both inputs might trigger this function at once.
   if (target.value !== currentModelValue.value) {
     emits('onInput', target.value)
+    onChanged()
   }
 }
 
@@ -88,7 +86,7 @@ onBeforeMount(() => {
     } else if (field.value.validator !== undefined) {
       fieldValidators.push(field.value.validator)
     }
-    // Keep in mind that the native color picker only supports 6 digit hex codes,
+    // Keep in mind that the native color picker only supports 6-digit hex codes,
     // so even though a value might technically be valid, it won't display the right color on the color picker input.
     fieldValidators.push(validators.hexColorValue)
     field.value.validator = fieldValidators
diff --git a/src/fields/core/FieldMask.vue b/src/fields/core/FieldMask.vue
index c645bbb..6b616a3 100644
--- a/src/fields/core/FieldMask.vue
+++ b/src/fields/core/FieldMask.vue
@@ -13,13 +13,13 @@
 
 <script setup lang="ts">
 import { toRefs, computed, ComputedRef, ref, onBeforeMount } from 'vue'
-import type { FieldPropRefs, FieldProps, MaskField } from '@/resources/types/field/fields'
+import type { FieldEmits, FieldPropRefs, FieldProps, MaskField } from '@/resources/types/field/fields'
 import type { MaskInputOptions } from 'maska'
 import { Mask } from 'maska'
 import { vMaska } from 'maska/vue'
-import { useFormModel, useFieldAttributes, useFieldEmits, useFieldValidate } from '@/composables'
+import { useFormModel, useFieldAttributes, useValidation } from '@/composables'
 
-const emits = defineEmits(useFieldEmits())
+const emits = defineEmits<FieldEmits>()
 const props = defineProps<FieldProps<MaskField>>()
 const { field, model }: FieldPropRefs<MaskField> = toRefs(props)
 
@@ -39,24 +39,17 @@ const maskOptions: ComputedRef<MaskInputOptions> = computed(() => {
 
 const { currentModelValue } = useFormModel(model.value, field.value)
 const { isRequired, isDisabled, isVisible, hint } = useFieldAttributes(model.value, field.value)
-const { errors, validate } = useFieldValidate(
+const { errors, onChanged, onBlur } = useValidation(
   model.value,
   field.value,
+  currentModelValue,
+  props.formOptions,
+  emits,
   isDisabled.value,
   isRequired.value,
   false
 )
 
-const onBlur = () => {
-  validate(currentModelValue.value).then((validationErrors) => {
-    emits('validated',
-      validationErrors.length === 0,
-      validationErrors,
-      field.value
-    )
-  })
-}
-
 const onFieldValueChanged = (event: Event): void => {
   errors.value = []
   if (field.value.maskOptions && field.value.maskOptions.unmasked) {
@@ -64,6 +57,7 @@ const onFieldValueChanged = (event: Event): void => {
   } else if (event.target) {
     emits('onInput', (event.target as HTMLInputElement).value)
   }
+  onChanged()
 }
 
 onBeforeMount(() => {
diff --git a/src/fields/core/FieldNumber.vue b/src/fields/core/FieldNumber.vue
index 7e65857..03846ac 100644
--- a/src/fields/core/FieldNumber.vue
+++ b/src/fields/core/FieldNumber.vue
@@ -18,46 +18,42 @@
 
 <script setup lang="ts">
 import { toRefs } from 'vue'
-import type { NumberField, FieldProps, FieldPropRefs } from '@/resources/types/field/fields'
+import type { NumberField, FieldProps, FieldEmits, FieldPropRefs } from '@/resources/types/field/fields'
 import {
   useFormModel,
   useFieldAttributes,
-  useFieldValidate,
-  useFieldEmits
+  useValidation
 } from '@/composables'
 
 const props = defineProps<FieldProps<NumberField>>()
-const emits = defineEmits(useFieldEmits())
+const emits = defineEmits<FieldEmits>()
 
 const { field, model }: FieldPropRefs<NumberField> = toRefs(props)
 
 const { isDisabled, isRequired, isVisible, hint } = useFieldAttributes(model.value, field.value)
 const { currentModelValue } = useFormModel(model.value, field.value)
-const { errors, validate } = useFieldValidate(
+const { errors, onChanged, onBlur } = useValidation(
   model.value,
   field.value,
+  currentModelValue,
+  props.formOptions,
+  emits,
   isDisabled.value,
   isRequired.value,
   false
 )
 
-const onBlur = () => {
-  validate(currentModelValue.value).then((validationErrors) => {
-    emits('validated',
-      validationErrors.length === 0,
-      validationErrors,
-      field.value
-    )
-  })
-}
-
 const onFieldValueChanged = (event: Event) => {
   const target = event.target as HTMLInputElement
   errors.value = []
   const step = field.value.step ?? 1
   const isDecimalStep = step.toString().split('.')[1]
-  if (!isDecimalStep) return emits('onInput', parseInt(target.value))
-  emits('onInput', parseFloat(target.value))
+  if (!isDecimalStep) {
+    emits('onInput', parseInt(target.value))
+  } else {
+    emits('onInput', parseFloat(target.value))
+  }
+  onChanged()
 }
 
 defineExpose({ hint, errors, isVisible })
diff --git a/src/fields/core/FieldPassword.vue b/src/fields/core/FieldPassword.vue
index 0c3a98a..dfc85a8 100644
--- a/src/fields/core/FieldPassword.vue
+++ b/src/fields/core/FieldPassword.vue
@@ -19,25 +19,27 @@
 import { computed, type ComputedRef, toRefs } from 'vue'
 import {
   useFormModel,
-  useFieldValidate,
-  useFieldAttributes,
-  useFieldEmits
+  useValidation,
+  useFieldAttributes
 } from '@/composables'
-import type { PasswordField, FieldProps, FieldPropRefs } from '@/resources/types/field/fields'
+import type { PasswordField, FieldProps, FieldPropRefs, FieldEmits } from '@/resources/types/field/fields'
 
 const mediumRegex = new RegExp('^(((?=.*[a-z])(?=.*[A-Z]))|((?=.*[a-z])(?=.*[0-9]))|((?=.*[A-Z])(?=.*[0-9])))(?=.{6,})')
 const strongRegex = new RegExp('^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.{8,})')
 
 const props = defineProps<FieldProps<PasswordField>>()
-const emits = defineEmits(useFieldEmits())
+const emits = defineEmits<FieldEmits>()
 
 const { model, field }: FieldPropRefs<PasswordField> = toRefs(props)
 const { isRequired, isDisabled, isVisible, hint } = useFieldAttributes(model.value, field.value)
 const { currentModelValue } = useFormModel(model.value, field.value)
 
-const { errors, validate } = useFieldValidate(
+const { errors, onChanged, onBlur } = useValidation(
   model.value,
   field.value,
+  currentModelValue,
+  props.formOptions,
+  emits,
   isDisabled.value,
   isRequired.value,
   false
@@ -67,16 +69,7 @@ const meterStyle: ComputedRef<string> = computed(() => {
 const onFieldValueChanged = (event: Event) => {
   errors.value = []
   emits('onInput', (event.target as HTMLInputElement).value)
-}
-
-const onBlur = () => {
-  validate(currentModelValue.value).then((validationErrors) => {
-    emits('validated',
-      validationErrors.length === 0,
-      validationErrors,
-      field.value
-    )
-  })
+  onChanged()
 }
 
 defineExpose({ hint, errors, isVisible })
diff --git a/src/fields/core/FieldRadio.vue b/src/fields/core/FieldRadio.vue
index cdbb1ae..dae6f19 100644
--- a/src/fields/core/FieldRadio.vue
+++ b/src/fields/core/FieldRadio.vue
@@ -7,6 +7,8 @@
         :name="field.name"
         :value="option.value"
         :required="isRequired"
+        :disabled="isDisabled"
+        :readonly="isReadonly"
         :checked="currentModelValue === option.value"
         @change="onFieldValueChanged"
       >
@@ -18,23 +20,36 @@
 <script setup lang="ts">
 import { toRefs } from 'vue'
 import {
-  useFieldEmits,
   useFormModel,
-  useFieldAttributes
+  useFieldAttributes,
+  useValidation
 } from '@/composables'
-import type { RadioField, FieldProps, FieldPropRefs } from '@/resources/types/field/fields'
+import type { RadioField, FieldProps, FieldEmits, FieldPropRefs } from '@/resources/types/field/fields'
 
 const props = defineProps<FieldProps<RadioField>>()
-const emits = defineEmits(useFieldEmits())
+const emits = defineEmits<FieldEmits>()
 
 const { field, model }: FieldPropRefs<RadioField> = toRefs(props)
-const { isRequired, isVisible, hint } = useFieldAttributes(model.value, field.value)
+const { isRequired, isVisible, isDisabled, isReadonly, hint } = useFieldAttributes(model.value, field.value)
 const { currentModelValue } = useFormModel(model.value, field.value)
 
+const { errors, validate } = useValidation(
+  model.value,
+  field.value,
+  currentModelValue,
+  props.formOptions,
+  emits,
+  isDisabled.value,
+  isRequired.value,
+  isReadonly.value
+)
+
 const getFieldId = (optionName: string) => `${field.value.name}_${optionName}`
 
 const onFieldValueChanged = (event: Event) => {
+  errors.value = []
   emits('onInput', (event.target as HTMLInputElement).value)
+  validate()
 }
 
 defineExpose({ hint, isVisible })
diff --git a/src/fields/core/FieldSelect.vue b/src/fields/core/FieldSelect.vue
index 967f837..3ed1e36 100644
--- a/src/fields/core/FieldSelect.vue
+++ b/src/fields/core/FieldSelect.vue
@@ -68,23 +68,21 @@
 import { useMagicKeys } from '@vueuse/core'
 import { onClickOutside as vOnClickOutside } from '@/directives/onClickOutside'
 import { ref, toRefs, computed, type ComputedRef, type Ref } from 'vue'
-import type { FieldProps, FieldPropRefs, SelectField } from '@/resources/types/field/fields'
+import type { FieldProps, FieldPropRefs, SelectField, FieldEmits } from '@/resources/types/field/fields'
 import {
   useFieldAttributes,
-  useFieldEmits,
-  useFieldValidate,
+  useValidation,
   useFormModel
 } from '@/composables'
 import { FieldOption } from '@/resources/types/fieldAttributes'
 
 const props = defineProps<FieldProps<SelectField>>()
-const emits = defineEmits(useFieldEmits())
+const emits = defineEmits<FieldEmits>()
 const { controlLeft, metaLeft } = useMagicKeys()
 
 const isOpened: Ref<boolean> = ref(false)
 const { field, model }: FieldPropRefs<SelectField> = toRefs(props)
-const { hint, isVisible } = useFieldAttributes(model.value, field.value)
-const { errors, validate } = useFieldValidate(model.value, field.value)
+const { hint, isVisible, isDisabled, isReadonly, isRequired } = useFieldAttributes(model.value, field.value)
 
 /** Names of the selected values */
 const selectedNames: ComputedRef<string[]> = computed(() => {
@@ -106,6 +104,16 @@ const hasValue: ComputedRef<boolean> = computed(() => field.value.multiple ? cur
 const isPressingModifierKey: ComputedRef<boolean> = computed(() => metaLeft.value || controlLeft.value)
 
 const { currentModelValue } = useFormModel(model.value, field.value)
+const { errors, validate } = useValidation(
+  model.value,
+  field.value,
+  currentModelValue,
+  props.formOptions,
+  emits,
+  isDisabled.value,
+  isRequired.value,
+  isReadonly.value
+)
 
 /** Toggles the isOpened state when the input is clicked. */
 const onClickInput = () => isOpened.value = !isOpened.value
@@ -147,14 +155,7 @@ function selectOption (option: FieldOption) {
   if (!(metaLeft.value || controlLeft.value)) {
     isOpened.value = false
   }
-  validate(currentModelValue.value).then(validationErrors => {
-    emits(
-      'validated',
-      validationErrors.length === 0,
-      validationErrors,
-      field.value
-    )
-  })
+  validate()
 }
 
 defineExpose({ hint, isVisible, errors })
diff --git a/src/fields/core/FieldSelectNative.vue b/src/fields/core/FieldSelectNative.vue
index f43ce68..73198c8 100644
--- a/src/fields/core/FieldSelectNative.vue
+++ b/src/fields/core/FieldSelectNative.vue
@@ -6,7 +6,6 @@
     :required="isRequired"
     :disabled="isDisabled"
     @change="onFieldValueChanged"
-    @blur="onBlur"
   >
     <option disabled value="">
       {{ field.placeholder ?? 'Select a ' + field.name }}
@@ -19,36 +18,35 @@
 
 <script setup lang="ts">
 import { toRefs } from 'vue'
-import type { FieldPropRefs, FieldProps, SelectNativeField } from '@/resources/types/field/fields'
+import type { FieldPropRefs, FieldEmits, FieldProps, SelectNativeField } from '@/resources/types/field/fields'
 import {
-  useFieldEmits,
-  useFieldValidate,
   useFieldAttributes,
-  useFormModel
+  useFormModel,
+  useValidation
 } from '@/composables'
 
 const props = defineProps<FieldProps<SelectNativeField>>()
-const emits = defineEmits(useFieldEmits())
+const emits = defineEmits<FieldEmits>()
 
 const { field, model }: FieldPropRefs<SelectNativeField> = toRefs(props)
 
 const { isRequired, isDisabled, isVisible, hint } = useFieldAttributes(model.value, field.value)
 const { currentModelValue } = useFormModel(model.value, field.value)
-const { validate, errors } = useFieldValidate(model.value, field.value)
-
-const onBlur = () => {
-  validate(currentModelValue.value).then((validationErrors) => {
-    emits('validated',
-      validationErrors.length === 0,
-      validationErrors,
-      field.value
-    )
-  })
-}
+const { validate, errors } = useValidation(
+  model.value,
+  field.value,
+  currentModelValue,
+  props.formOptions,
+  emits,
+  isDisabled.value,
+  isRequired.value,
+  false
+)
 
 const onFieldValueChanged = (event: Event) => {
   errors.value = []
   emits('onInput', (event.target as HTMLSelectElement).value)
+  validate()
 }
 
 defineExpose({ hint, isVisible, errors })
diff --git a/src/fields/core/FieldSwitch.vue b/src/fields/core/FieldSwitch.vue
index ef01813..573d176 100644
--- a/src/fields/core/FieldSwitch.vue
+++ b/src/fields/core/FieldSwitch.vue
@@ -13,34 +13,36 @@
 
 <script setup lang="ts">
 import { toRefs } from 'vue'
-import type { SwitchField, FieldPropRefs, FieldProps } from '@/resources/types/field/fields.js'
+import type { SwitchField, FieldEmits, FieldPropRefs, FieldProps } from '@/resources/types/field/fields.js'
 import {
-  useFieldEmits,
   useFieldAttributes,
-  useFieldValidate,
+  useValidation,
   useFormModel
 } from '@/composables'
 
 
 const props = defineProps<FieldProps<SwitchField>>()
-const emits = defineEmits(useFieldEmits())
+const emits = defineEmits<FieldEmits>()
 
 const { field, model }: FieldPropRefs<SwitchField> = toRefs(props)
 
 const { isDisabled, isVisible, hint } = useFieldAttributes(model.value, field.value)
 const { currentModelValue } = useFormModel(model.value, field.value)
-const { errors, validate } = useFieldValidate(model.value, field.value)
+const { errors, validate } = useValidation(
+  model.value,
+  field.value,
+  currentModelValue,
+  props.formOptions,
+  emits,
+  isDisabled.value,
+  false,
+  false
+)
 
 const onFieldValueChanged = (event: Event) => {
   const target = event.target as HTMLInputElement
   emits('onInput', target.checked)
-  validate(target.checked).then(validationErrors => {
-    emits('validated',
-      validationErrors.length === 0,
-      validationErrors,
-      field.value
-    )
-  })
+  validate()
 }
 
 defineExpose({ isVisible, hint, errors })
diff --git a/src/fields/core/FieldText.vue b/src/fields/core/FieldText.vue
index 9f16bc8..868d897 100644
--- a/src/fields/core/FieldText.vue
+++ b/src/fields/core/FieldText.vue
@@ -17,10 +17,10 @@
 
 <script setup lang="ts">
 import { toRefs, computed, type ComputedRef } from 'vue'
-import type { FieldPropRefs, FieldProps, TextField } from '@/resources/types/field/fields'
-import { useFormModel, useFieldAttributes, useFieldValidate, useFieldEmits } from '@/composables'
+import type { FieldPropRefs, FieldProps, FieldEmits, TextField } from '@/resources/types/field/fields'
+import { useFormModel, useFieldAttributes, useValidation } from '@/composables'
 
-const emits = defineEmits(useFieldEmits())
+const emits = defineEmits<FieldEmits>()
 const props = defineProps<FieldProps<TextField>>()
 
 const { field, model }: FieldPropRefs<TextField> = toRefs(props)
@@ -29,27 +29,22 @@ const autoCompleteState: ComputedRef<string> = computed(() => field.value.autoco
 
 const { currentModelValue } = useFormModel(model.value, field.value)
 const { isRequired, isDisabled, isReadonly, isVisible, hint } = useFieldAttributes(model.value, field.value)
-const { errors, validate } = useFieldValidate(
+
+const { errors, onChanged, onBlur } = useValidation(
   model.value,
   field.value,
+  currentModelValue,
+  props.formOptions,
+  emits,
   isDisabled.value,
   isRequired.value,
-  false
+  isReadonly.value
 )
 
-const onBlur = () => {
-  validate(currentModelValue.value).then((validationErrors) => {
-    emits('validated',
-      validationErrors.length === 0,
-      validationErrors,
-      field.value
-    )
-  })
-}
-
 const onFieldValueChanged = (event: Event) => {
   errors.value = []
   emits('onInput', (event.target as HTMLInputElement).value)
+  onChanged()
 }
 
 defineExpose({ errors, hint, isVisible })
diff --git a/src/fields/core/FieldTextarea.vue b/src/fields/core/FieldTextarea.vue
index bd306c9..d1f8182 100644
--- a/src/fields/core/FieldTextarea.vue
+++ b/src/fields/core/FieldTextarea.vue
@@ -17,37 +17,36 @@
 
 <script setup lang="ts">
 import { toRefs } from 'vue'
-import type { FieldProps, FieldPropRefs, TextAreaField } from '@/resources/types/field/fields'
+import type { FieldProps, FieldEmits, FieldPropRefs, TextAreaField } from '@/resources/types/field/fields'
 import {
-  useFieldEmits,
-  useFieldValidate,
+  useValidation,
   useFieldAttributes,
   useFormModel
 } from '@/composables'
 
 
 const props = defineProps<FieldProps<TextAreaField>>()
-const emits = defineEmits(useFieldEmits())
+const emits = defineEmits<FieldEmits>()
 
 const { field, model }: FieldPropRefs<TextAreaField> = toRefs(props)
 
 const { isRequired, isDisabled, isReadonly, isVisible, hint } = useFieldAttributes(model.value, field.value)
 const { currentModelValue } = useFormModel(model.value, field.value)
-const { validate, errors } = useFieldValidate(model.value, field.value)
-
-const onBlur = () => {
-  validate(currentModelValue.value).then((validationErrors) => {
-    emits('validated',
-      validationErrors.length === 0,
-      validationErrors,
-      field.value
-    )
-  })
-}
+const { onChanged, errors, onBlur } = useValidation(
+  model.value,
+  field.value,
+  currentModelValue,
+  props.formOptions,
+  emits,
+  isDisabled.value,
+  isRequired.value,
+  isReadonly.value
+)
 
 const onFieldValueChanged = (event: Event) => {
   errors.value = []
   emits('onInput', (event.target as HTMLTextAreaElement).value)
+  onChanged()
 }
 
 defineExpose({ hint, errors, isVisible })
diff --git a/src/helpers/index.ts b/src/helpers/index.ts
index 2463afa..31a5835 100644
--- a/src/helpers/index.ts
+++ b/src/helpers/index.ts
@@ -1,4 +1,27 @@
 import type { Field } from '@/resources/types/field/fields'
+import type { ValidatorMap } from '@/resources/types/generic'
+import type { TValidatorFunction } from '@/resources/types/functions'
+import validators from '@/validators'
+
+/**
+ * Get the corresponding validator function for a given string, or function. If a function is passed, the function is
+ * assumed to be the validator to use and thus return. If no argument is passed, we'll just return a function that
+ * will always return true, thus assuming the value is always valid.
+ * @param validator
+ */
+export function getValidator (validator: string | TValidatorFunction | undefined): TValidatorFunction {
+  if (validator === undefined) return (): boolean => true
+
+  if (isFunction(validator)) return <TValidatorFunction>validator
+
+  if (isString(validator)) {
+    if ((validators as ValidatorMap)[<string>validator] === undefined) {
+      throw new Error('Invalid validator: ' + validator)
+    }
+    return (validators as ValidatorMap)[<string>validator]
+  }
+  return (): boolean => true
+}
 
 /**
  * Determine if value is of type Function.
diff --git a/src/index.ts b/src/index.ts
index ff668ab..706ceea 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,5 +1,22 @@
 import { App } from 'vue'
-import { FieldPluginOptions, PluginOptions } from '@/resources/types/generic'
+import type { FieldPluginOptions, PluginOptions } from '@/resources/types/generic'
+import type { FieldProps, FieldPropRefs, FieldEmits } from '@/resources/types/field/fields'
+import type { FieldBase } from '@/resources/types/field/base'
+import type { FieldOption, FormModel } from '@/resources/types/fieldAttributes'
+import type {
+  TDynamicAttributeBooleanFunction,
+  TDynamicAttributeStringFunction,
+  TValidatorFunction,
+  TOnValidatedFunction
+} from '@/resources/types/functions'
+import type {
+  ValidationTrigger,
+  FormGeneratorSchema,
+  FieldExposedValues,
+  FieldComponent,
+  FormOptions,
+  FieldValidation
+} from '@/resources/types/generic'
 
 import { setMessages } from '@/validators/messages'
 import { isObject } from '@/helpers'
@@ -46,3 +63,24 @@ export {
   useFieldValidate,
   validators
 }
+
+export type {
+  FieldProps,
+  FieldEmits,
+  FieldPropRefs,
+  FieldPluginOptions,
+  PluginOptions,
+  FieldBase,
+  FieldOption,
+  FormModel,
+  TDynamicAttributeBooleanFunction,
+  TDynamicAttributeStringFunction,
+  TValidatorFunction,
+  TOnValidatedFunction,
+  ValidationTrigger,
+  FormGeneratorSchema,
+  FieldExposedValues,
+  FieldComponent,
+  FormOptions,
+  FieldValidation
+}
diff --git a/src/resources/types/field/base.ts b/src/resources/types/field/base.ts
index 33ed78b..432c33a 100644
--- a/src/resources/types/field/base.ts
+++ b/src/resources/types/field/base.ts
@@ -5,6 +5,7 @@ import type {
   TValidatorFunction
 } from '@/resources/types/functions'
 import type { FieldOption } from '@/resources/types/fieldAttributes'
+import type { ValidationTrigger } from '@/resources/types/generic'
 
 /**
  * The base of every field type.
@@ -20,8 +21,9 @@ export type FieldBase = {
   readonly?: boolean | TDynamicAttributeBooleanFunction;
   disabled?: boolean | TDynamicAttributeBooleanFunction;
   hint?: string | TDynamicAttributeStringFunction;
-  validator?: TValidatorFunction | TValidatorFunction[],
-  onValidated?: TOnValidatedFunction
+  validator?: TValidatorFunction | TValidatorFunction[];
+  onValidated?: TOnValidatedFunction;
+  validate?: ValidationTrigger;
   noLabel?: boolean;
 }
 
diff --git a/src/resources/types/field/fields.ts b/src/resources/types/field/fields.ts
index 6eb651b..dec587c 100644
--- a/src/resources/types/field/fields.ts
+++ b/src/resources/types/field/fields.ts
@@ -100,17 +100,22 @@ export type TextAreaField = FieldBase & PlaceholderField & {
 export type Field = TextField | RadioField | ChecklistField | SelectField | MaskField | PasswordField | ButtonField |
   NumberField | ColorField | CheckboxField | ObjectField | ResetField | SelectNativeField | SubmitField | SwitchField |
   TextAreaField
-export type FieldValue = number | string | number[] | string[]
+export type FieldValue = number | string | number[] | string[] | boolean | boolean[]
 
 export interface FieldPropRefs<T extends Field=Field> {
   field: Ref<T>,
   model: Ref<FormModel>
 }
 
+export type FieldEmits = {
+  validated: [isValid: boolean, errors: string[], field: Field];
+  onInput: [value: FieldValue];
+}
+
 export interface FieldProps<T extends Field=Field> {
   id: string;
   formGenerator?: object;
-  formOptions?: FormOptions;
+  formOptions: FormOptions;
   field: T;
   model: Record<string, unknown>;
 }
diff --git a/src/resources/types/generic.ts b/src/resources/types/generic.ts
index f882c24..2ffb06a 100644
--- a/src/resources/types/generic.ts
+++ b/src/resources/types/generic.ts
@@ -17,6 +17,8 @@ export type PluginOptions = {
   excludedComponents?: string[];
 }
 
+export type ValidationTrigger = 'onChanged' | 'onBlur';
+
 export type FieldPluginOptions = {
   aliases?: PluginOptions['aliases'];
   excludedComponents?: PluginOptions['excludedComponents'];
@@ -34,7 +36,7 @@ export type FormGeneratorSchema = {
 }
 
 export type FormGroupProps = {
-  formOptions?: FormOptions;
+  formOptions: FormOptions;
   model: FormModel;
   field: Field;
   errors?: string[];
@@ -64,6 +66,7 @@ export type FieldComponent = ComponentPublicInstance<FieldProps, FieldExposedVal
 
 export type FormOptions = {
   idPrefix?: string;
+  validate?: ValidationTrigger;
 }
 
 export type FieldValidation = {
diff --git a/tests/components/fields/FieldColor.spec.js b/tests/components/fields/FieldColor.spec.js
index 2e9e082..5d9d948 100644
--- a/tests/components/fields/FieldColor.spec.js
+++ b/tests/components/fields/FieldColor.spec.js
@@ -1,4 +1,8 @@
-import { mountFormGenerator, generatePropsSingleField, generateSchemaSingleField } from '@test/_resources/utils.js'
+import {
+  mountFormGenerator,
+  generatePropsSingleField,
+  generateSchemaSingleField
+} from '@test/_resources/utils.js'
 import { mount, config } from '@vue/test-utils'
 import { describe, it, expect, beforeAll } from 'vitest'
 
@@ -82,4 +86,24 @@ describe('FieldColor', () => {
     expect(wrapper.find('input[type=text]').attributes().value).toBe('#ff0000')
   })
 
+  it('Should validate onBlur, by default', async () => {
+    const formWrapper = mountFormGenerator(form.schema, form.model)
+    const wrapper = formWrapper.findComponent(FieldColor)
+    await wrapper.find('input[type=color]').trigger('blur')
+    expect(wrapper.emitted()).toHaveProperty('validated')
+  })
+
+  it('Should validate onChanged, if set', async () => {
+    const schema = { ...form.schema }
+    schema.fields[0].validate = 'onChanged'
+    const formWrapper = mountFormGenerator(schema, form.model)
+    const wrapper = formWrapper.findComponent(FieldColor)
+
+    await wrapper.find('input[type=color]').trigger('blur')
+    expect(wrapper.emitted()).not.toHaveProperty('validated')
+
+    await wrapper.find('input[type=text]').setValue('#efefef')
+    expect(wrapper.emitted()).toHaveProperty('validated')
+  })
+
 })
diff --git a/tests/components/fields/FieldMask.spec.js b/tests/components/fields/FieldMask.spec.js
index 5b205ae..e5cc5a3 100644
--- a/tests/components/fields/FieldMask.spec.js
+++ b/tests/components/fields/FieldMask.spec.js
@@ -1,4 +1,8 @@
-import { mountFormGenerator, generatePropsSingleField, generateSchemaSingleField } from '@test/_resources/utils'
+import {
+  mountFormGenerator,
+  generatePropsSingleField,
+  generateSchemaSingleField
+} from '@test/_resources/utils'
 import { mount, config } from '@vue/test-utils'
 import { describe, it, expect, beforeAll } from 'vitest'
 
@@ -68,4 +72,22 @@ describe('FieldMask', () => {
     expect(formWrapper.vm.model.maskModel).toBe('1234123412341234')
   })
 
+  it('Should validate onBlur, by default', async () => {
+    const formWrapper = mountFormGenerator(form.schema, form.model)
+
+    const textField = formWrapper.findComponent(FieldMask)
+    await textField.find('input').trigger('blur')
+    expect(textField.emitted()).toHaveProperty('validated')
+  })
+
+  it('Should validate onChanged, if set', async () => {
+    const schema = { ...form.schema }
+    schema.fields[0].validate = 'onChanged'
+    const formWrapper = mountFormGenerator(form.schema, form.model)
+
+    const textField = formWrapper.findComponent(FieldMask)
+    await textField.find('input').setValue('1234 1234 1234 1234')
+    expect(textField.emitted()).toHaveProperty('validated')
+  })
+
 })
diff --git a/tests/components/fields/FieldPassword.spec.js b/tests/components/fields/FieldPassword.spec.js
index 399d1e5..7a4631b 100644
--- a/tests/components/fields/FieldPassword.spec.js
+++ b/tests/components/fields/FieldPassword.spec.js
@@ -128,4 +128,13 @@ describe('FieldPassword', () => {
     expect(errorContainer.find('.error').element.innerHTML).toBe('Field is invalid')
   })
 
+  it('Should validate onChanged, if set', async () => {
+    const schema = { ...form.schema }
+    schema.fields[0].validate = 'onChanged'
+    const formWrapper = mountFormGenerator(schema, form.model)
+    const wrapper = formWrapper.findComponent(FieldPassword)
+    await wrapper.find('input[type=password]').setValue('testpassword')
+    expect(wrapper.emitted()).toHaveProperty('validated')
+  })
+
 })
diff --git a/tests/components/fields/FieldRadio.spec.js b/tests/components/fields/FieldRadio.spec.js
index 39bd952..e0f8e44 100644
--- a/tests/components/fields/FieldRadio.spec.js
+++ b/tests/components/fields/FieldRadio.spec.js
@@ -83,4 +83,11 @@ describe('FieldRadio', () => {
     expect(formWrapper.vm.model.radioModel).toBe('value_2')
   })
 
+  it('Should validate onChanged, by default', async () => {
+    const formWrapper = mountFormGenerator(form.schema, form.model)
+    const wrapper = formWrapper.findComponent(FieldRadio)
+    await wrapper.find('input[type=radio]').setChecked()
+    expect(wrapper.emitted()).toHaveProperty('validated')
+  })
+
 })
diff --git a/tests/components/fields/FieldText.spec.js b/tests/components/fields/FieldText.spec.js
index fe42a6b..3a7e5f1 100644
--- a/tests/components/fields/FieldText.spec.js
+++ b/tests/components/fields/FieldText.spec.js
@@ -1,4 +1,4 @@
-import { generateSchemaSingleField, generatePropsSingleField, mountFormGenerator } from '@test/_resources/utils.js'
+import { generateSchemaSingleField, generatePropsSingleField, mountFormGenerator, clearEmittedEvents } from '@test/_resources/utils.js'
 import { mount, config } from '@vue/test-utils'
 import { describe, it, expect } from 'vitest'
 
@@ -60,4 +60,22 @@ describe('FieldText', () => {
     expect(formWrapper.vm.model.modelText).toBe('I have the high ground')
   })
 
+  it('Should validate onBlur, by default', async () => {
+    const formWrapper = mountFormGenerator(form.schema, form.model)
+    const textField = formWrapper.findComponent(FieldText)
+    await textField.find('input').trigger('blur')
+    expect(textField.emitted()).toHaveProperty('validated')
+  })
+
+  it('Should validate onChanged, if set', async () => {
+    const schema = { ...form.schema }
+    schema.fields[0].validate = 'onChanged'
+    schema.fields[0].validator = (v) => v === 'Hello there!'
+    const formWrapper = mountFormGenerator(schema, form.model)
+    const textField = formWrapper.findComponent(FieldText)
+    clearEmittedEvents(textField)
+    await textField.find('input').setValue('Hello there!')
+    expect(textField.emitted()).toHaveProperty('validated')
+  })
+
 })
diff --git a/tests/components/fields/FieldTextarea.spec.js b/tests/components/fields/FieldTextarea.spec.js
index 1a288e6..b618b5f 100644
--- a/tests/components/fields/FieldTextarea.spec.js
+++ b/tests/components/fields/FieldTextarea.spec.js
@@ -55,4 +55,20 @@ describe('FieldTextarea', () => {
     expect(formWrapper.vm.model.textModel).toBe('I have the high ground')
   })
 
+  it('Should validate onBlur, by default', async () => {
+    const formWrapper = mountFormGenerator(form.schema, form.model)
+    const textAreaField = formWrapper.findComponent(FieldTextarea)
+    await textAreaField.find('textarea').trigger('blur')
+    expect(textAreaField.emitted()).toHaveProperty('validated')
+  })
+
+  it('Should validate onChanged, if set', async () => {
+    const schema = { ...form.schema }
+    schema.fields[0].validate = 'onChanged'
+    const formWrapper = mountFormGenerator(schema, form.model)
+    const textAreaField = formWrapper.findComponent(FieldTextarea)
+    await textAreaField.find('textarea').setValue('Hello!')
+    expect(textAreaField.emitted()).toHaveProperty('validated')
+  })
+
 })
diff --git a/tests/composables/useValidation.spec.js b/tests/composables/useValidation.spec.js
new file mode 100644
index 0000000..6841560
--- /dev/null
+++ b/tests/composables/useValidation.spec.js
@@ -0,0 +1,138 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { useValidation } from '@/composables/useValidation'
+import { ref, nextTick } from 'vue'
+
+const createBaseField = (overrides = {}) => ({
+  name: 'testField',
+  model: 'test',
+  type: 'text',
+  validate: 'onBlur',
+  ...overrides
+})
+
+const model = {
+  test: ''
+}
+const emits = vi.fn()
+
+describe('useValidation', () => {
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('should initialize with empty errors', () => {
+    const field = createBaseField()
+    const value = ref('')
+
+    const { errors } = useValidation(
+      model,
+      field,
+      value,
+      {},
+      emits,
+      false,
+      false,
+      false
+    )
+
+    expect(errors.value).toEqual([])
+  })
+
+  it('Should validate on blur when validate is set to onBlur', async () => {
+    const field = createBaseField({
+      validate: 'onBlur',
+      validator: [ (value) => value.length > 0 ]
+    })
+    const value = ref('')
+
+    const { onBlur } = useValidation(
+      model,
+      field,
+      value,
+      {},
+      emits,
+      false,
+      true,
+      false
+    )
+
+    await onBlur()
+
+    expect(emits).toHaveBeenCalled()
+  })
+
+  it('Should validate on change when validate is set to onChanged', async () => {
+    const field = createBaseField({
+      validate: 'onChanged',
+      validator: [ (value) => value.length > 0 ]
+    })
+    const value = ref('')
+
+    const { onChanged } = useValidation(
+      model,
+      field,
+      value,
+      {},
+      emits,
+      false,
+      true,
+      false
+    )
+
+    await onChanged()
+
+    expect(emits).toHaveBeenCalled()
+  })
+
+  it('Should handle multiple validators', async () => {
+    const field = createBaseField({
+      validator: [
+        (value) => value.length >= 3,
+        (value) => value.length <= 10
+      ]
+    })
+    const value = ref('a')
+
+    const { onBlur, errors } = useValidation(
+      model,
+      field,
+      value,
+      {},
+      emits,
+      false,
+      true,
+      false
+    )
+
+    await onBlur()
+    await nextTick()
+
+    expect(errors.value).toContain('Field is invalid')
+  })
+
+  it('Should clear errors when validation passes', async () => {
+    const field = createBaseField({
+      validator: [ (value) => value.length > 0 ]
+    })
+    const value = ref('')
+
+    const { onBlur, errors } = useValidation(
+      model,
+      field,
+      value,
+      {},
+      emits,
+      false,
+      true,
+      false
+    )
+
+    await onBlur()
+    expect(errors.value.length).toBeGreaterThan(0)
+
+    value.value = 'valid value'
+    await onBlur()
+    expect(errors.value).toEqual([])
+  })
+})
\ No newline at end of file