nuxt/dist/app/composables/fetch.d.ts

Nuxt is a free and open-source framework with an intuitive and extendable way to create type-safe, performant and production-grade full-stack web applications and websites with Vue.js.

import { NuxtError } from "../error.js";
import "./error.js";
import { AcceptedDeclaredMethod, AcceptedMethod, AnyServerRouteMethod, AvailableServerRouteMethod, DeclaredFetchRequest, DeclaredRequestShape, DeclaredServerResponse, EffectiveBaseURL, FallbackBaseURL, RequiredDeclaredBody, RequiredFetchBody, ResolvedFetchPath, ServerRouteMethod, ServerRouteMethods, TypedFetch, TypedFetchOptions, TypedFetchPathInput, TypedFetchRequest, TypedRequestShape, TypedServerError, TypedServerResponse, UnmatchedDeclaredRouteArgs, UnmatchedRouteArgs, ValidDeclaredFetchPath, ValidTypedFetchPath } from "../types/fetch.js";
import { MergedAddonsExtensions, MergedAddonsOptions, UseFetchAddon } from "./addons.js";
import { AsyncData, AsyncDataOptions, AugmentedAsyncData, KeysOf, MultiWatchSources, PickFrom, _Transform } from "./asyncData.js";
import { MaybeRefOrGetter, Ref } from "vue";
import { FetchOptions, ResponseType } from "ofetch";
//#region src/app/composables/fetch.d.ts
export type FetchResult<ReqT, M extends AnyServerRouteMethod> = TypedServerResponse<ReqT, unknown, M>;
type ComputedOptions<T extends Record<string, any>> = { [K in keyof T]: T[K] extends Function ? T[K] : ComputedOptions<T[K]> | MaybeRefOrGetter<T[K]>; };
type NuxtFetchOptions<R, M extends AnyServerRouteMethod = 'get', DataT = any, B extends string = string> = Omit<FetchOptions<ResponseType, DataT>, 'baseURL' | 'cache' | 'method' | 'body' | 'query' | 'params' | 'headers'> & {
  baseURL?: B;
  method?: AcceptedMethod<R, M>;
  cache?: FetchOptions<ResponseType, DataT>['cache'] | false;
} & TypedRequestShape<R, M>;
type ComputedFetchOptions<R, M extends AnyServerRouteMethod, DataT = any, B extends string = string> = ComputedOptions<NuxtFetchOptions<R, M, DataT, B>>;
export interface UseFetchOptions<ResT, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined, R extends string = string, M extends AnyServerRouteMethod = 'get', B extends string = string> extends Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'watch'>, Omit<ComputedFetchOptions<R, M, DataT, B>, 'timeout'> {
  key?: MaybeRefOrGetter<string>;
  $fetch?: TypedFetch;
  watch?: MultiWatchSources | false;
}
export interface UseFetchOptionsWithTransform<ResT, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined, R extends string = string, M extends AnyServerRouteMethod = 'get', B extends string = string> extends Omit<UseFetchOptions<ResT, DataT, PickKeys, DefaultT, R, M, B>, 'transform'> {
  transform: _Transform<ResT, DataT>;
}
type FetchFactoryDataT<FDataT, _ResT> = [unknown] extends [FDataT] ? _ResT : FDataT;
type FetchFactoryDefaultT<FDefaultT, Fallback> = [undefined] extends [FDefaultT] ? Fallback : FDefaultT;
type FetchFactoryPickKeys<FPickKeys, PickKeys, DataT> = [Array<never>] extends [FPickKeys] ? PickKeys : FPickKeys & KeysOf<DataT>;
export interface UseFetch<FDataT = unknown, FPickKeys extends KeysOf<FDataT> = never[], FDefaultT = undefined, FBaseURL extends string = '', FAddonOpts = {}, FAddonExt = {}> {
  <ResT = void, ErrorT = NuxtError<unknown>, ReqT extends TypedFetchRequest = TypedFetchRequest, const Method extends AnyServerRouteMethod = ResT extends void ? 'get' : AnyServerRouteMethod, const BaseURL extends string = FallbackBaseURL<ReqT, TypedFetchRequest>, _ReqT = ResolvedFetchPath<ReqT, EffectiveBaseURL<FBaseURL, BaseURL>>, _ResT = ResT extends void ? FetchResult<_ReqT, Method> : ResT, DataT = _ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = FetchFactoryDefaultT<FDefaultT, undefined>>(request: Ref<ReqT> | ReqT | (() => ReqT), opts: UseFetchOptionsWithTransform<_ResT, DataT, PickKeys, DefaultT, _ReqT & string, Method, BaseURL> & RequiredFetchBody<_ReqT, Method> & FAddonOpts, ...unmatched: UnmatchedRouteArgs<_ReqT, Method>): AugmentedAsyncData<PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined, FAddonExt>;
  <ResT = void, ErrorT = NuxtError<unknown>, ReqT extends TypedFetchRequest = TypedFetchRequest, const Method extends AnyServerRouteMethod = ResT extends void ? 'get' : AnyServerRouteMethod, const BaseURL extends string = FallbackBaseURL<ReqT, TypedFetchRequest>, _ReqT = ResolvedFetchPath<ReqT, EffectiveBaseURL<FBaseURL, BaseURL>>, _ResT = ResT extends void ? FetchResult<_ReqT, Method> : ResT, DataT = _ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = FetchFactoryDefaultT<FDefaultT, DataT>>(request: Ref<ReqT> | ReqT | (() => ReqT), opts: UseFetchOptionsWithTransform<_ResT, DataT, PickKeys, DefaultT, _ReqT & string, Method, BaseURL> & RequiredFetchBody<_ReqT, Method> & FAddonOpts, ...unmatched: UnmatchedRouteArgs<_ReqT, Method>): AugmentedAsyncData<PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined, FAddonExt>;
  <ResT = void, ErrorT = NuxtError<unknown>, ReqT extends TypedFetchRequest = TypedFetchRequest, const Method extends AnyServerRouteMethod = ResT extends void ? 'get' : AnyServerRouteMethod, const BaseURL extends string = FallbackBaseURL<ReqT, TypedFetchRequest>, _ReqT = ResolvedFetchPath<ReqT, EffectiveBaseURL<FBaseURL, BaseURL>>, _ResT = ResT extends void ? FetchResult<_ReqT, Method> : ResT, DataT = FetchFactoryDataT<FDataT, _ResT>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = FetchFactoryDefaultT<FDefaultT, undefined>>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, _ReqT & string, Method, BaseURL> & RequiredFetchBody<_ReqT, Method> & FAddonOpts, ...unmatched: UnmatchedRouteArgs<_ReqT, Method>): AugmentedAsyncData<PickFrom<DataT, FetchFactoryPickKeys<FPickKeys, PickKeys, DataT>> | DefaultT, ErrorT | undefined, FAddonExt>;
  <ResT = void, ErrorT = NuxtError<unknown>, ReqT extends TypedFetchRequest = TypedFetchRequest, const Method extends AnyServerRouteMethod = ResT extends void ? 'get' : AnyServerRouteMethod, const BaseURL extends string = FallbackBaseURL<ReqT, TypedFetchRequest>, _ReqT = ResolvedFetchPath<ReqT, EffectiveBaseURL<FBaseURL, BaseURL>>, _ResT = ResT extends void ? FetchResult<_ReqT, Method> : ResT, DataT = FetchFactoryDataT<FDataT, _ResT>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = FetchFactoryDefaultT<FDefaultT, DataT>>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, _ReqT & string, Method, BaseURL> & RequiredFetchBody<_ReqT, Method> & FAddonOpts, ...unmatched: UnmatchedRouteArgs<_ReqT, Method>): AugmentedAsyncData<PickFrom<DataT, FetchFactoryPickKeys<FPickKeys, PickKeys, DataT>> | DefaultT, ErrorT | undefined, FAddonExt>;
  <ResT = void, ErrorT = NuxtError<unknown>, ReqT extends TypedFetchRequest = TypedFetchRequest, const Method extends AnyServerRouteMethod = ResT extends void ? 'get' : AnyServerRouteMethod, const BaseURL extends string = FallbackBaseURL<ReqT, TypedFetchRequest>, _ReqT = ResolvedFetchPath<ReqT, EffectiveBaseURL<FBaseURL, BaseURL>>, _ResT = ResT extends void ? FetchResult<_ReqT, Method> : ResT, DataT = _ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(request: Ref<ReqT> | ReqT | (() => ReqT), arg1?: string | (UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, _ReqT & string, Method, BaseURL> & RequiredFetchBody<_ReqT, Method> & FAddonOpts), arg2?: string, ...unmatched: UnmatchedRouteArgs<_ReqT, Method>): AugmentedAsyncData<PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined, FAddonExt>;
  <ResT = void, ErrorT = NuxtError<unknown>, ReqT extends TypedFetchPathInput = TypedFetchPathInput, const Method extends AnyServerRouteMethod = ResT extends void ? 'get' : AnyServerRouteMethod, const BaseURL extends string = FallbackBaseURL<ReqT, TypedFetchPathInput>, _ReqT = ResolvedFetchPath<ReqT, EffectiveBaseURL<FBaseURL, BaseURL>>, _ResT = ResT extends void ? FetchResult<_ReqT, Method> : ResT, DataT = _ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = FetchFactoryDefaultT<FDefaultT, undefined>>(request: (Ref<ReqT> | ReqT | (() => ReqT)) & ValidTypedFetchPath<_ReqT, Method>, opts: UseFetchOptionsWithTransform<_ResT, DataT, PickKeys, DefaultT, _ReqT & string, Method, BaseURL> & RequiredFetchBody<_ReqT, Method> & FAddonOpts): AugmentedAsyncData<PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined, FAddonExt>;
  <ResT = void, ErrorT = NuxtError<unknown>, ReqT extends TypedFetchPathInput = TypedFetchPathInput, const Method extends AnyServerRouteMethod = ResT extends void ? 'get' : AnyServerRouteMethod, const BaseURL extends string = FallbackBaseURL<ReqT, TypedFetchPathInput>, _ReqT = ResolvedFetchPath<ReqT, EffectiveBaseURL<FBaseURL, BaseURL>>, _ResT = ResT extends void ? FetchResult<_ReqT, Method> : ResT, DataT = _ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = FetchFactoryDefaultT<FDefaultT, DataT>>(request: (Ref<ReqT> | ReqT | (() => ReqT)) & ValidTypedFetchPath<_ReqT, Method>, opts: UseFetchOptionsWithTransform<_ResT, DataT, PickKeys, DefaultT, _ReqT & string, Method, BaseURL> & RequiredFetchBody<_ReqT, Method> & FAddonOpts): AugmentedAsyncData<PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined, FAddonExt>;
  <ResT = void, ErrorT = NuxtError<unknown>, ReqT extends TypedFetchPathInput = TypedFetchPathInput, const Method extends AnyServerRouteMethod = ResT extends void ? 'get' : AnyServerRouteMethod, const BaseURL extends string = FallbackBaseURL<ReqT, TypedFetchPathInput>, _ReqT = ResolvedFetchPath<ReqT, EffectiveBaseURL<FBaseURL, BaseURL>>, _ResT = ResT extends void ? FetchResult<_ReqT, Method> : ResT, DataT = FetchFactoryDataT<FDataT, _ResT>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = FetchFactoryDefaultT<FDefaultT, undefined>>(request: (Ref<ReqT> | ReqT | (() => ReqT)) & ValidTypedFetchPath<_ReqT, Method>, opts?: UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, _ReqT & string, Method, BaseURL> & RequiredFetchBody<_ReqT, Method> & FAddonOpts): AugmentedAsyncData<PickFrom<DataT, FetchFactoryPickKeys<FPickKeys, PickKeys, DataT>> | DefaultT, ErrorT | undefined, FAddonExt>;
  <ResT = void, ErrorT = NuxtError<unknown>, ReqT extends TypedFetchPathInput = TypedFetchPathInput, const Method extends AnyServerRouteMethod = ResT extends void ? 'get' : AnyServerRouteMethod, const BaseURL extends string = FallbackBaseURL<ReqT, TypedFetchPathInput>, _ReqT = ResolvedFetchPath<ReqT, EffectiveBaseURL<FBaseURL, BaseURL>>, _ResT = ResT extends void ? FetchResult<_ReqT, Method> : ResT, DataT = FetchFactoryDataT<FDataT, _ResT>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = FetchFactoryDefaultT<FDefaultT, DataT>>(request: (Ref<ReqT> | ReqT | (() => ReqT)) & ValidTypedFetchPath<_ReqT, Method>, opts?: UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, _ReqT & string, Method, BaseURL> & RequiredFetchBody<_ReqT, Method> & FAddonOpts): AugmentedAsyncData<PickFrom<DataT, FetchFactoryPickKeys<FPickKeys, PickKeys, DataT>> | DefaultT, ErrorT | undefined, FAddonExt>;
  <ResT = void, ErrorT = NuxtError<unknown>, ReqT extends TypedFetchPathInput = TypedFetchPathInput, const Method extends AnyServerRouteMethod = ResT extends void ? 'get' : AnyServerRouteMethod, const BaseURL extends string = FallbackBaseURL<ReqT, TypedFetchPathInput>, _ReqT = ResolvedFetchPath<ReqT, EffectiveBaseURL<FBaseURL, BaseURL>>, _ResT = ResT extends void ? FetchResult<_ReqT, Method> : ResT, DataT = _ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(request: (Ref<ReqT> | ReqT | (() => ReqT)) & ValidTypedFetchPath<_ReqT, Method>, arg1?: string | (UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, _ReqT & string, Method, BaseURL> & RequiredFetchBody<_ReqT, Method> & FAddonOpts), arg2?: string): AugmentedAsyncData<PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined, FAddonExt>;
}
/** The response a request to `ReqT` resolves to, against a route set a client declares. */
export type DeclaredFetchResult<Schema, ReqT, M extends AnyServerRouteMethod> = DeclaredServerResponse<Schema, ReqT, unknown, M>;
type DeclaredFetchOptionsBase<Schema, R, M extends AnyServerRouteMethod = 'get', DataT = any> = Omit<FetchOptions<ResponseType, DataT>, 'cache' | 'method' | 'body' | 'query' | 'params' | 'headers'> & {
  method?: AcceptedDeclaredMethod<Schema, R, M>;
  cache?: FetchOptions<ResponseType, DataT>['cache'] | false;
} & DeclaredRequestShape<Schema, R, M>;
/**
 * As {@link UseFetchOptions}, for a client that declared the route set it serves.
 *
 * `baseURL` stays ofetch's own: the declared paths are the ones the API documents, so they are
 * matched as written and the base is transport rather than part of the route.
 */
export interface DeclaredUseFetchOptions<Schema, ResT, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined, R = string, M extends AnyServerRouteMethod = 'get'> extends Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'watch'>, Omit<ComputedOptions<DeclaredFetchOptionsBase<Schema, R, M, DataT>>, 'timeout'> {
  key?: MaybeRefOrGetter<string>;
  $fetch?: TypedFetch;
  watch?: MultiWatchSources | false;
  /**
   * The routes this client serves, read as a type only.
   *
   * Pass `{} as MyRoutes` - by hand, or an interface a generator emitted from an OpenAPI document -
   * and every request the composable makes is resolved against that route set instead of the app's
   * own. The value is dropped before the request is made.
   */
  routes?: Schema;
}
export interface DeclaredUseFetchOptionsWithTransform<Schema, ResT, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined, R = string, M extends AnyServerRouteMethod = 'get'> extends Omit<DeclaredUseFetchOptions<Schema, ResT, DataT, PickKeys, DefaultT, R, M>, 'transform'> {
  transform: _Transform<ResT, DataT>;
}
/**
 * The composable {@link createUseFetch} returns for a client that declared its own route set.
 *
 * The same shapes as {@link UseFetch}, resolved against `Schema`. A path outside that set is turned
 * away by the trailing `UnmatchedDeclaredRouteArgs`, exactly as an unregistered path is for the
 * app's own routes.
 */
export interface DeclaredUseFetch<Schema, FDataT = unknown, FPickKeys extends KeysOf<FDataT> = never[], FDefaultT = undefined, FAddonOpts = {}, FAddonExt = {}> {
  <ResT = void, ErrorT = NuxtError<unknown>, ReqT extends DeclaredFetchRequest<Schema> = DeclaredFetchRequest<Schema>, const Method extends AnyServerRouteMethod = ResT extends void ? 'get' : AnyServerRouteMethod, _ResT = ResT extends void ? DeclaredFetchResult<Schema, ReqT, Method> : ResT, DataT = _ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = FetchFactoryDefaultT<FDefaultT, undefined>>(request: Ref<ReqT> | ReqT | (() => ReqT), opts: DeclaredUseFetchOptionsWithTransform<Schema, _ResT, DataT, PickKeys, DefaultT, ReqT, Method> & RequiredDeclaredBody<Schema, ReqT, Method> & FAddonOpts, ...unmatched: UnmatchedDeclaredRouteArgs<Schema, ReqT, Method>): AugmentedAsyncData<PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined, FAddonExt>;
  <ResT = void, ErrorT = NuxtError<unknown>, ReqT extends DeclaredFetchRequest<Schema> = DeclaredFetchRequest<Schema>, const Method extends AnyServerRouteMethod = ResT extends void ? 'get' : AnyServerRouteMethod, _ResT = ResT extends void ? DeclaredFetchResult<Schema, ReqT, Method> : ResT, DataT = _ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = FetchFactoryDefaultT<FDefaultT, DataT>>(request: Ref<ReqT> | ReqT | (() => ReqT), opts: DeclaredUseFetchOptionsWithTransform<Schema, _ResT, DataT, PickKeys, DefaultT, ReqT, Method> & RequiredDeclaredBody<Schema, ReqT, Method> & FAddonOpts, ...unmatched: UnmatchedDeclaredRouteArgs<Schema, ReqT, Method>): AugmentedAsyncData<PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined, FAddonExt>;
  <ResT = void, ErrorT = NuxtError<unknown>, ReqT extends DeclaredFetchRequest<Schema> = DeclaredFetchRequest<Schema>, const Method extends AnyServerRouteMethod = ResT extends void ? 'get' : AnyServerRouteMethod, _ResT = ResT extends void ? DeclaredFetchResult<Schema, ReqT, Method> : ResT, DataT = FetchFactoryDataT<FDataT, _ResT>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = FetchFactoryDefaultT<FDefaultT, undefined>>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: DeclaredUseFetchOptions<Schema, _ResT, DataT, PickKeys, DefaultT, ReqT, Method> & RequiredDeclaredBody<Schema, ReqT, Method> & FAddonOpts, ...unmatched: UnmatchedDeclaredRouteArgs<Schema, ReqT, Method>): AugmentedAsyncData<PickFrom<DataT, FetchFactoryPickKeys<FPickKeys, PickKeys, DataT>> | DefaultT, ErrorT | undefined, FAddonExt>;
  <ResT = void, ErrorT = NuxtError<unknown>, ReqT extends DeclaredFetchRequest<Schema> = DeclaredFetchRequest<Schema>, const Method extends AnyServerRouteMethod = ResT extends void ? 'get' : AnyServerRouteMethod, _ResT = ResT extends void ? DeclaredFetchResult<Schema, ReqT, Method> : ResT, DataT = FetchFactoryDataT<FDataT, _ResT>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = FetchFactoryDefaultT<FDefaultT, DataT>>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: DeclaredUseFetchOptions<Schema, _ResT, DataT, PickKeys, DefaultT, ReqT, Method> & RequiredDeclaredBody<Schema, ReqT, Method> & FAddonOpts, ...unmatched: UnmatchedDeclaredRouteArgs<Schema, ReqT, Method>): AugmentedAsyncData<PickFrom<DataT, FetchFactoryPickKeys<FPickKeys, PickKeys, DataT>> | DefaultT, ErrorT | undefined, FAddonExt>;
  <ResT = void, ErrorT = NuxtError<unknown>, ReqT extends DeclaredFetchRequest<Schema> = DeclaredFetchRequest<Schema>, const Method extends AnyServerRouteMethod = ResT extends void ? 'get' : AnyServerRouteMethod, _ResT = ResT extends void ? DeclaredFetchResult<Schema, ReqT, Method> : ResT, DataT = _ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(request: Ref<ReqT> | ReqT | (() => ReqT), arg1?: string | (DeclaredUseFetchOptions<Schema, _ResT, DataT, PickKeys, DefaultT, ReqT, Method> & RequiredDeclaredBody<Schema, ReqT, Method> & FAddonOpts), arg2?: string, ...unmatched: UnmatchedDeclaredRouteArgs<Schema, ReqT, Method>): AugmentedAsyncData<PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined, FAddonExt>;
  <ReqT extends string, const Method extends AnyServerRouteMethod = 'get'>(request: (Ref<ReqT> | ReqT | (() => ReqT)) & ValidDeclaredFetchPath<Schema, ReqT, Method>, opts?: {
    method?: Method;
  }, key?: string, ...resolves: unknown extends ValidDeclaredFetchPath<Schema, ReqT, Method> ? [never] : []): AsyncData<unknown, NuxtError<unknown> | undefined>;
}
type CreateUseFetchOptions<ResT, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined, R extends string = string, M extends AnyServerRouteMethod = 'get', B extends string = string, Addons extends ReadonlyArray<UseFetchAddon<any, any>> = []> = Partial<UseFetchOptions<ResT, DataT, PickKeys, DefaultT, R, M, B>> & {
  addons?: Addons;
};
export interface CreateUseFetch {
  <FSchema, FResT = void, FReqT extends DeclaredFetchRequest<FSchema> = DeclaredFetchRequest<FSchema>, const FMethod extends AnyServerRouteMethod = 'get', F_ResT = FResT extends void ? DeclaredFetchResult<FSchema, FReqT, FMethod> : FResT, FDataT = F_ResT, FPickKeys extends KeysOf<FDataT> = KeysOf<FDataT>, FDefaultT = undefined, const FAddons extends ReadonlyArray<UseFetchAddon<any, any>> = []>(options: Partial<DeclaredUseFetchOptions<FSchema, F_ResT, FDataT, FPickKeys, FDefaultT, FReqT, FMethod>> & {
    routes: FSchema;
    addons?: FAddons;
  }): DeclaredUseFetch<FSchema, FDataT, FPickKeys, FDefaultT, MergedAddonsOptions<FAddons>, MergedAddonsExtensions<FAddons>>;
  <FResT = void, FReqT extends TypedFetchRequest = TypedFetchRequest, const FMethod extends AnyServerRouteMethod = 'get', const FBaseURL extends string = FResT extends void ? '' : string, F_ResT = FResT extends void ? FetchResult<FReqT, FMethod> : FResT, FDataT = F_ResT, FPickKeys extends KeysOf<FDataT> = KeysOf<FDataT>, FDefaultT = undefined, const FAddons extends ReadonlyArray<UseFetchAddon<any, any>> = []>(options?: CreateUseFetchOptions<F_ResT, FDataT, FPickKeys, FDefaultT, FReqT & string, FMethod, FBaseURL, FAddons> | ((callerOptions: UseFetchOptions<unknown>) => Partial<UseFetchOptions<F_ResT, FDataT, FPickKeys, FDefaultT, FReqT & string, FMethod, FBaseURL>>)): UseFetch<FDataT, FPickKeys, FDefaultT, FBaseURL, MergedAddonsOptions<FAddons>, MergedAddonsExtensions<FAddons>>;
}
/**
 * A factory function to create a custom `useFetch` composable with pre-defined default options.
 * @since 4.4.0
 */
export declare const createUseFetch: CreateUseFetch;
/** @internal */
export declare function _createUseFetch<FResT = void, FReqT extends TypedFetchRequest = TypedFetchRequest, const FMethod extends AnyServerRouteMethod = 'get', F_ResT = FResT extends void ? FetchResult<FReqT, FMethod> : FResT, FDataT = F_ResT, FPickKeys extends KeysOf<FDataT> = KeysOf<FDataT>, FDefaultT = undefined>(options?: Partial<UseFetchOptions<F_ResT, FDataT, FPickKeys, FDefaultT, FReqT & string, FMethod>> | ((callerOptions: UseFetchOptions<unknown>) => Partial<UseFetchOptions<F_ResT, FDataT, FPickKeys, FDefaultT, FReqT & string, FMethod>>)): UseFetch<FDataT, FPickKeys, FDefaultT>;
export declare const useFetch: UseFetch;
export declare const useLazyFetch: UseFetch;
//#endregion
export type { TypedFetch as $Fetch, AnyServerRouteMethod, AvailableServerRouteMethod, ServerRouteMethod, ServerRouteMethods, TypedFetch, TypedFetchOptions, TypedFetchRequest, TypedServerError, TypedServerResponse };