diff --git a/src/index.ts b/src/index.ts
index c226bf4..899ab56 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -72,6 +72,14 @@ export type GetConfig<T> = $GetConfig<T> | Ref<$GetConfig<T>>
 
 export type TypeAllowed = undefined | null | string | number | boolean | Obj
 
+type Params<Z, A extends unknown[]> = (() => (Z | [...A])) |
+  ComputedRef<Z | [...A]> |
+  Ref<Z | [...A]> |
+  Z |
+  [...A]
+
+export type RequiredParams<Z extends TypeAllowed, A extends TypeAllowed[]> = Params<Required<Z>, Required<A>>;
+
 export type GetReturn<T> = {
   isPending: ComputedRef<undefined | boolean>,
   data: ComputedRef<T>,
diff --git a/src/useAsync.ts b/src/useAsync.ts
index 7bbea6d..fa471cd 100644
--- a/src/useAsync.ts
+++ b/src/useAsync.ts
@@ -7,7 +7,11 @@ import {
 } from 'vue';
 import { Result } from '@/useResult';
 import uuid from '@/_base/uuid';
-import type { TypeAllowed, UnwrappedPromiseType } from './index';
+import type {
+  TypeAllowed,
+  UnwrappedPromiseType,
+  RequiredParams,
+} from './index';
 
 type OnErrorCb<T> = (e: null | Error, params: T) => unknown;
 
@@ -15,26 +19,18 @@ type OnStartCb<T> = (params: T) => unknown;
 
 type OnEndCb<T, Z> = (res: T, params: Z) => unknown;
 
-// params: ComputedRef<A> | Ref<A> | (() => A) | A = {} as A,
-
-type Params<Z, A extends unknown[]> = (() => (Z | [...A])) |
-  ComputedRef<Z | [...A]> |
-  Ref<Z | [...A]> |
-  Z |
-  [...A]
-
 const useAsync = <T, Z extends TypeAllowed, A extends TypeAllowed[]>(
   func: ((...args: A) => Promise<T>) | ((args: Z) => Promise<T>),
-  params?: Params<Z, A>,
+  params?: RequiredParams<Z, A>,
   enabled: Ref<boolean> | (() => boolean) = ref(true),
 ): {
   isPending: Ref<undefined | boolean>,
   data: ComputedRef<undefined | null | UnwrappedPromiseType<typeof func>>;
   error: Ref<null | Error>,
   reload: () => unknown,
-  onError: (cb: OnErrorCb<Params<Z, A>>) => unknown,
-  onStart: (cb: OnStartCb<Params<Z, A>>) => unknown,
-  onEnd: (cb: OnEndCb<UnwrappedPromiseType<typeof func>, Params<Z, A>>) => unknown,
+  onError: (cb: OnErrorCb<RequiredParams<Z, A>>) => unknown,
+  onStart: (cb: OnStartCb<RequiredParams<Z, A>>) => unknown,
+  onEnd: (cb: OnEndCb<UnwrappedPromiseType<typeof func>, RequiredParams<Z, A>>) => unknown,
   promise: ComputedRef<null | ReturnType<typeof func>>,
 } => {
   const isPending = ref<undefined | boolean>();
@@ -43,20 +39,20 @@ const useAsync = <T, Z extends TypeAllowed, A extends TypeAllowed[]>(
 
   const error: Ref<null | Error> = ref(null);
 
-  const onErrorList: Array<OnErrorCb<Params<Z, A>>> = [];
+  const onErrorList: Array<OnErrorCb<RequiredParams<Z, A>>> = [];
 
-  const onStartList: Array<OnStartCb<Params<Z, A>>> = [];
+  const onStartList: Array<OnStartCb<RequiredParams<Z, A>>> = [];
 
-  const onEndList: Array<OnEndCb<T, Params<Z, A>>> = [];
+  const onEndList: Array<OnEndCb<T, RequiredParams<Z, A>>> = [];
 
   // for legacy use case
   const d = ref<null | Promise<T>>(null);
 
   const wrapParams = computed(() => {
     if (typeof params === 'function') {
-      return params();
+      return params() as RequiredParams<Z, A>;
     }
-    return unref(params);
+    return unref(params) as RequiredParams<Z, A>;
   });
 
   const lastUnwrapParams = ref();
@@ -69,7 +65,7 @@ const useAsync = <T, Z extends TypeAllowed, A extends TypeAllowed[]>(
   });
 
   // generate new xhr/promise
-  const _reload = (_params: Z | [...A]) => {
+  const _reload = (_params: RequiredParams<Z, A>) => {
     if (!_enabled.value) {
       return null;
     }
@@ -80,7 +76,7 @@ const useAsync = <T, Z extends TypeAllowed, A extends TypeAllowed[]>(
     error.value = null;
 
     // possible to call with rest params
-    const funcDefault = func as ((args: Z) => Promise<T>);
+    const funcDefault = func as ((args: RequiredParams<Z, A>) => Promise<T>);
 
     // call with only one param
     const funcRest = func as ((...args: A) => Promise<T>);
@@ -113,15 +109,15 @@ const useAsync = <T, Z extends TypeAllowed, A extends TypeAllowed[]>(
 
   const reload = () => _reload(wrapParams.value);
 
-  const onError = (cb: OnErrorCb<Params<Z, A>>) => {
+  const onError = (cb: OnErrorCb<RequiredParams<Z, A>>) => {
     onErrorList.push(cb);
   };
 
-  const onStart = (cb: OnStartCb<Params<Z, A>>) => {
+  const onStart = (cb: OnStartCb<RequiredParams<Z, A>>) => {
     onStartList.push(cb);
   };
 
-  const onEnd = (cb: OnEndCb<UnwrappedPromiseType<typeof func>, Params<Z, A>>) => {
+  const onEnd = (cb: OnEndCb<UnwrappedPromiseType<typeof func>, RequiredParams<Z, A>>) => {
     onEndList.push(cb);
   };
 
diff --git a/src/useXhr.ts b/src/useXhr.ts
index 16ec280..aa833d9 100644
--- a/src/useXhr.ts
+++ b/src/useXhr.ts
@@ -15,6 +15,7 @@ import type {
   GetConfig,
   GetReturn,
   Obj,
+  RequiredParams,
   TypeAllowed,
   XhrConfig,
   XhrGet,
@@ -39,20 +40,15 @@ type $$GetConfigArg<T> = Omit<$GetConfigArgs<T>, 'url'> & {
   url?: string,
 }
 
-type Params<Z> = (() => Z) |
-  ComputedRef<Z> |
-  Ref<Z> |
-  Z
-
 // used as default `onError`
 const _blank = () => {
 };
 
-declare type UseXhr<T, Z extends TypeAllowed> = Partial<{
+declare type UseXhr<T, Z extends TypeAllowed, A extends TypeAllowed[]> = Partial<{
   // global callback for VueJS 2 plugin compatibility
   onError: OnErrorCb<T>,
-  onStart: OnStartCb<T, Params<Z>>,
-  onEnd: OnEndCb<T, Params<Z>>,
+  onStart: OnStartCb<T, RequiredParams<Z, A>>,
+  onEnd: OnEndCb<T, RequiredParams<Z, A>>,
   onProgress: (e: ProgressEvent) => any,
   onAbort: (e: ProgressEvent) => any,
   //
@@ -63,7 +59,7 @@ declare type UseXhr<T, Z extends TypeAllowed> = Partial<{
 
 const getTokenValue = (token: undefined | Token): undefined | null | string => unref<undefined | string | null>(token);
 
-export default function <T, Z extends TypeAllowed>(args?: UseXhr<T, Z>) {
+export default function <T, Z extends TypeAllowed, A extends TypeAllowed[]>(args?: UseXhr<T, Z, A>) {
   const {
     onError,
     onStart,
@@ -90,9 +86,9 @@ export default function <T, Z extends TypeAllowed>(args?: UseXhr<T, Z>) {
   /**
    * For GET it's possible to add cache
    */
-  function get<TT = T, ZZ = Z>(
+  function get<TT = T, ZZ extends TypeAllowed = Z, AA extends TypeAllowed[] = A>(
     parametersObj: GetConfig<ZZ>,
-    params?: Params<ZZ>,
+    params?: RequiredParams<ZZ, AA>,
     enabled?: Enabled,
   ): GetReturn<TT> {
     const xhr: Xhr<TT> = new Xhr<TT>();
@@ -130,7 +126,7 @@ export default function <T, Z extends TypeAllowed>(args?: UseXhr<T, Z>) {
 
         // use params from second args of get function
         if (!params) {
-          params = (unwrapParametersObj.params || {}) as Params<ZZ>;
+          params = (unwrapParametersObj.params || {}) as RequiredParams<ZZ, AA>;
         }
 
         duration = unwrapParametersObj.cacheDuration;
@@ -152,15 +148,15 @@ export default function <T, Z extends TypeAllowed>(args?: UseXhr<T, Z>) {
       }
 
       // merge params
-      let p = unref(_getParams.params || params || {} as Params<ZZ>);
+      let p = unref(_getParams.params || params || {});
       if (typeof p === 'function') {
-        p = (p as () => ZZ)();
+        p = (p as () => ZZ)() as RequiredParams<ZZ, AA>;
       }
 
-      _getParams.params = {
-        ...p as ZZ,
+      _getParams.params = ({
+        ...p,
         ...(isRef(params) ? (params.value || {}) : params),
-      };
+      }) as ZZ;
 
       url = typeof _url === 'function' ? _url(_getParams.params) : unref(_url);
       _getParams.url = url;
@@ -285,7 +281,11 @@ export default function <T, Z extends TypeAllowed>(args?: UseXhr<T, Z>) {
     };
   }
 
-  const update = <TT = T, ZZ = Z>(method: 'post' | 'delete' | 'put', xhrConfig?: $UpdateConfigArgs, params?: Params<ZZ>) => {
+  const update = <TT = T, ZZ extends TypeAllowed = Z, AA extends TypeAllowed[] = A>(
+    method: 'post' | 'delete' | 'put',
+    xhrConfig?: $UpdateConfigArgs,
+    params?: RequiredParams<ZZ, AA>,
+  ) => {
     const updateArgs = computed(() => {
       const _postArgs: $UpdateConfigArgs<ZZ> = {};
 
@@ -293,7 +293,7 @@ export default function <T, Z extends TypeAllowed>(args?: UseXhr<T, Z>) {
 
       // use params from second args of post function
       if (!params) {
-        params = (unwrapParametersObj.params || {}) as Params<ZZ>;
+        params = (unwrapParametersObj.params || {}) as RequiredParams<ZZ, AA>;
       }
       _postArgs.params = unref<ZZ>(params as ZZ);
 
@@ -301,12 +301,6 @@ export default function <T, Z extends TypeAllowed>(args?: UseXhr<T, Z>) {
         _postArgs.token = getTokenValue(token);
       }
 
-      // merge params
-      let p = unref(_postArgs.params || params || {} as Params<ZZ>);
-      if (typeof p === 'function') {
-        p = (p as () => ZZ)();
-      }
-
       _postArgs.url = unref(unwrapParametersObj.url);
 
       return _postArgs;
@@ -344,11 +338,20 @@ export default function <T, Z extends TypeAllowed>(args?: UseXhr<T, Z>) {
     };
   };
 
-  const post = <TT = T, ZZ = Z>(xhrConfig?: $UpdateConfigArgs, params?: Params<ZZ>) => update<TT, ZZ>('post', xhrConfig, params);
+  const post = <TT = T, ZZ extends TypeAllowed = Z, AA extends TypeAllowed[] = A>(
+    xhrConfig?: $UpdateConfigArgs,
+    params?: RequiredParams<ZZ, AA>,
+  ) => update<TT, ZZ, AA>('post', xhrConfig, params);
 
-  const put = <TT = T, ZZ = Z>(xhrConfig?: $UpdateConfigArgs, params?: Params<ZZ>) => update<TT, ZZ>('put', xhrConfig, params);
+  const put = <TT = T, ZZ extends TypeAllowed = Z, AA extends TypeAllowed[] = A>(
+    xhrConfig?: $UpdateConfigArgs,
+    params?: RequiredParams<ZZ, AA>,
+  ) => update<TT, ZZ, AA>('put', xhrConfig, params);
 
-  const _delete = <TT = T, ZZ = Z>(xhrConfig?: $UpdateConfigArgs, params?: Params<ZZ>) => update<TT, ZZ>('delete', xhrConfig, params);
+  const _delete = <TT = T, ZZ extends TypeAllowed = Z, AA extends TypeAllowed[] = A>(
+    xhrConfig?: $UpdateConfigArgs,
+    params?: RequiredParams<ZZ, AA>,
+  ) => update<TT, ZZ, AA>('delete', xhrConfig, params);
 
   if (!legacy) {
     onBeforeUnmount(() => {