diff --git a/.nvmrc b/.nvmrc
index 10fef25..35d2d08 100644
--- a/.nvmrc
+++ b/.nvmrc
@@ -1 +1 @@
-20.18
+22.12
diff --git a/package-lock.json b/package-lock.json
index c9e9384..503817c 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -19,12 +19,14 @@
         "eslint": "^9.17.0",
         "eslint-plugin-vue": "^9.32.0",
         "rollup-plugin-visualizer": "^5.12.0",
+        "type-fest": "^4.30.2",
         "typescript": "^5.6.3",
         "vite": "^6.0.3",
         "vite-plugin-checker": "^0.8.0",
         "vite-plugin-dts": "^4.3.0",
         "vitepress": "^1.5.0",
         "vitest": "^2.1.8",
+        "vue-component-type-helpers": "^2.1.10",
         "vue-tsc": "^2.1.10"
       },
       "peerDependencies": {
@@ -3804,6 +3806,19 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/eslint-plugin-vue/node_modules/type-fest": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
+      "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
+      "dev": true,
+      "license": "(MIT OR CC0-1.0)",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/eslint-plugin-vue/node_modules/xml-name-validator": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-4.0.0.tgz",
@@ -6411,12 +6426,13 @@
       }
     },
     "node_modules/type-fest": {
-      "version": "0.20.2",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
-      "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
+      "version": "4.30.2",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.30.2.tgz",
+      "integrity": "sha512-UJShLPYi1aWqCdq9HycOL/gwsuqda1OISdBO3t8RlXQC4QvtuIz4b5FCfe2dQIWEpmlRExKmcTBfP1r9bhY7ig==",
       "dev": true,
+      "license": "(MIT OR CC0-1.0)",
       "engines": {
-        "node": ">=10"
+        "node": ">=16"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
@@ -11459,6 +11475,12 @@
             "type-fest": "^0.20.2"
           }
         },
+        "type-fest": {
+          "version": "0.20.2",
+          "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
+          "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
+          "dev": true
+        },
         "xml-name-validator": {
           "version": "4.0.0",
           "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-4.0.0.tgz",
@@ -13295,9 +13317,9 @@
       }
     },
     "type-fest": {
-      "version": "0.20.2",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
-      "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
+      "version": "4.30.2",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.30.2.tgz",
+      "integrity": "sha512-UJShLPYi1aWqCdq9HycOL/gwsuqda1OISdBO3t8RlXQC4QvtuIz4b5FCfe2dQIWEpmlRExKmcTBfP1r9bhY7ig==",
       "dev": true
     },
     "typescript": {
diff --git a/package.json b/package.json
index 21b0a9e..b6e4da2 100644
--- a/package.json
+++ b/package.json
@@ -25,12 +25,14 @@
     "eslint": "^9.17.0",
     "eslint-plugin-vue": "^9.32.0",
     "rollup-plugin-visualizer": "^5.12.0",
+    "type-fest": "^4.30.2",
     "typescript": "^5.6.3",
     "vite": "^6.0.3",
     "vite-plugin-checker": "^0.8.0",
     "vite-plugin-dts": "^4.3.0",
     "vitepress": "^1.5.0",
     "vitest": "^2.1.8",
+    "vue-component-type-helpers": "^2.1.10",
     "vue-tsc": "^2.1.10"
   },
   "peerDependencies": {
diff --git a/src/App.vue b/src/App.vue
index 928f9f2..8647338 100644
--- a/src/App.vue
+++ b/src/App.vue
@@ -6,7 +6,7 @@
         'my-input': [{ message: 'outer error' }],
         'my.nested.value': [{ message: 'qwe' }]
       }"
-      :resolver="$options.resolver"
+      :resolver="resolver"
       @submit="onSubmit"
     >
       <template #default="{ handleSubmit, values, dirty, errors, reset, onFieldChange }">
@@ -22,7 +22,7 @@
               <input
                 :value="modelValue"
                 type="text"
-                @input="onChange($event.target.value)"
+                @input="onChange(($event.target as HTMLInputElement).value)"
               >
             </template>
           </ValidationField>
@@ -32,7 +32,7 @@
               <input
                 :value="modelValue"
                 type="text"
-                @input="onChange($event.target.value)"
+                @input="onChange(($event.target as HTMLInputElement).value)"
               >
             </template>
           </ValidationField>
@@ -51,7 +51,7 @@
                       <input
                         :value="modelValue"
                         type="text"
-                        @input="onChange($event.target.value)"
+                        @input="onChange(($event.target as HTMLInputElement).value)"
                       >
                     </template>
                   </ValidationField>
@@ -60,7 +60,7 @@
                       <input
                         :value="modelValue"
                         type="text"
-                        @input="onChange($event.target.value)"
+                        @input="onChange(($event.target as HTMLInputElement).value)"
                       >
                     </template>
                   </ValidationField>
@@ -69,14 +69,14 @@
                       <input
                         :value="modelValue"
                         type="text"
-                        @input="onChange($event.target.value)"
+                        @input="onChange(($event.target as HTMLInputElement).value)"
                       >
                     </template>
                   </ValidationField>
                 </div>
                 <button
                   type="button"
-                  @click="prepend({ firstName: 'prepend' }, { name: 'firstName' })"
+                  @click="prepend({ firstName: 'prepend' }, { field: 'firstName' })"
                 >
                   Prepend
                 </button>
@@ -153,82 +153,72 @@
   </div>
 </template>
 
-<script>
+<script setup lang="ts">
 import {
   ValidationErrors,
   ValidationField,
   ValidationFieldArray,
   ValidationProvider,
-  get
+  get,
+  Resolver,
+  ResolverResult,
+  OnSubmit
 } from './index';
 
-function required(value) {
-  return !!value;
-}
-
-export default {
-  name: 'App',
-  components: {
-    ValidationProvider,
-    ValidationField,
-    ValidationFieldArray,
-    ValidationErrors
-  },
-  resolver(values) {
-    const result = {
-      values,
-      errors: {}
-    };
-    if (!required(get(values, 'my-input'))) {
-      result.errors['my-input'] = [{ message: 'field required' }];
+const defaultValues = {
+  my: {
+    nested: {
+      value: 'test'
     }
-    if (!required(get(values, 'my.nested.value'))) {
-      result.errors['my.nested.value'] = [{ message: 'field required' }];
-    }
-    get(values, 'arrayField', []).forEach(({ firstName }, index) => {
-      if (!required(firstName)) {
-        result.errors[`arrayField.${index}.firstName`] = [{ message: 'field required' }];
-      }
-    });
-    return result;
-  },
-  data() {
-    return {
-      defaultValues: {
-        my: {
-          nested: {
-            value: 'test'
-          }
-        },
-        arrayField: [
-          {
-            id: '1',
-            firstName: '111',
-            type: 'user'
-          },
-          {
-            id: '2',
-            firstName: '222',
-            type: 'user'
-          },
-          {
-            id: '3',
-            firstName: '333',
-            type: null
-          }
-        ]
-      }
-    };
   },
-  methods: {
-    onSubmit(values, { setError }) {
-      setTimeout(() => {
-        setError('my-input', { message: 'invalid field', type: 'custom' });
-        setError('common', { message: 'invalid common field', type: 'custom' });
-      }, 250);
-
-      console.log(values);
+  arrayField: [
+    {
+      id: '1',
+      firstName: '111',
+      type: 'user'
+    },
+    {
+      id: '2',
+      firstName: '222',
+      type: 'user'
+    },
+    {
+      id: '3',
+      firstName: '333',
+      type: null
     }
+  ]
+};
+type V = typeof defaultValues;
+
+function required(value: unknown) {
+  return !!value;
+}
+const resolver: Resolver<V> = (values) => {
+  const result: ResolverResult<V> = {
+    values,
+    errors: {}
+  };
+  if (!required(get(values, 'my-input'))) {
+    result.errors['my-input'] = [{ message: 'field required' }];
+  }
+  if (!required(get(values, 'my.nested.value'))) {
+    result.errors['my.nested.value'] = [{ message: 'field required' }];
   }
+  get(values, 'arrayField', []).forEach(({ firstName }, index) => {
+    if (!required(firstName)) {
+      result.errors[`arrayField.${index}.firstName`] = [{ message: 'field required' }];
+    }
+  });
+  return result;
+};
+
+const onSubmit: OnSubmit<V> = (values, { setError }) => {
+  setTimeout(() => {
+    setError('my-input', { message: 'invalid field', type: 'custom' });
+    setError('common', { message: 'invalid common field', type: 'custom' });
+  }, 250);
+
+  console.log(values);
 };
 </script>
diff --git a/src/components/ValidationField.vue b/src/components/ValidationField.vue
index db535a2..78276ca 100644
--- a/src/components/ValidationField.vue
+++ b/src/components/ValidationField.vue
@@ -14,7 +14,7 @@
 </template>
 
 <script lang="ts" setup>
-import { computed, inject, ref, toRefs, reactive, nextTick, onUnmounted } from 'vue';
+import { computed, inject, ref, reactive, nextTick, onUnmounted } from 'vue';
 
 import type { InnerValidationError } from '../types/error';
 import {
@@ -29,22 +29,16 @@ import {
 import type { Field } from '../types/field';
 import { ON_FIELD_CHANGE } from './constants';
 
-export interface Props {
+const { name, isEqual = (a, b) => a === b } = defineProps<{
   name: string;
   isEqual?: (a: unknown, b: unknown) => boolean;
-}
-
-const props = withDefaults(defineProps<Props>(), {
-  isEqual: (a, b) => a === b
-});
+}>();
 
 const emit = defineEmits<{
   (e: 'should-focus', options: { name: string }): void;
   (e: 'change', value: unknown): void;
 }>();
 
-const { name, isEqual } = toRefs(props);
-
 const registered = ref(false);
 const errors = ref<InnerValidationError[]>([]);
 
@@ -56,14 +50,14 @@ const getIsValidateAvailable = inject(getIsValidateAvailableSymbol)!;
 const register = inject(registerSymbol)!;
 const validate = inject(validateSymbol)!;
 
-const defaultValue = computed(() => getFieldDefaultValue(name.value));
-const hasProvidedValue = computed(() => hasFieldValue(name.value));
-const providedValue = computed(() => getFieldValue(name.value));
+const defaultValue = computed(() => getFieldDefaultValue(name));
+const hasProvidedValue = computed(() => hasFieldValue(name));
+const providedValue = computed(() => getFieldValue(name));
 const validateAvailable = computed(() => getIsValidateAvailable());
 const value = ref(hasProvidedValue.value ? providedValue.value : defaultValue.value);
-const pristine = ref<boolean>(getFieldPristine(name.value));
+const pristine = ref<boolean>(getFieldPristine(name));
 
-const dirty = computed(() => !isEqual.value(value.value, defaultValue.value));
+const dirty = computed(() => !isEqual(value.value, defaultValue.value));
 const firstError = computed(() => errors.value[0]);
 const invalid = computed(() => !!errors.value.length);
 
@@ -76,7 +70,7 @@ const reset: Field['reset'] = () => {
 };
 
 const onChange: Field['onChange'] = (newValue: unknown) => {
-  if (isEqual.value(value.value, newValue)) {
+  if (isEqual(value.value, newValue)) {
     return;
   }
 
@@ -88,7 +82,7 @@ const onChange: Field['onChange'] = (newValue: unknown) => {
     return;
   }
 
-  validate(name.value);
+  validate(name);
 };
 
 const setError: Field['setError'] = ({
@@ -110,7 +104,7 @@ const resetErrors: Field['resetErrors'] = () => {
 };
 
 const field: Field = reactive({
-  name,
+  name: computed(() => name),
   dirty,
   pristine,
   errors,
@@ -121,7 +115,7 @@ const field: Field = reactive({
   reset,
   onFocus: () => {
     emit('should-focus', {
-      name: name.value
+      name
     });
   }
 });
diff --git a/src/components/ValidationFieldArray.vue b/src/components/ValidationFieldArray.vue
index 7c2b518..89fe4f9 100644
--- a/src/components/ValidationFieldArray.vue
+++ b/src/components/ValidationFieldArray.vue
@@ -13,7 +13,7 @@
 </template>
 
 <script lang="ts" setup>
-import { computed, inject, nextTick, onBeforeUnmount, provide, reactive, ref, toRefs } from 'vue';
+import { computed, inject, nextTick, onBeforeUnmount, provide, reactive, ref } from 'vue';
 import type { Field } from '../types/field';
 import type { FocusOptions } from '../types/field-array';
 import {
@@ -31,14 +31,10 @@ export interface Props {
   keyName?: string;
 }
 
-const props = withDefaults(defineProps<Props>(), {
-  keyName: 'id'
-});
-
-const { name, keyName } = toRefs(props);
+const { name, keyName = 'id' } = defineProps<Props>();
 
 const getFieldPristine = inject(getFieldPristineSymbol)!;
-const pristine = ref<boolean>(getFieldPristine(name.value));
+const pristine = ref<boolean>(getFieldPristine(name));
 
 const register = inject(registerSymbol)!;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -48,14 +44,14 @@ const getFieldDefaultValue = inject<(name: string, defaultValue?: any[]) => any[
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const getFieldValue = inject<(name: string) => any[]>(getFieldValueSymbol)!;
 
-const defaultValue = computed(() => getFieldDefaultValue(name.value, []));
+const defaultValue = computed(() => getFieldDefaultValue(name, []));
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-const providedValue = computed<Array<Record<string, any>>>(() => getFieldValue(name.value) || []);
+const providedValue = computed<Array<Record<string, any>>>(() => getFieldValue(name) || []);
 const providedValueMap = computed(() => {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const map: Record<string, Record<string, any>> = {};
   providedValue.value.forEach((field) => {
-    map[field[keyName.value]] = field;
+    map[field[keyName]] = field;
   });
   return map;
 });
@@ -63,8 +59,8 @@ const providedValueMap = computed(() => {
 const actualValue = computed<Array<Record<string, any>>>(() => {
   const map = providedValueMap.value;
   return fields.value.map((field) => ({
-    ...map[field[keyName.value]],
-    [keyName.value]: field[keyName.value]
+    ...map[field[keyName]],
+    [keyName]: field[keyName]
   }));
 });
 
@@ -74,13 +70,13 @@ const fields = ref(getInitialFields());
 function getInitialFields() {
   return defaultValue.value.map((field) => ({
     ...field,
-    [keyName.value]: getId(field)
+    [keyName]: getId(field)
   }));
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function getId(field: Record<string, any>) {
-  return keyName.value in field ? field[keyName.value] : nanoid();
+  return keyName in field ? field[keyName] : nanoid();
 }
 
 function touch() {
@@ -89,7 +85,7 @@ function touch() {
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function append(value: Record<string, any>, focusOptions?: FocusOptions) {
-  value[keyName.value] = getId(value);
+  value[keyName] = getId(value);
   fields.value.push(value);
   touch();
   if (focusOptions) {
@@ -99,7 +95,7 @@ function append(value: Record<string, any>, focusOptions?: FocusOptions) {
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function prepend(value: Record<string, any>, focusOptions?: FocusOptions) {
-  value[keyName.value] = getId(value);
+  value[keyName] = getId(value);
   fields.value.unshift(value);
   touch();
   if (focusOptions) {
@@ -109,7 +105,11 @@ function prepend(value: Record<string, any>, focusOptions?: FocusOptions) {
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function insert(index: number, value: Record<string, any>, focusOptions?: FocusOptions) {
-  value[keyName.value] = getId(value);
+  checkIndexOverflow({
+    index
+  });
+
+  value[keyName] = getId(value);
   fields.value.splice(index, 0, value);
   touch();
   if (focusOptions) {
@@ -118,6 +118,11 @@ function insert(index: number, value: Record<string, any>, focusOptions?: FocusO
   }
 }
 function swap(from: number, to: number, focusOptions?: FocusOptions) {
+  checkIndexOverflow({
+    from,
+    to
+  });
+
   const temp = fields.value[from];
   fields.value[from] = fields.value[to];
   fields.value[to] = temp;
@@ -128,6 +133,11 @@ function swap(from: number, to: number, focusOptions?: FocusOptions) {
   }
 }
 function move(from: number, to: number, focusOptions?: FocusOptions) {
+  checkIndexOverflow({
+    from,
+    to
+  });
+
   fields.value.splice(to, 0, fields.value.splice(from, 1)[0]);
   touch();
   if (focusOptions) {
@@ -145,12 +155,21 @@ function remove(index: number, focusOptions?: FocusOptions) {
   }
 }
 
+function checkIndexOverflow(values: Record<string, number>) {
+  const maxIndex = fields.value.length - 1;
+  Object.entries(values).forEach(([key, count]) => {
+    if (count < 0 || count > maxIndex) {
+      throw new Error(`'${key}' should be between 0 and ${maxIndex}`);
+    }
+  });
+}
+
 function handleFocus({ field, index = 0 }: FocusOptions) {
   if (!field) {
     throw new Error(`Field name is required for focus, please provide field name in focus options`);
   }
 
-  const itemName = `${name.value}.${index || 0}.${field}`;
+  const itemName = `${name}.${index || 0}.${field}`;
   nextTick(() => {
     const fieldComponent = fieldComponents.value.find(({ name }) => name === itemName);
     fieldComponent?.onFocus();
@@ -178,14 +197,14 @@ const reset: Field['reset'] = () => {
 const noop = () => {};
 
 const field: Field = reactive({
-  name,
+  name: computed(() => name),
   dirty: false,
   pristine,
   errors: [],
   getValue: () => {
     return fields.value.map((field) => {
       return {
-        [keyName.value]: field[keyName.value]
+        [keyName]: field[keyName]
       };
     });
   },
@@ -203,7 +222,7 @@ onBeforeUnmount(() => {
 });
 
 function getNormalizedName(fieldName: string) {
-  return fieldName.replace(new RegExp(`^${name.value}.`), '');
+  return fieldName.replace(new RegExp(`^${name}.`), '');
 }
 
 provide(hasFieldValueSymbol, () => true);
diff --git a/src/components/ValidationProvider.vue b/src/components/ValidationProvider.vue
index 5cf0763..3249a14 100644
--- a/src/components/ValidationProvider.vue
+++ b/src/components/ValidationProvider.vue
@@ -14,8 +14,8 @@
   />
 </template>
 
-<script lang="ts" setup>
-import { computed, nextTick, provide, ref, toRefs, watch, onBeforeUnmount } from 'vue';
+<script lang="ts" setup generic="T extends Values">
+import { computed, nextTick, provide, ref, watch, onBeforeUnmount } from 'vue';
 
 import type { Values } from '../types/values';
 import type {
@@ -42,40 +42,35 @@ import {
 import { get, has, set } from './helpers';
 import { ON_FIELD_CHANGE, ON_FORM_CHANGE } from './constants';
 
-export interface Props {
-  defaultValues?: Values;
+export interface Props<V extends Values> {
+  defaultValues?: Partial<V>;
   defaultErrors?: ValidationsErrors;
-  resolver?: Resolver;
+  resolver?: Resolver<V>;
   instantValidate?: boolean;
   resetOnUpdate?: boolean;
 }
 
-const props = withDefaults(defineProps<Props>(), {
-  defaultValues: () => ({}),
-  defaultErrors: () => ({}),
-  resolver: (values: Record<string, unknown>) => ({ values, errors: {} }),
-  instantValidate: false,
-  resetOnUpdate: true
-});
+const {
+  defaultValues = {},
+  defaultErrors = {},
+  resolver = (values) => ({ values, errors: {} as ValidationsErrors }),
+  instantValidate = false,
+  resetOnUpdate = true
+} = defineProps<Props<T>>();
+
 const emit = defineEmits<{
-  (
-    e: 'submit',
-    values: Values,
-    opt: {
-      setError: (name: string, error: ValidationError) => void;
-      reset: (defaultValue?: Values) => void;
-      onFieldChange: (name: string, value: unknown) => void;
-      focusInvalidField: () => void;
-    }
-  ): void;
-  (e: 'dirty', dirty: boolean): void;
-  (e: 'change', values: Values): void;
+  submit: [values: T, opt: {
+    setError: (name: string, error: ValidationError) => void;
+    reset: (defaultValue?: Partial<T>) => void;
+    onFieldChange: (name: string, value: unknown) => void;
+    focusInvalidField: () => void;
+  }];
+  dirty: [dirty: boolean];
+  change: [values: Partial<T>];
 }>();
 
-const { defaultValues, defaultErrors, resolver, instantValidate, resetOnUpdate } = toRefs(props);
-
 const submitted = ref(false);
-const innerDefaultValues = ref<Values>({});
+const innerDefaultValues = ref<Partial<T>>({});
 const fieldComponents = ref<Field[]>([]);
 const additionalErrors = ref<InnerValidationsErrors>({});
 
@@ -85,7 +80,7 @@ const fieldComponentMap = computed<Record<string, Field>>(() => {
     return map;
   }, {});
 });
-const values = computed<Values>(() => {
+const values = computed<Partial<T>>(() => {
   return fieldComponents.value.reduce((result, { name, getValue }) => {
     set(result, name, getValue());
     return result;
@@ -113,19 +108,19 @@ const firstInvalidFieldComponent = computed<Field | undefined>(() => {
   return fieldComponents.value.find(({ name }) => errors.value[name].length);
 });
 const validateAvailable = computed(() => {
-  return submitted.value || instantValidate.value;
+  return submitted.value || instantValidate;
 });
 const invalid = computed(() => {
   return existsErrors.value;
 });
 
-watch(defaultValues, () => {
-  if (resetOnUpdate.value) {
+watch(() => defaultValues, () => {
+  if (resetOnUpdate) {
     setDefaultData();
   }
 });
-watch(defaultErrors, () => {
-  if (resetOnUpdate.value) {
+watch(() => defaultErrors, () => {
+  if (resetOnUpdate) {
     setDefaultData();
   }
 });
@@ -145,15 +140,15 @@ watch(values, async () => {
 setDefaultData();
 
 async function setDefaultData() {
-  reset(defaultValues.value);
+  reset(defaultValues);
   additionalErrors.value = {};
-  const hasErrors = Object.values(defaultErrors.value).some((errors) => errors.length);
-  if (!instantValidate.value && !hasErrors) {
+  const hasErrors = Object.values(defaultErrors).some((errors) => errors.length);
+  if (!instantValidate && !hasErrors) {
     return;
   }
 
   await nextTick();
-  setErrorsList(defaultErrors.value, ON_FIELD_CHANGE);
+  setErrorsList(defaultErrors, ON_FIELD_CHANGE);
   const { errors } = await validate();
   setErrorsList(errors);
   if (hasErrors) {
@@ -182,7 +177,7 @@ async function handleSubmit(): Promise<void> {
     return focusInvalidField();
   }
 
-  emit('submit', values, {
+  emit('submit', values as T, {
     setError,
     reset,
     onFieldChange,
@@ -204,12 +199,12 @@ async function validate(triggerFieldName?: string) {
   return { values, errors: errorsList };
 }
 function resolveSchema() {
-  return resolver.value(values.value);
+  return resolver(values.value);
 }
 function onFieldChange(name: string, value: unknown) {
   fieldComponentMap.value[name].onChange(value);
 }
-function reset(values?: Values) {
+function reset(values?: Partial<T>) {
   submitted.value = false;
   if (values) {
     innerDefaultValues.value = JSON.parse(JSON.stringify(values));
@@ -290,10 +285,10 @@ provide(validateSymbol, async (name: string) => {
   setErrorsList(errors);
 });
 provide(getFieldDefaultValueSymbol, getFieldDefaultValue);
-provide(getFieldValueSymbol, (name: string) => get(values.value, name));
-provide(getFieldPristineSymbol, (name: string) => fieldComponentMap.value[name]?.pristine ?? true);
+provide(getFieldValueSymbol, (name) => get(values.value, name));
+provide(getFieldPristineSymbol, (name) => fieldComponentMap.value[name]?.pristine ?? true);
 provide(getErrorsSymbol, getErrors);
-provide(hasFieldValueSymbol, (name: string) => has(values.value, name));
+provide(hasFieldValueSymbol, (name) => has(values.value, name));
 provide(getIsSubmittedSymbol, () => submitted.value);
 provide(getIsValidateAvailableSymbol, () => validateAvailable.value);
 
diff --git a/src/components/helpers.ts b/src/components/helpers.ts
index 1ed3b02..1a7a891 100644
--- a/src/components/helpers.ts
+++ b/src/components/helpers.ts
@@ -1,6 +1,8 @@
+import type { Get, LiteralUnion, IfUnknown } from 'type-fest';
 import type { Values } from '../types/values';
+import type { Paths } from '../types/paths';
 
-export function has(object: Values, path: string): boolean {
+export function has<V extends Values>(object: V, path: LiteralUnion<Paths<V>, string>): boolean {
   let tempObject = object;
   if (!isObject(tempObject)) {
     return false;
@@ -20,22 +22,22 @@ export function has(object: Values, path: string): boolean {
   return true;
 }
 
-export function get(object: Values, path: string, defaultValue?: unknown): unknown {
+export function get<V extends Values, Path extends LiteralUnion<Paths<V>, string>, DV, Res extends IfUnknown<DV, Get<V, Path>, DV>>(object: V, path: Path, defaultValue?: DV): Res {
   let tempObject = object;
   if (!isObject(tempObject)) {
-    return defaultValue;
+    return defaultValue as unknown as Res;
   }
 
   const pathParts = path.split('.');
   while (pathParts.length > 0) {
     const key = pathParts.shift() ?? '';
     if (!(key in tempObject)) {
-      return defaultValue;
+      return defaultValue as unknown as Res;
     }
 
     tempObject = tempObject[key];
   }
-  return tempObject;
+  return tempObject as unknown as Res;
 }
 
 export function set(object: Values, path: string, value: unknown): void {
diff --git a/src/index.ts b/src/index.ts
index 7a80fa1..920dca5 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -7,6 +7,7 @@ import { get, has } from './components/helpers';
 
 export { type ValidationError, type ValidationsErrors } from './types/error';
 export { type Resolver, type ResolverResult } from './types/resolver';
+export { type OnSubmit, type OnChange } from './types/emit';
 
 export {
   ValidationProvider,
diff --git a/src/shims-vue.d.ts b/src/shims-vue.d.ts
deleted file mode 100644
index 7b36afb..0000000
--- a/src/shims-vue.d.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-declare module '*.vue' {
-  import { type defineComponent } from 'vue';
-  const component: ReturnType<typeof defineComponent>;
-  export default component;
-}
diff --git a/src/types/emit.ts b/src/types/emit.ts
new file mode 100644
index 0000000..6746210
--- /dev/null
+++ b/src/types/emit.ts
@@ -0,0 +1,9 @@
+import type { ComponentProps } from 'vue-component-type-helpers';
+import type { Values } from './values';
+import ValidationProvider from '../components/ValidationProvider.vue';
+
+type Props<V extends Values> = ComponentProps<typeof ValidationProvider<V>>;
+
+export type OnSubmit<V extends Values = Values> = Exclude<Props<V>['onSubmit'], undefined>;
+
+export type OnChange<V extends Values = Values> = Exclude<Props<V>['onChange'], undefined>;
diff --git a/src/types/paths.ts b/src/types/paths.ts
new file mode 100644
index 0000000..36c0b56
--- /dev/null
+++ b/src/types/paths.ts
@@ -0,0 +1,4 @@
+import type { Paths as PathsImplement } from 'type-fest';
+import type { ToString } from './string';
+
+export type Paths<V> = ToString<PathsImplement<V, { bracketNotation: false }>>;
diff --git a/src/types/resolver.ts b/src/types/resolver.ts
index dc20378..f28aa71 100644
--- a/src/types/resolver.ts
+++ b/src/types/resolver.ts
@@ -1,9 +1,9 @@
 import type { Values } from './values';
 import type { ValidationsErrors } from './error';
 
-export interface ResolverResult {
-  values: Values;
+export interface ResolverResult<V extends Values> {
+  values: Partial<V>;
   errors: ValidationsErrors;
 }
 
-export type Resolver = (values: Values) => Promise<ResolverResult> | ResolverResult;
+export type Resolver<V extends Values> = (values: Partial<V>) => Promise<ResolverResult<V>> | ResolverResult<V>;
diff --git a/src/types/string.ts b/src/types/string.ts
new file mode 100644
index 0000000..4facff5
--- /dev/null
+++ b/src/types/string.ts
@@ -0,0 +1 @@
+export type ToString<T> = T extends string | number ? `${T}` : never;