diff --git a/src/FormHandler.ts b/src/FormHandler.ts
index a056d79..abe26a0 100644
--- a/src/FormHandler.ts
+++ b/src/FormHandler.ts
@@ -1,5 +1,5 @@
 import useFormHandler from './useFormHandler';
-import { FormHandlerParams, FormHandlerReturn } from './types';
+import { FormHandlerParams, FormHandlerReturn } from './types/formHandler';
 import { defineComponent, PropType } from 'vue';
 
 export default defineComponent({
@@ -8,15 +8,15 @@ export default defineComponent({
         initialValues: Object as PropType<FormHandlerParams['initialValues']>,
         interceptor: Function as PropType<FormHandlerParams['interceptor']>,
         validate: Function as PropType<FormHandlerParams['validate']>,
-        options: Object as PropType<FormHandlerParams['options']>
+        validationMode: Object as PropType<FormHandlerParams['validationMode']>
     },
-    setup: (props, {slots}) => {
-        const {...formHandler} = useFormHandler({
+    setup: (props, { slots }) => {
+        const { ...formHandler } = useFormHandler({
             initialValues: props.initialValues,
             interceptor: props.interceptor,
             validate: props.validate,
-            options: props.options
+            validationMode: props.validationMode
         })
-        return () => slots.default && slots.default({...formHandler} as FormHandlerReturn)
+        return () => slots.default && slots.default({ ...formHandler } as FormHandlerReturn)
     }
 })
\ No newline at end of file
diff --git a/src/constants.ts b/src/core/constants.ts
similarity index 93%
rename from src/constants.ts
rename to src/core/constants.ts
index 6143919..897155e 100644
--- a/src/constants.ts
+++ b/src/core/constants.ts
@@ -1,4 +1,4 @@
-import { BaseControlEmits } from "./types"
+import { BaseControlEmits } from "../types"
 
 export const DEFAULT_FIELD_VALUE = null;
 
diff --git a/src/index.ts b/src/index.ts
index cfd473d..5f60bb8 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,5 +1,5 @@
 export { default as FormHandler } from './FormHandler'
 export { default as useFormHandler } from './useFormHandler'
 
-export * from './constants'
+export * from './core/constants'
 export * from './types'
\ No newline at end of file
diff --git a/src/logic/getDefaultFieldValue.ts b/src/logic/getDefaultFieldValue.ts
index e5aea9f..e53729c 100644
--- a/src/logic/getDefaultFieldValue.ts
+++ b/src/logic/getDefaultFieldValue.ts
@@ -1,5 +1,5 @@
 import { isCheckboxInput } from "../utils"
-import { DEFAULT_FIELD_VALUE } from "../constants"
+import { DEFAULT_FIELD_VALUE } from "../core/constants"
 
 export default (el: any) => {
     if (!el) {
diff --git a/src/logic/getNativeFieldValue.ts b/src/logic/getNativeFieldValue.ts
index c5a1ded..c5ad313 100644
--- a/src/logic/getNativeFieldValue.ts
+++ b/src/logic/getNativeFieldValue.ts
@@ -1,4 +1,4 @@
-import { DEFAULT_FIELD_VALUE } from './../constants';
+import { DEFAULT_FIELD_VALUE } from '../core/constants';
 import { isCheckboxInput, isMultipleSelect, isRadioInput } from "../utils"
 
 export default (el: any) => {
diff --git a/src/logic/index.ts b/src/logic/index.ts
index d1f1a03..45d83d2 100644
--- a/src/logic/index.ts
+++ b/src/logic/index.ts
@@ -1,2 +1,6 @@
 export { default as getNativeFieldValue } from './getNativeFieldValue'
-export { default as getDefaultFieldValue } from './getNativeFieldValue'
\ No newline at end of file
+export { default as getDefaultFieldValue } from './getDefaultFieldValue'
+export { default as validateField } from './validateField'
+export { default as validateForm } from './validateForm'
+export { default as refFn } from './refFn'
+export { default as transformValidations } from './transformValidations'
\ No newline at end of file
diff --git a/src/logic/refFn.ts b/src/logic/refFn.ts
new file mode 100644
index 0000000..5718781
--- /dev/null
+++ b/src/logic/refFn.ts
@@ -0,0 +1,50 @@
+import { Refs, FieldReference } from "../types";
+import { isCheckboxInput, isMultipleSelect, isNativeControl, isRadioInput } from "../utils"
+
+export default (name: string, _refs: Refs, values: any) => (fieldRef: any) => {
+    if (!fieldRef) {
+        delete _refs[name]
+        return
+    }
+    if (!fieldRef.nodeName || !isNativeControl(fieldRef)) {
+        //TODO: Correctly type this in order to expect a fixed data structure
+        _refs[name].ref = {
+            type: 'custom'
+        }
+        return
+    }
+    const isFirstRegister = _refs[name] && (!_refs[name].ref
+        || (Array.isArray(_refs[name].ref)
+            && isRadioInput(fieldRef)
+            && (!(_refs[name].ref as FieldReference[])
+                .some((option: any) => option.value === fieldRef.value))))
+    if (isFirstRegister) {
+        _refs[name].ref = isRadioInput(fieldRef)
+            ? [...(_refs[name].ref as FieldReference[] || [])
+                , fieldRef]
+            : fieldRef
+    }
+    if (isRadioInput(fieldRef)) {
+        if (isFirstRegister && fieldRef.checked) {
+            values[name] = fieldRef.value
+            return
+        }
+        fieldRef.checked = (values[name] === fieldRef.value)
+        return
+    }
+    if (isCheckboxInput(fieldRef)) {
+        if (isFirstRegister) {
+            values[name] = !!fieldRef.checked
+            return
+        }
+        fieldRef.checked = !!values[name]
+        return
+    }
+    if (isMultipleSelect(fieldRef)) {
+        [...fieldRef.options].forEach((option: any, index) => {
+            fieldRef[index].selected = !!values[name]?.includes(option.value)
+        })
+        return
+    }
+    fieldRef.value = values[name]
+};
\ No newline at end of file
diff --git a/src/logic/transformValidations.ts b/src/logic/transformValidations.ts
new file mode 100644
index 0000000..a791104
--- /dev/null
+++ b/src/logic/transformValidations.ts
@@ -0,0 +1,38 @@
+import { ValidationsConfiguration, ValidationWithMessage, Validations } from "../types";
+import { max, maxLength, min, minLength, pattern, required } from "../utils";
+
+export default (validations: ValidationsConfiguration = {}): Validations => {
+    const transformed: Validations = {};
+    if (!!validations.required) {
+        transformed.required = typeof validations.required === 'string'
+            ? required(validations.required)
+            : required();
+    }
+    if (validations.min) {
+        transformed.min = typeof validations.min === 'number'
+            ? min(validations.min)
+            : min(validations.min.value as number, validations.min.message);
+    }
+    if (validations.max) {
+        transformed.max = typeof validations.max === 'number'
+            ? max(validations.max)
+            : max(validations.max.value as number, validations.max.message);
+    }
+    if (validations.minLength) {
+        transformed.minLength = typeof validations.minLength === 'number'
+            ? minLength(validations.minLength)
+            : minLength(validations.minLength.value as number, validations.minLength.message);
+    }
+    if (validations.maxLength) {
+        transformed.maxLength = typeof validations.maxLength === 'number'
+            ? maxLength(validations.maxLength)
+            : maxLength(validations.maxLength.value as number, validations.maxLength.message);
+    }
+    if (validations.pattern) {
+        transformed.pattern = !(validations.pattern as ValidationWithMessage)?.value
+            ? pattern(validations.pattern as RegExp)
+            : pattern((validations.pattern as ValidationWithMessage).value as RegExp, (validations.pattern as ValidationWithMessage).message as string);
+    }
+    return transformed;
+}
+
diff --git a/src/logic/validateField.ts b/src/logic/validateField.ts
new file mode 100644
index 0000000..881a13b
--- /dev/null
+++ b/src/logic/validateField.ts
@@ -0,0 +1,20 @@
+import { ValidateFieldParams } from './../types/logic';
+
+export default async ({ name, values, formState, _refs }: ValidateFieldParams): Promise<void> => {
+    if (!Object.keys(_refs[name]._validations).length) {
+        return
+    }
+    if (_refs[name]._disabled) {
+        return
+    }
+    for (const [validationName, validation] of Object.entries(_refs[name]._validations)) {
+        const result = await validation(values[name])
+        formState.errors[name] = {
+            ...(result !== true && { [validationName]: result })
+        }
+        if (result !== true) {
+            break;
+        }
+        delete formState.errors[name]
+    }
+}
\ No newline at end of file
diff --git a/src/logic/validateForm.ts b/src/logic/validateForm.ts
new file mode 100644
index 0000000..1dea11d
--- /dev/null
+++ b/src/logic/validateForm.ts
@@ -0,0 +1,8 @@
+import { ValidateFormParams } from './../types/logic';
+import validateField from "./validateField"
+
+export default async (params: ValidateFormParams) => {
+    for (const name of Object.keys(params.values)) {
+        await validateField({ ...params, name })
+    }
+}
\ No newline at end of file
diff --git a/src/playground/App.vue b/src/playground/App.vue
index 18d2afa..b3d4e24 100644
--- a/src/playground/App.vue
+++ b/src/playground/App.vue
@@ -1,61 +1,36 @@
 <template>
-    <h2> VSSTS </h2>
-    <input v-bind="register('hello')"><br>
-    <input type="number" v-bind="register('number')"><br>
-    <input type="radio" value="female" name="test"> Female<br>
-    <input type="radio" value="other" name="test"> Other<br>
-    <br>
-    <input type="radio" value="male" v-bind="register('gender')"> Male<br>
-    <input type="radio" value="female" v-bind="register('gender')"> Female<br>
-    <input type="radio" value="other" v-bind="register('gender')"> Other<br>
-    <br>
-    <input type="checkbox" v-bind="register('checkbox')"> Other <br>
-    <br>
-    <select v-bind="register('select1')" style="min-width:300px">
-        <option value="">--- Please select option ---</option>
-        <option value="dog">Dog</option>
-        <option value="cat">Cat</option>
-        <option value="hamster">Hamster</option>
-        <option value="parrot">Parrot</option>
-        <option value="spider">Spider</option>
-        <option value="goldfish">Goldfish</option>
-    </select><br>
-    <br>
-    <select v-bind="register('select')" style="min-width:300px" multiple>
-        <option value="dog">Dog</option>
-        <option value="cat">Cat</option>
-        <option value="hamster">Hamster</option>
-        <option value="parrot">Parrot</option>
-        <option value="spider">Spider</option>
-        <option value="goldfish">Goldfish</option>
-    </select><br>
-    <br>
-    <textarea v-bind="register('textArea')"></textarea>
-    <pre>{{ values }}</pre>
-    <pre>{{ formState }}</pre>
-    <pre>{{ modifiedValues() }}</pre>
-    <template v-if="!!dynamic">
-        <input v-bind="register('dynamic')"> <br>
-    </template> <br>
-
-
-    <button @click="setValue('gender', 'female')">Set radio to female</button>
-    <button @click="setValue('select', ['dog', 'cat'])">Set select to dog & cat</button>
-    <button @click="resetField('checkbox')">Reset checkbox</button>
-    <button @click="dynamic = true">Add dynamic field</button>
+    <form @submit.prevent="() => handleSubmit(submitForm)">
+        <h2> VSSTS </h2>
+        <input v-bind="register('hello', {
+            required: 'Something is required',
+            pattern: /^[A-Za-z]+$/i
+        })"><br>
+        <input type="number" v-bind="register('hello2', {
+            min: 5,
+            max: 10
+        })"><br>
+        <input v-bind="register('hello3', {
+            minLength: {
+                value: 5,
+                message: 'Min length is 5'
+            },
+            maxLength: 20,
+            disabled: values.hello2 > 5
+        })"><br>
+        <br>
+        <button>Submit</button>
+        <pre>{{ values }}</pre>
+        <pre>{{ formState }}</pre>
+    </form>
 </template>
 
 <script setup lang="ts">
 import useFormHandler from '../useFormHandler';
-import { ref } from 'vue'
-const dynamic = ref(false)
-
-const { register, values, formState, resetField, setValue, modifiedValues } = useFormHandler({
-    initialValues: {
-        gender: 'male'
-    }
-});
 
+const { register, handleSubmit, values, formState } = useFormHandler({});
+const submitForm = (values: any) => {
+    console.log(values)
+}
 </script>
 
 <style>
diff --git a/src/types/baseControl.ts b/src/types/baseControl.ts
new file mode 100644
index 0000000..b09c83f
--- /dev/null
+++ b/src/types/baseControl.ts
@@ -0,0 +1,40 @@
+/** Props for a base control */
+export interface BaseControlProps {
+    /** Name of the control */
+    name: string,
+
+    /** Current errors of the control */
+    errors: string[]
+
+    /** Value binding for native inputs */
+    ref: any,
+
+    /** Value binding for custom inputs */
+    modelValue: any,
+
+    /** Handler binding for custom inputs */
+    'onUpdate:modelValue': (value: any) => void,
+
+    /** Disabled state of the field*/
+    disabled?: boolean
+
+    /** Current dirty state of the control */
+    isDirty?: boolean
+
+    /** Current touched state of the control */
+    isTouched?: boolean
+
+    /** Handler binding for native inputs */
+    onChange?: (el: any) => void,
+
+    /** Blur handler */
+    onBlur?: () => void,
+
+    /** Clear handler */
+    onClear?: () => void,
+}
+
+/** Each emit the handler could be expecting */
+export type EmitOption = 'update:modelValue' | 'blur' | 'clear'
+/** Emit collection for a base control */
+export type BaseControlEmits = EmitOption[]
\ No newline at end of file
diff --git a/src/types.ts b/src/types/formHandler.ts
similarity index 67%
rename from src/types.ts
rename to src/types/formHandler.ts
index 677045e..2f1d4a1 100644
--- a/src/types.ts
+++ b/src/types/formHandler.ts
@@ -1,40 +1,4 @@
-/** Props for a base control */
-export interface BaseControlProps {
-    /** Name of the control */
-    name: string,
-
-    /** Current errors of the control */
-    errors?: string[]
-
-    /** Current dirty state of the control */
-    isDirty?: boolean
-
-    /** Current touched state of the control */
-    isTouched?: boolean
-
-    /** Value binding for native inputs */
-    ref: any,
-
-    /** Handler binding for native inputs */
-    onChange?: (el: any) => void,
-
-    /** Value binding for custom inputs */
-    modelValue: any,
-
-    /** Handler binding for custom inputs */
-    'onUpdate:modelValue': (value: any) => void,
-
-    /** Blur handler */
-    onBlur?: () => void,
-
-    /** Clear handler */
-    onClear?: () => void,
-}
-
-/** Each emit the handler could be expecting */
-export type EmitOption = 'update:modelValue' | 'blur' | 'clear'
-/** Emit collection for a base control */
-export type BaseControlEmits = EmitOption[]
+import { RegisterOptions, Register } from "./register"
 
 export interface FormState {
     /** Boolean holding the dirty state of the form */
@@ -56,41 +20,9 @@ export interface FormState {
     errors: Record<string, any>
 }
 
-/** Function returning true for correct validation or a string with an error if it's invalid */
-export type ValidationFn = (_: any) => Promise<boolean | string> | boolean | string
-
-/** Validations collection as an object */
-export type Validations = Record<string, ValidationFn>
-
-export interface RegisterOptions {
-    /** Indicates wether the input is native or not, set to false if the extra listeners are not desired */
-    native?: boolean
-
-    /** Indicates wether the input is clearable or not */
-    clearable?: boolean
-
-    /** Default value for the field */
-    defaultValue?: any
-
-    /** Required indicator for the control */
-    required?: boolean
-
-    /** Validations for the field */
-    validations?: Validations
-
-    /** Set to true if you want to bind also dirty and touched states */
-    withDetails?: boolean
-}
-
-/** Gets the initial/default/fallback value for a control */
-export type GetInitValueForControl = (name: string) => any
-
 /** Field initializer */
 export type InitControl = (name: string, options: RegisterOptions) => void
 
-/** Function that allows you to register a control to interact with the form */
-export type Register = (name: string, options?: RegisterOptions) => BaseControlProps
-
 /** Sets dirty state of a control */
 export type SetDirty = (name: string, dirty: boolean) => void
 
@@ -133,6 +65,9 @@ export type HandleSubmitSuccessFn = (values: Object) => void
 /** Optional function to be called after a form failed to submit */
 export type HandleSubmitErrorFn = (errors: Object) => void
 
+/** Checks for the validity of the form before submitting */
+export type IsValidForm = () => Promise<boolean>
+
 /** Submit handler */
 export type HandleSubmit = (successFn: HandleSubmitSuccessFn, errorFn?: HandleSubmitErrorFn) => void
 
@@ -167,11 +102,6 @@ export interface InterceptorParams {
     /** Function that returns the modified values of the form */
     modifiedValues: ModifiedValues
 }
-
-export interface FormHandlerOptions {
-    /** Set to submit if validations are desired before sending the form */
-    validationBehaviour?: 'always' | 'submit'
-}
 export interface FormHandlerParams {
     /** Values to initialize the form */
     initialValues?: Record<string, any>
@@ -182,10 +112,9 @@ export interface FormHandlerParams {
     /** Validation function to execute before submitting (when using this individual validations are invalidated) */
     validate?: () => Promise<boolean> | boolean
 
-    /** Options for the form handler */
-    options?: FormHandlerOptions
+    /** Validation behavior options */
+    validationMode?: 'onChange' | 'onBlur' | 'onSubmit' | 'always'
 }
-
 export interface FormHandlerReturn {
     /** Current form values */
     values: Record<string, any>
diff --git a/src/types/index.ts b/src/types/index.ts
new file mode 100644
index 0000000..47ad96a
--- /dev/null
+++ b/src/types/index.ts
@@ -0,0 +1,6 @@
+export * from './formHandler'
+export * from './logic'
+export * from './register'
+export * from './validations'
+export * from './refs'
+export * from './baseControl'
\ No newline at end of file
diff --git a/src/types/logic.ts b/src/types/logic.ts
new file mode 100644
index 0000000..892503e
--- /dev/null
+++ b/src/types/logic.ts
@@ -0,0 +1,14 @@
+import { FormState } from "./formHandler"
+import { Refs } from "./refs"
+
+export interface ValidateFormParams {
+    _refs: Refs
+    formState: FormState
+    values: Record<string, any>
+}
+
+export interface ValidateFieldParams extends ValidateFormParams {
+    name: string
+}
+
+export interface TriggerValidationParams extends ValidateFieldParams { }
\ No newline at end of file
diff --git a/src/types/refs.ts b/src/types/refs.ts
new file mode 100644
index 0000000..65c2561
--- /dev/null
+++ b/src/types/refs.ts
@@ -0,0 +1,19 @@
+import { Validations } from "./register";
+
+export interface FieldReference {
+    type: 'custom' | 'select' | 'select-multiple' | 'radio' | 'checkbox' | 'input' | 'textarea' | 'file' | 'range' | 'color' | 'date' | 'datetime-local' | 'email' | 'month' | 'number' | 'password' | 'search' | 'tel' | 'text' | 'time' | 'url' | 'week';
+    value?: any;
+    checked?: boolean;
+    selected?: boolean;
+    options?: any;
+    nodeName?: string;
+}
+
+export interface WrappedReference {
+    ref: FieldReference | FieldReference[];
+    _validations: Validations;
+    _disabled: boolean;
+    _defaultValue: any;
+}
+
+export type Refs = Record<string, WrappedReference>;
\ No newline at end of file
diff --git a/src/types/register.ts b/src/types/register.ts
new file mode 100644
index 0000000..28928ce
--- /dev/null
+++ b/src/types/register.ts
@@ -0,0 +1,35 @@
+import { BaseControlProps } from "./baseControl";
+import { ValidationsConfiguration } from "./validations";
+
+/** Function returning true for correct validation or a string with an error if it's invalid */
+export type ValidationFn = (_: any) => Promise<boolean | string> | boolean | string
+
+/** Validations collection as an object */
+export type Validations = Record<string, ValidationFn>
+
+
+export interface RegisterOptions extends ValidationsConfiguration {
+    /** Indicates wether the input is native or not, set to false if the extra listeners are not desired */
+    native?: boolean
+
+    /** Indicates wether the input is clearable or not */
+    clearable?: boolean
+
+    /** Default value for the field */
+    defaultValue?: any
+
+    /** Validations for the field */
+    validations?: Validations
+
+    /** Set to true if you want to bind also dirty and touched states */
+    withDetails?: boolean
+
+    /** Set to true if the field should be disabled */
+    disabled?: boolean
+
+    /** Indicates if the control should use the native html validation */
+    useNativeValidation?: boolean
+}
+
+/** Function that allows you to register a control to interact with the form */
+export type Register = (name: string, options?: RegisterOptions) => BaseControlProps
\ No newline at end of file
diff --git a/src/types/validations.ts b/src/types/validations.ts
new file mode 100644
index 0000000..d6ffad8
--- /dev/null
+++ b/src/types/validations.ts
@@ -0,0 +1,39 @@
+export interface ValidationWithMessage {
+    /** Validation value */
+    value: number | string | RegExp
+
+    /** Validation message */
+    message: string
+}
+
+export interface ValidationsConfiguration {
+    /** Required validation */
+    /** If true, the field is required */
+    /** If a string, the field is required and the string is the validation message */
+    required?: boolean | string
+
+    /** Min validation */
+    /** If a number, the field must be greater than or equal to the number */
+    /** If an object, the field must be greater than or equal to the object.value and the object.message is the validation message */
+    min?: number | ValidationWithMessage
+
+    /** Max validation */
+    /** If a number, the field must be less than or equal to the number */
+    /** If an object, the field must be less than or equal to the object.value and the object.message is the validation message */
+    max?: number | ValidationWithMessage
+
+    /** MinLength validation */
+    /** If a number, the field must be greater than or equal to the number */
+    /** If an object, the field must be greater than or equal to the object.value and the object.message is the validation message */
+    minLength?: number | ValidationWithMessage
+
+    /** MaxLength validation */
+    /** If a number, the field must be less than or equal to the number */
+    /** If an object, the field must be less than or equal to the object.value and the object.message is the validation message */
+    maxLength?: number | ValidationWithMessage
+
+    /** Pattern validation */
+    /** If a RegExp, the field must match the RegExp */
+    /** If an object, the field must match the object.value and the object.message is the validation message */
+    pattern?: RegExp | ValidationWithMessage
+}
\ No newline at end of file
diff --git a/src/useFormHandler.ts b/src/useFormHandler.ts
index b785b7c..56babf6 100644
--- a/src/useFormHandler.ts
+++ b/src/useFormHandler.ts
@@ -1,11 +1,29 @@
-import { DEFAULT_FIELD_VALUE } from './constants';
-import { ModifiedValues, TriggerValidation, Validations, FormHandler, ResetField, ResetForm, InitControl, SetError, ClearErrors, SetValue, ClearField, SetDirty, SetTouched, HandleBlur, HandleChange, GetInitValueForControl } from './types';
-import { FormState, HandleSubmit, Register } from './types';
+import { DEFAULT_FIELD_VALUE } from './core/constants';
+import {
+  ModifiedValues,
+  TriggerValidation,
+  FormHandler,
+  ResetField,
+  ResetForm,
+  InitControl,
+  SetError,
+  ClearErrors,
+  SetValue,
+  ClearField,
+  SetDirty,
+  SetTouched,
+  HandleBlur,
+  HandleChange,
+  FormState,
+  HandleSubmit,
+  Register,
+  IsValidForm,
+  Refs,
+  ValidationsConfiguration
+} from './types';
 import { reactive, readonly, watch } from 'vue'
 import { isEqual } from 'lodash-es'
-import { getNativeFieldValue } from './logic';
-import { isCheckboxInput, isRadioInput, isMultipleSelect, isNativeControl, isDefined } from './utils';
-import getDefaultFieldValue from './logic/getDefaultFieldValue';
+import { getNativeFieldValue, validateField, validateForm, getDefaultFieldValue, refFn, transformValidations } from './logic';
 
 export const initialState = () => ({
   touched: {},
@@ -16,39 +34,43 @@ export const initialState = () => ({
   isValid: true,
 })
 
-//TODO: separate synchronous from asynchronous validations
-//TODO: extend validation behaviors
+//TODO: add descriptive Error throwing for easier debugging
+//TODO: avoid watcher to update validation state
 const useFormHandler: FormHandler = ({
   initialValues = {},
   interceptor,
   validate,
-  // TODO: if no further options, validation behavior should be considered along with the base params
-  options = { validationBehaviour: 'always' }
+  validationMode = 'onChange'
 } = {}) => {
   const values: Record<string, any> = reactive({ ...initialValues })
   const formState = reactive<FormState>({ ...initialState() })
 
-  let validations: Record<string, Validations> = {}
-  let defaultValues: Record<string, any> = {}
-  let refs: Record<string, any> = {}
+  let _refs: Refs = {}
 
-  const getDefaultValueForControl = (name: string) => defaultValues[name] ?? getDefaultFieldValue(refs[name])
-  const getInitValueForControl: GetInitValueForControl = (name) => initialValues[name] ?? getDefaultValueForControl(name)
-  const initControl: InitControl = (name, options) => {
-    validations = {
-      ...validations,
-      [name]: options.validations || {}
+  const _getDefault = (name: string): any => _refs[name]?._defaultValue ?? getDefaultFieldValue(_refs[name]?.ref)
+  const _getInitial = (name: string): any => initialValues[name] ?? _getDefault(name)
+  const _initControl: InitControl = (name, options) => {
+    const needsReset = options.disabled && _refs[name] && !_refs[name]._disabled
+    _refs[name] = {
+      ..._refs[name] || {},
+      _validations: {
+        ...(!options.useNativeValidation
+          && transformValidations(options as ValidationsConfiguration)),
+        ...(options.validations || {})
+      },
+      _defaultValue: options.defaultValue,
+      _disabled: !!options.disabled,
     }
-    defaultValues = {
-      ...defaultValues,
-      [name]: options.defaultValue
+    if (needsReset) {
+      unregister(name)
+      return
     }
     if (initialValues[name] === undefined && values[name] === undefined) {
-      values[name] = getDefaultValueForControl(name)
+      values[name] = _getDefault(name)
     }
   }
 
-  const isValid = () => {
+  const _updateValidState = () => {
     formState.isValid = !Object.keys(formState.errors).some(field => Object.keys(formState.errors[field]).length)
   }
 
@@ -67,35 +89,17 @@ const useFormHandler: FormHandler = ({
         ? !errors.includes(errorName)
         : errors !== errorName))
 
-    if (Object.entries(formState.errors[name]).length < 1) {
+    if (!Object.entries(formState.errors[name]).length) {
       delete formState.errors[name]
     }
   }
 
   const triggerValidation: TriggerValidation = async (name) => {
-    if (!Object.keys(validations).length) {
-      return
-    }
     if (!name) {
-      for (const field of Object.keys(values)) {
-        await triggerValidation(field)
-      }
-      return
-    }
-    if (!Object.keys(validations[name]).length) {
+      validateForm({ formState, values, _refs })
       return
     }
-    for (const [validationName, validation] of Object.entries(validations[name])) {
-      const result = await validation(values[name])
-      formState.errors[name] = {
-        ...(result !== true && { [validationName]: result })
-      }
-      if (result !== true) {
-        break;
-      }
-      //TODO: improve this
-      clearErrors(name)
-    }
+    validateField({ formState, name, _refs, values })
   }
 
   const setDirty: SetDirty = (name, dirty) => {
@@ -123,7 +127,7 @@ const useFormHandler: FormHandler = ({
   }
 
   const resetField: ResetField = (name) => {
-    values[name] = getInitValueForControl(name)
+    values[name] = _getInitial(name)
     setTouched(name, false)
     setDirty(name, false)
   }
@@ -148,111 +152,113 @@ const useFormHandler: FormHandler = ({
   }
 
   const setValue: SetValue = async (name, value = DEFAULT_FIELD_VALUE) => {
-    if (!interceptor || await interceptor({ name, value, values, formState, clearErrors, modifiedValues, resetField, resetForm, setError, triggerValidation })) {
+    if (!_refs[name]?._disabled
+      && (!interceptor
+        || await interceptor({
+          name,
+          value,
+          values,
+          formState,
+          clearErrors,
+          modifiedValues,
+          resetField,
+          resetForm,
+          setError,
+          triggerValidation
+        }))) {
       values[name] = value
-      setDirty(name, !isEqual(value, getInitValueForControl(name)))
+      setDirty(name, !isEqual(value, _getInitial(name)))
     }
   }
 
   const handleBlur: HandleBlur = (name) => {
     setTouched(name, true)
-    triggerValidation(name)
+    if (validationMode === 'onBlur' || validationMode === 'always') {
+      triggerValidation(name)
+    }
   }
 
   const handleChange: HandleChange = async (name, value = DEFAULT_FIELD_VALUE) => {
     await setValue(name, value)
     setTouched(name, true)
-    triggerValidation(name)
+    if (validationMode === 'onChange' || validationMode === 'always') {
+      triggerValidation(name)
+    }
   }
 
   const clearField: ClearField = async (name) => {
-    await setValue(name, getDefaultValueForControl(name))
+    await setValue(name, _getDefault(name))
+  }
+
+  const unregister = (name: string) => {
+    delete _refs[name]
+    delete values[name]
+    delete formState.errors[name]
+    delete formState.dirty[name]
+    delete formState.touched[name]
   }
 
   const register: Register = (name, options = {}) => {
-    initControl(name, options);
+    const {
+      validations,
+      defaultValue,
+      disabled,
+      withDetails,
+      native,
+      useNativeValidation,
+      ...nativeValidations } = options
+    _initControl(name, options);
     return ({
       name,
+      modelValue: values[name],
       errors: Object.values(formState.errors[name] || {}) || [],
+      'onUpdate:modelValue': (value: any) => handleChange(name, value),
+      ref: refFn(name, _refs, values),
       onBlur: () => handleBlur(name),
-      ...(options.withDetails && {
+      onClear: () => clearField(name),
+      ...(disabled && { disabled: true }),
+      ...(withDetails && {
         isDirty: !!formState.dirty[name],
         isTouched: !!formState.touched[name],
       }),
-      modelValue: values[name],
-      'onUpdate:modelValue': (value: any) => handleChange(name, value),
-      ref: (fieldRef: any) => {
-        if (!fieldRef || !fieldRef.nodeName || !isNativeControl(fieldRef)) {
-          refs = {
-            ...refs,
-            [name]: {
-              type: 'custom'
-            }
-          }
-          return
-        }
-        if (!refs[name] || (isRadioInput(fieldRef) && !refs[name].some((option: any) => option.value === fieldRef.value))) {
-          refs = {
-            ...refs,
-            [name]: isRadioInput(fieldRef) ? [...(refs[name] || []), fieldRef] : fieldRef
-          }
-        }
-        if (isRadioInput(fieldRef)) {
-          if (fieldRef.checked) {
-            values[name] = fieldRef.value
-            return
-          }
-          fieldRef.checked = (values[name] === fieldRef.value)
-          return
-        }
-        if (isCheckboxInput(fieldRef)) {
-          if (isDefined(fieldRef.checked)) {
-            values[name] = !!fieldRef.checked
-            return
-          }
-          fieldRef.checked = !!values[name]
-          return
-        }
-        if (isMultipleSelect(fieldRef)) {
-          [...fieldRef.options].forEach((option: any, index) => {
-            fieldRef[index].selected = !!values[name]?.includes(option.value)
-          })
-          return
-        }
-        fieldRef.value = values[name]
-      },
-      ...(options.native !== false && {
-        onChange: () => handleChange(name, getNativeFieldValue(refs[name] as HTMLInputElement)),
-        ...(options.required && { required: true })
+      ...(native !== false && {
+        onChange: () => handleChange(name, getNativeFieldValue(_refs[name].ref)),
       }),
-      ...(options.clearable && { onClear: () => resetField(name) })
+      ...(useNativeValidation && {
+        ...nativeValidations
+      })
     })
   }
 
-  const handleSubmit: HandleSubmit = async (successFn, errorFn) => {
-    let valid = false;
-    if (validate) {
-      valid = await validate()
-    }
-    else {
-      await triggerValidation()
-      valid = formState.isValid
-    }
-    if (valid) {
-      successFn(values)
-      return
+  const isValidForm: IsValidForm = async () => {
+    if (['always', 'onSubmit'].includes(validationMode)) {
+      if (validate) {
+        return await validate()
+      }
+      triggerValidation()
     }
-    if (errorFn) {
-      errorFn(formState.errors)
-      return
+    return formState.isValid
+  }
+
+  const handleSubmit: HandleSubmit = async (successFn, errorFn) => {
+    try {
+      if (await isValidForm()) {
+        successFn(values)
+        return
+      }
+      if (errorFn) {
+        errorFn(formState.errors)
+        return
+      }
+    } catch {
+      throw new Error('One or more errors found during validation')
     }
-    throw new Error('One or more errors found during validation')
   }
 
   watch(
     () => formState.errors,
     () => {
-      isValid();
+      _updateValidState();
     }, { deep: true, immediate: true })
 
   return {
diff --git a/src/utils/index.ts b/src/utils/index.ts
index ace2176..bc2244f 100644
--- a/src/utils/index.ts
+++ b/src/utils/index.ts
@@ -2,4 +2,10 @@ export { default as isCheckboxInput } from './isCheckboxInput'
 export { default as isNativeControl } from './isNativeControl'
 export { default as isRadioInput } from './isRadioInput'
 export { default as isMultipleSelect } from './isMultipleSelect'
-export { default as isDefined } from './isDefined'
\ No newline at end of file
+export { default as isDefined } from './isDefined'
+export { default as max } from './max'
+export { default as maxLength } from './maxLength'
+export { default as min } from './min'
+export { default as minLength } from './minLength'
+export { default as pattern } from './pattern'
+export { default as required } from './required'
\ No newline at end of file
diff --git a/src/utils/max.ts b/src/utils/max.ts
new file mode 100644
index 0000000..5592c7b
--- /dev/null
+++ b/src/utils/max.ts
@@ -0,0 +1,16 @@
+/**
+ * @param max - The maximum value
+ * @param message - The validation message
+ * @returns A function that returns true if the value is less than the max or a string with the message if it's not
+ * @example 
+ * const max = max(10, 'This field must be less than 10')
+ * 
+ * max(5) // true
+ * max(15) // 'This field must be less than 10'
+ */
+export default (max: number, message = `This field must be less than ${max}`) => (value: any) => {
+    if (value && value > max) {
+        return message
+    }
+    return true
+}
\ No newline at end of file
diff --git a/src/utils/maxLength.ts b/src/utils/maxLength.ts
new file mode 100644
index 0000000..cec7709
--- /dev/null
+++ b/src/utils/maxLength.ts
@@ -0,0 +1,16 @@
+/**
+ * @param {number} max - Maximum length of the string
+ * @param {string} message - The validation message
+ * @returns {function} A function that returns true if the value is less than the max or a string with the message if it's not
+ * @example
+ * const maxLength = maxLength(10, 'This field must be less than 10 characters')
+ * 
+ * maxLength('123456789') // true
+ * maxLength('12345678901') // 'This field must be less than 10 characters'
+ */
+export default (max: number, message = `This field must be less than ${max} characters`) => (value: any) => {
+    if (value && value.length > max) {
+        return message
+    }
+    return true
+}
diff --git a/src/utils/min.ts b/src/utils/min.ts
new file mode 100644
index 0000000..adc94e0
--- /dev/null
+++ b/src/utils/min.ts
@@ -0,0 +1,16 @@
+/**
+ * @param min - The minimum value
+ * @param message - The validation message
+ * @returns A function that returns true if the value is greater than the min or a string with the message if it's not
+ * @example
+ * const min = min(10, 'This field must be at least 10')
+ * 
+ * min(15) // true
+ * min(5) // 'This field must be at least 10'
+ */
+export default (min: number, message = `This field must be at least ${min}`) => (value: any) => {
+    if (value && value < min) {
+        return message
+    }
+    return true
+}
\ No newline at end of file
diff --git a/src/utils/minLength.ts b/src/utils/minLength.ts
new file mode 100644
index 0000000..bebb8de
--- /dev/null
+++ b/src/utils/minLength.ts
@@ -0,0 +1,16 @@
+/**
+ * @param min - Minimum length of the string
+ * @param message - The validation message
+ * @returns A function that returns true if the value is greater than the min or a string with the message if it's not
+ * @example
+ * const minLength = minLength(10, 'This field must be at least 10 characters')
+ * 
+ * minLength('1234567890') // true
+ * minLength('123456789') // 'This field must be at least 10 characters'
+ */
+export default (min: number, message = `This field must be at least ${min} characters`) => (value: any) => {
+    if (value && value.length < min) {
+        return message
+    }
+    return true
+}
\ No newline at end of file
diff --git a/src/utils/pattern.ts b/src/utils/pattern.ts
new file mode 100644
index 0000000..e951440
--- /dev/null
+++ b/src/utils/pattern.ts
@@ -0,0 +1,16 @@
+/**
+ * @param pattern - RegExp pattern
+ * @param message - The validation message
+ * @returns A function that returns true if the value matches the pattern or a string with the message if it doesn't
+ * @example
+ * const pattern = pattern(/^[a-z]+$/, 'This field is invalid')
+ * 
+ * pattern('abc') // true
+ * pattern('123') // 'This field is invalid'
+ */
+export default (pattern: RegExp, message = 'This field is invalid') => (value: any) => {
+    if (value && !pattern.test(value)) {
+        return message
+    }
+    return true
+}
\ No newline at end of file
diff --git a/src/utils/required.ts b/src/utils/required.ts
new file mode 100644
index 0000000..79e172b
--- /dev/null
+++ b/src/utils/required.ts
@@ -0,0 +1,15 @@
+/**
+ * @param {string} message
+ * @returns {function} A function that returns true if the value is not undefined, null or an empty string or a string with the message if it is
+ * @example
+ * const required = required('This field is required')
+ * 
+ * required('abc') // true
+ * required('') // 'This field is required'
+ */
+export default (message = 'This field is required') => (value: any) => {
+    if (value === undefined || value === null || value === '') {
+        return message
+    }
+    return true
+}
\ No newline at end of file
diff --git a/test/useFormHandler.test.ts b/test/useFormHandler.test.ts
index 6c38384..cd40bf6 100644
--- a/test/useFormHandler.test.ts
+++ b/test/useFormHandler.test.ts
@@ -119,7 +119,7 @@ describe('Register function testing', () => {
         expect(field.onBlur).toBeDefined()
         expect(field.isDirty).toBeUndefined()
         expect(field.isTouched).toBeUndefined()
-        expect(field.onClear).toBeUndefined()
+        expect(field.onClear).toBeDefined()
         expect(field.onChange).toBeDefined()
         expect(field.modelValue).toBe(null)
         expect(field['onUpdate:modelValue']).toBeDefined()
@@ -178,6 +178,7 @@ describe('Register function testing', () => {
         await setValue('field', 'error')
         await triggerValidation('field')
         expect(values.field).toBe('error')
+        await sleep()
         expect(formState.isValid).toBeFalsy()
     })
 })
\ No newline at end of file
diff --git a/tsconfig.json b/tsconfig.json
index f075a1e..935cdc0 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -23,7 +23,6 @@
   "include": [
     "src/**/*.ts",
     "src/**/*.d.ts",
-    "src/**/*.tsx",
     "src/**/*.vue"
   ],
   "references": [
diff --git a/tsconfig.node.json b/tsconfig.node.json
index 03369ba..86350b4 100644
--- a/tsconfig.node.json
+++ b/tsconfig.node.json
@@ -7,6 +7,6 @@
     "declaration": true
   },
   "include": [
-    "vite.config.ts"
+    "vite.config.ts",
   ]
 }
\ No newline at end of file