nuxt/dist/app/composables/addons.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 { ArrayItems, UnionToIntersection } from "../utils.js";
import { UseFetch, UseFetchOptions } from "./fetch.js";
import { AsyncData, AsyncDataMiddleware, AsyncDataOptions, UseAsyncData, _AsyncData } from "./asyncData.js";
import { FetchOptions } from "ofetch";
//#region src/app/composables/addons.d.ts
declare const AddonMarker: unique symbol;
type SerializableValue = string | number | boolean | null | undefined | SerializableValue[] | {
  [key: string]: SerializableValue;
};
export type AsyncDataAddonInstance = _AsyncData<unknown, unknown>;
export type AsyncDataAddonSetup<Ext> = (asyncData: AsyncDataAddonInstance) => Ext | void;
interface AddonChains {
  middleware: AsyncDataMiddleware<any>[];
}
export type UseAsyncDataAddonOptions<Opts extends Record<string, any> = {}> = Omit<AsyncDataOptions<any, any>, 'transform' | 'middleware'> & AddonChains & Opts;
export type UseFetchAddonOptions<Opts extends Record<string, any> = {}> = Omit<UseFetchOptions<any, any>, 'transform' | 'middleware' | 'onRequest' | 'onRequestError' | 'onResponse' | 'onResponseError'> & AddonChains & {
  onRequest: ArrayItems<FetchOptions['onRequest']>[];
  onRequestError: ArrayItems<FetchOptions['onRequestError']>[];
  onResponse: ArrayItems<FetchOptions['onResponse']>[];
  onResponseError: ArrayItems<FetchOptions['onResponseError']>[];
} & Opts;
export interface UseAsyncDataAddon<Opts extends Record<string, any> = {}, Ext = {}> {
  setup: (options: UseAsyncDataAddonOptions<Opts>) => AsyncDataAddonSetup<Ext> | void;
  /** @internal */
  [AddonMarker]?: {
    options: Opts;
    extension: Ext;
  };
}
export interface UseFetchAddon<Opts extends Record<string, any> = {}, Ext = {}> {
  /** Segment added to the auto-generated key, derived from custom options that affect the response. */
  key?: (options: UseFetchAddonOptions<Opts>) => SerializableValue;
  setup: (options: UseFetchAddonOptions<Opts>) => AsyncDataAddonSetup<Ext> | void;
  /** @internal */
  [AddonMarker]?: {
    options: Opts;
    extension: Ext;
  };
}
/**
 * Define a reusable addon for composables created with `createUseFetch`.
 * @since 4.6.0
 */
export declare function defineUseFetchAddon<Opts extends Record<string, any> = {}, Ext = {}>(addon: UseFetchAddon<Opts, Ext>): UseFetchAddon<Opts, Ext>;
/**
 * Define a reusable addon for composables created with `createUseAsyncData`.
 * @since 4.6.0
 */
export declare function defineUseAsyncDataAddon<Opts extends Record<string, any> = {}, Ext = {}>(addon: UseAsyncDataAddon<Opts, Ext>): UseAsyncDataAddon<Opts, Ext>;
export type MergedAddonsOptions<Addons extends ReadonlyArray<any>> = [Addons[number]] extends [never] ? {} : UnionToIntersection<Addons[number] extends {
  [AddonMarker]?: {
    options: infer O;
    extension: any;
  };
} ? O : never>;
type AddonsExtensions<Addons extends ReadonlyArray<any>> = UnionToIntersection<Addons[number] extends {
  [AddonMarker]?: {
    options: any;
    extension: infer E;
  };
} ? E : never>;
export type MergedAddonsExtensions<Addons extends ReadonlyArray<any>> = [keyof AddonsExtensions<Addons>] extends [never] ? {} : Omit<AddonsExtensions<Addons>, PromiseMethod>;
declare const PROMISE_METHODS: readonly ["then", "catch", "finally"];
type PromiseMethod = typeof PROMISE_METHODS[number];
/** @internal */
export declare function applyUseFetchAddons(create: (options: Record<string, any>) => (...args: any[]) => AsyncData<unknown, unknown>, { addons, ...factoryOptions }: Record<string, any>): UseFetch;
/** @internal */
export declare function applyUseAsyncDataAddons(create: (options: Record<string, any>) => (...args: any[]) => AsyncData<unknown, unknown>, { addons, ...factoryOptions }: Record<string, any>): UseAsyncData;
//#endregion
export {};