@depup/nuxt 4.2.2-depup.0

package/dist/app/composables/state.js

@@ -0,0 +1,40 @@
+import { isRef, toRef } from "vue";
+import { useNuxtApp } from "../nuxt.js";
+import { toArray } from "../utils.js";
+const useStateKeyPrefix = "$s";
+export function useState(...args) {
+  const autoKey = typeof args[args.length - 1] === "string" ? args.pop() : void 0;
+  if (typeof args[0] !== "string") {
+    args.unshift(autoKey);
+  }
+  const [_key, init] = args;
+  if (!_key || typeof _key !== "string") {
+    throw new TypeError("[nuxt] [useState] key must be a string: " + _key);
+  }
+  if (init !== void 0 && typeof init !== "function") {
+    throw new Error("[nuxt] [useState] init must be a function: " + init);
+  }
+  const key = useStateKeyPrefix + _key;
+  const nuxtApp = useNuxtApp();
+  const state = toRef(nuxtApp.payload.state, key);
+  if (state.value === void 0 && init) {
+    const initialValue = init();
+    if (isRef(initialValue)) {
+      nuxtApp.payload.state[key] = initialValue;
+      return initialValue;
+    }
+    state.value = initialValue;
+  }
+  return state;
+}
+export function clearNuxtState(keys) {
+  const nuxtApp = useNuxtApp();
+  const _allKeys = Object.keys(nuxtApp.payload.state).map((key) => key.substring(useStateKeyPrefix.length));
+  const _keys = !keys ? _allKeys : typeof keys === "function" ? _allKeys.filter(keys) : toArray(keys);
+  for (const _key of _keys) {
+    const key = useStateKeyPrefix + _key;
+    if (key in nuxtApp.payload.state) {
+      nuxtApp.payload.state[key] = void 0;
+    }
+  }
+}

package/dist/app/composables/url.d.ts

@@ -0,0 +1,3 @@
+import { getRequestURL } from 'h3';
+/** @since 3.5.0 */
+export declare function useRequestURL(opts?: Parameters<typeof getRequestURL>[1]): URL;

package/dist/app/composables/url.js

@@ -0,0 +1,8 @@
+import { getRequestURL } from "h3";
+import { useRequestEvent } from "./ssr.js";
+export function useRequestURL(opts) {
+  if (import.meta.server) {
+    return getRequestURL(useRequestEvent(), opts);
+  }
+  return new URL(globalThis.location.href);
+}

package/dist/app/config.d.ts

@@ -0,0 +1,14 @@
+import type { AppConfig } from 'nuxt/schema';
+type DeepPartial<T> = T extends Function ? T : T extends Record<string, any> ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export declare const _getAppConfig: () => AppConfig;
+export declare function useAppConfig(): AppConfig;
+export declare function _replaceAppConfig(newConfig: AppConfig): void;
+/**
+ * Deep assign the current appConfig with the new one.
+ *
+ * Will preserve existing properties.
+ */
+export declare function updateAppConfig(appConfig: DeepPartial<AppConfig>): void;
+export {};

package/dist/app/config.js

@@ -0,0 +1,72 @@
+import { reactive } from "vue";
+import { klona } from "klona";
+import { useNuxtApp } from "./nuxt.js";
+import __appConfig from "#build/app.config.mjs";
+export const _getAppConfig = () => __appConfig;
+function isPojoOrArray(val) {
+  return Array.isArray(val) || !!val && typeof val === "object" && val.constructor?.name === "Object";
+}
+function deepDelete(obj, newObj) {
+  if (Array.isArray(obj) && Array.isArray(newObj)) {
+    obj.length = 0;
+    obj.push(...newObj);
+    return;
+  }
+  for (const key in obj) {
+    const val = newObj[key];
+    if (!(key in newObj)) {
+      delete obj[key];
+    }
+    if (isPojoOrArray(val)) {
+      deepDelete(obj[key], newObj[key]);
+    }
+  }
+}
+function deepAssign(obj, newObj) {
+  for (const key in newObj) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const val = newObj[key];
+    if (isPojoOrArray(val)) {
+      const defaultVal = Array.isArray(val) ? [] : {};
+      if (Array.isArray(obj[key]) !== Array.isArray(val)) {
+        obj[key] = defaultVal;
+      } else {
+        obj[key] ??= defaultVal;
+      }
+      deepAssign(obj[key], val);
+    } else {
+      obj[key] = val;
+    }
+  }
+}
+export function useAppConfig() {
+  const nuxtApp = useNuxtApp();
+  nuxtApp._appConfig ||= import.meta.server ? klona(__appConfig) : reactive(__appConfig);
+  return nuxtApp._appConfig;
+}
+export function _replaceAppConfig(newConfig) {
+  const appConfig = useAppConfig();
+  deepAssign(appConfig, newConfig);
+  deepDelete(appConfig, newConfig);
+}
+export function updateAppConfig(appConfig) {
+  const _appConfig = useAppConfig();
+  deepAssign(_appConfig, appConfig);
+}
+if (import.meta.dev) {
+  if (import.meta.hot) {
+    import.meta.hot.accept((newModule) => {
+      const newConfig = newModule?._getAppConfig();
+      if (newConfig) {
+        _replaceAppConfig(newConfig);
+      }
+    });
+  }
+  if (import.meta.webpackHot) {
+    import.meta.webpackHot.accept("#build/app.config.mjs", () => {
+      _replaceAppConfig(__appConfig);
+    });
+  }
+}

package/dist/app/entry-spa.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

package/dist/app/entry-spa.js

@@ -0,0 +1,2 @@
+export default () => {
+};

package/dist/app/entry.async.d.ts

@@ -0,0 +1,3 @@
+import type { CreateOptions } from './nuxt.js';
+declare const entry: (ctx?: CreateOptions["ssrContext"]) => Promise<any>;
+export default entry;

package/dist/app/entry.async.js

@@ -0,0 +1,5 @@
+const entry = import.meta.server ? (ctx) => import("#app/entry").then((m) => m.default(ctx)) : () => import("#app/entry").then((m) => m.default);
+if (import.meta.client) {
+  entry();
+}
+export default entry;

package/dist/app/entry.d.ts

@@ -0,0 +1,7 @@
+import type { App } from 'vue';
+import '#build/fetch.mjs';
+import '#build/global-polyfills.mjs';
+import type { CreateOptions } from './nuxt.js';
+import '#build/css';
+declare const _default: (ssrContext?: CreateOptions["ssrContext"]) => Promise<App<Element>>;
+export default _default;

package/dist/app/entry.js

@@ -0,0 +1,78 @@
+import { createApp, createSSRApp, nextTick } from "vue";
+import "#build/fetch.mjs";
+import "#build/global-polyfills.mjs";
+import { applyPlugins, createNuxtApp } from "./nuxt.js";
+import { createError } from "./composables/error.js";
+import "#build/css";
+import plugins from "#build/plugins";
+import RootComponent from "#build/root-component.mjs";
+import { appId, appSpaLoaderAttrs, multiApp, spaLoadingTemplateOutside, vueAppRootContainer } from "#build/nuxt.config.mjs";
+let entry;
+if (import.meta.server) {
+  entry = async function createNuxtAppServer(ssrContext) {
+    const vueApp = createApp(RootComponent);
+    const nuxt = createNuxtApp({ vueApp, ssrContext });
+    try {
+      await applyPlugins(nuxt, plugins);
+      await nuxt.hooks.callHook("app:created", vueApp);
+    } catch (error) {
+      await nuxt.hooks.callHook("app:error", error);
+      nuxt.payload.error ||= createError(error);
+    }
+    if (ssrContext?._renderResponse) {
+      throw new Error("skipping render");
+    }
+    return vueApp;
+  };
+}
+if (import.meta.client) {
+  if (import.meta.dev && import.meta.webpackHot) {
+    import.meta.webpackHot.accept();
+  }
+  let vueAppPromise;
+  entry = async function initApp() {
+    if (vueAppPromise) {
+      return vueAppPromise;
+    }
+    const isSSR = Boolean(
+      (multiApp ? window.__NUXT__?.[appId] : window.__NUXT__)?.serverRendered ?? (multiApp ? document.querySelector(`[data-nuxt-data="${appId}"]`) : document.getElementById("__NUXT_DATA__"))?.dataset.ssr === "true"
+    );
+    const vueApp = isSSR ? createSSRApp(RootComponent) : createApp(RootComponent);
+    const nuxt = createNuxtApp({ vueApp });
+    async function handleVueError(error) {
+      await nuxt.callHook("app:error", error);
+      nuxt.payload.error ||= createError(error);
+    }
+    vueApp.config.errorHandler = handleVueError;
+    nuxt.hook("app:suspense:resolve", () => {
+      if (vueApp.config.errorHandler === handleVueError) {
+        vueApp.config.errorHandler = void 0;
+      }
+    });
+    if (spaLoadingTemplateOutside && !isSSR && appSpaLoaderAttrs.id) {
+      nuxt.hook("app:suspense:resolve", () => {
+        document.getElementById(appSpaLoaderAttrs.id)?.remove();
+      });
+    }
+    try {
+      await applyPlugins(nuxt, plugins);
+    } catch (err) {
+      handleVueError(err);
+    }
+    try {
+      await nuxt.hooks.callHook("app:created", vueApp);
+      await nuxt.hooks.callHook("app:beforeMount", vueApp);
+      vueApp.mount(vueAppRootContainer);
+      await nuxt.hooks.callHook("app:mounted", vueApp);
+      await nextTick();
+    } catch (err) {
+      handleVueError(err);
+    }
+    return vueApp;
+  };
+  vueAppPromise = entry().catch((error) => {
+    console.error("Error while mounting app:", error);
+    throw error;
+  });
+}
+export default (ssrContext) => entry(ssrContext);

package/dist/app/index.d.ts

@@ -0,0 +1,12 @@
+import '../../dist/app/types/augments.js';
+export { applyPlugin, applyPlugins, callWithNuxt, createNuxtApp, defineAppConfig, defineNuxtPlugin, definePayloadPlugin, isNuxtPlugin, registerPluginHooks, tryUseNuxtApp, useNuxtApp, useRuntimeConfig } from './nuxt.js';
+export type { CreateOptions, NuxtApp, NuxtPayload, NuxtPluginIndicator, NuxtSSRContext, ObjectPlugin, Plugin, PluginEnvContext, PluginMeta, ResolvedPluginMeta, RuntimeNuxtHooks } from './nuxt.js';
+export { defineNuxtComponent, useAsyncData, useLazyAsyncData, useNuxtData, refreshNuxtData, clearNuxtData, useHydration, callOnce, useState, clearNuxtState, clearError, createError, isNuxtError, showError, useError, useFetch, useLazyFetch, useCookie, refreshCookie, onPrehydrate, prerenderRoutes, useRequestHeaders, useRequestEvent, useRequestFetch, setResponseStatus, useResponseHeader, onNuxtReady, abortNavigation, addRouteMiddleware, defineNuxtRouteMiddleware, onBeforeRouteLeave, onBeforeRouteUpdate, setPageLayout, navigateTo, useRoute, useRouter, preloadComponents, prefetchComponents, preloadRouteComponents, isPrerendered, loadPayload, preloadPayload, definePayloadReducer, definePayloadReviver, getAppManifest, getRouteRules, reloadNuxtApp, useRequestURL, usePreviewMode, useId, useRouteAnnouncer, useHead, useHeadSafe, useServerSeoMeta, useServerHeadSafe, useServerHead, useSeoMeta, injectHead, useRuntimeHook } from './composables/index.js';
+export type { AddRouteMiddlewareOptions, AsyncData, AsyncDataOptions, AsyncDataRequestStatus, CookieOptions, CookieRef, FetchResult, NuxtAppManifest, NuxtAppManifestMeta, NuxtError, Politeness, ReloadNuxtAppOptions, RouteMiddleware, UseFetchOptions } from './composables/index.js';
+export { defineNuxtLink } from './components/index.js';
+export type { NuxtLinkOptions, NuxtLinkProps, NuxtTimeProps } from './components/index.js';
+export { _getAppConfig, updateAppConfig, useAppConfig } from './config.js';
+export { cancelIdleCallback, requestIdleCallback } from './compat/idle-callback.js';
+export type { NuxtAppLiterals, NuxtIslandContext, NuxtIslandResponse, NuxtRenderHTMLContext, PageMeta, NuxtPageProps } from './types.js';
+export declare const isVue2 = false;
+export declare const isVue3 = true;

package/dist/app/index.js

@@ -0,0 +1,8 @@
+import "../../dist/app/types/augments";
+export { applyPlugin, applyPlugins, callWithNuxt, createNuxtApp, defineAppConfig, defineNuxtPlugin, definePayloadPlugin, isNuxtPlugin, registerPluginHooks, tryUseNuxtApp, useNuxtApp, useRuntimeConfig } from "./nuxt.js";
+export { defineNuxtComponent, useAsyncData, useLazyAsyncData, useNuxtData, refreshNuxtData, clearNuxtData, useHydration, callOnce, useState, clearNuxtState, clearError, createError, isNuxtError, showError, useError, useFetch, useLazyFetch, useCookie, refreshCookie, onPrehydrate, prerenderRoutes, useRequestHeaders, useRequestEvent, useRequestFetch, setResponseStatus, useResponseHeader, onNuxtReady, abortNavigation, addRouteMiddleware, defineNuxtRouteMiddleware, onBeforeRouteLeave, onBeforeRouteUpdate, setPageLayout, navigateTo, useRoute, useRouter, preloadComponents, prefetchComponents, preloadRouteComponents, isPrerendered, loadPayload, preloadPayload, definePayloadReducer, definePayloadReviver, getAppManifest, getRouteRules, reloadNuxtApp, useRequestURL, usePreviewMode, useId, useRouteAnnouncer, useHead, useHeadSafe, useServerSeoMeta, useServerHeadSafe, useServerHead, useSeoMeta, injectHead, useRuntimeHook } from "./composables/index.js";
+export { defineNuxtLink } from "./components/index.js";
+export { _getAppConfig, updateAppConfig, useAppConfig } from "./config.js";
+export { cancelIdleCallback, requestIdleCallback } from "./compat/idle-callback.js";
+export const isVue2 = false;
+export const isVue3 = true;

package/dist/app/middleware/manifest-route-rule.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../composables/router.js").RouteMiddleware;
+export default _default;

package/dist/app/middleware/manifest-route-rule.js

@@ -0,0 +1,17 @@
+import { hasProtocol } from "ufo";
+import { defineNuxtRouteMiddleware } from "../composables/router.js";
+import { getRouteRules } from "../composables/manifest.js";
+export default defineNuxtRouteMiddleware(async (to) => {
+  if (import.meta.server || import.meta.test) {
+    return;
+  }
+  const rules = await getRouteRules({ path: to.path });
+  if (rules.redirect) {
+    const path = rules.redirect.includes("#") ? rules.redirect : rules.redirect + to.hash;
+    if (hasProtocol(path, { acceptRelative: true })) {
+      window.location.href = path;
+      return false;
+    }
+    return path;
+  }
+});

package/dist/app/nuxt.d.ts

@@ -0,0 +1,271 @@
+import type { App, EffectScope, Ref, VNode, onErrorCaptured } from 'vue';
+import type { RouteLocationNormalizedLoaded } from 'vue-router';
+import type { Hookable } from 'hookable';
+import type { SSRContext, createRenderer } from 'vue-bundle-renderer/runtime';
+import type { EventHandlerRequest, H3Event } from 'h3';
+import type { RenderResponse } from 'nitropack/types';
+import type { LogObject } from 'consola';
+import type { VueHeadClient } from '@unhead/vue/types';
+import type { NuxtAppLiterals } from 'nuxt/app';
+import type { NuxtIslandContext } from './types.js';
+import type { RouteMiddleware } from './composables/router.js';
+import type { NuxtError } from './composables/error.js';
+import type { AsyncDataExecuteOptions, AsyncDataRequestStatus } from './composables/asyncData.js';
+import type { NuxtAppManifestMeta } from './composables/manifest.js';
+import type { LoadingIndicator } from './composables/loading-indicator.js';
+import type { RouteAnnouncer } from './composables/route-announcer.js';
+import type { AppConfig, AppConfigInput, RuntimeConfig } from 'nuxt/schema';
+export declare function getNuxtAppCtx(id?: any): import("unctx/index").UseContext<NuxtApp>;
+type HookResult = Promise<void> | void;
+type AppRenderedContext = {
+    ssrContext: NuxtApp['ssrContext'];
+    renderResult: null | Awaited<ReturnType<ReturnType<typeof createRenderer>['renderToString']>>;
+};
+export interface RuntimeNuxtHooks {
+    'app:created': (app: App<Element>) => HookResult;
+    'app:beforeMount': (app: App<Element>) => HookResult;
+    'app:mounted': (app: App<Element>) => HookResult;
+    'app:rendered': (ctx: AppRenderedContext) => HookResult;
+    'app:redirected': () => HookResult;
+    'app:suspense:resolve': (Component?: VNode) => HookResult;
+    'app:error': (err: any) => HookResult;
+    'app:error:cleared': (options: {
+        redirect?: string;
+    }) => HookResult;
+    'app:chunkError': (options: {
+        error: any;
+    }) => HookResult;
+    'app:data:refresh': (keys?: string[]) => HookResult;
+    'app:manifest:update': (meta?: NuxtAppManifestMeta) => HookResult;
+    'dev:ssr-logs': (logs: LogObject[]) => HookResult;
+    'link:prefetch': (link: string) => HookResult;
+    'page:start': (Component?: VNode) => HookResult;
+    'page:finish': (Component?: VNode) => HookResult;
+    'page:transition:finish': (Component?: VNode) => HookResult;
+    'page:view-transition:start': (transition: ViewTransition) => HookResult;
+    'page:loading:start': () => HookResult;
+    'page:loading:end': () => HookResult;
+    'vue:setup': () => void;
+    'vue:error': (...args: Parameters<Parameters<typeof onErrorCaptured>[0]>) => HookResult;
+}
+export interface NuxtSSRContext extends SSRContext {
+    url: string;
+    event: H3Event;
+    runtimeConfig: RuntimeConfig;
+    noSSR: boolean;
+    /** whether we are rendering an SSR error */
+    error?: boolean;
+    nuxt: _NuxtApp;
+    payload: Partial<NuxtPayload>;
+    head: VueHeadClient;
+    /** This is used solely to render runtime config with SPA renderer. */
+    config?: Pick<RuntimeConfig, 'public' | 'app'>;
+    teleports?: Record<string, string>;
+    islandContext?: NuxtIslandContext;
+    /** @internal */
+    _renderResponse?: Partial<RenderResponse>;
+    /** @internal */
+    _payloadReducers: Record<string, (data: any) => any>;
+    /** @internal */
+    _sharedPrerenderCache?: {
+        get<T = unknown>(key: string): Promise<T> | undefined;
+        set<T>(key: string, value: Promise<T>): Promise<void>;
+    };
+    /** @internal */
+    _preloadManifest?: boolean;
+}
+export interface NuxtPayload {
+    path?: string;
+    serverRendered?: boolean;
+    prerenderedAt?: number;
+    data: Record<string, any>;
+    state: Record<string, any>;
+    once: Set<string>;
+    config?: Pick<RuntimeConfig, 'public' | 'app'>;
+    error?: NuxtError | undefined;
+    _errors: Record<string, NuxtError | undefined>;
+    [key: string]: unknown;
+}
+interface _NuxtApp {
+    vueApp: App<Element>;
+    versions: Record<string, string>;
+    hooks: Hookable<RuntimeNuxtHooks>;
+    hook: _NuxtApp['hooks']['hook'];
+    callHook: _NuxtApp['hooks']['callHook'];
+    runWithContext: <T extends () => any>(fn: T) => ReturnType<T> | Promise<Awaited<ReturnType<T>>>;
+    [key: string]: unknown;
+    /** @internal */
+    _cookies?: Record<string, unknown>;
+    /**
+     * The id of the Nuxt application.
+     * @internal */
+    _id: string;
+    /** @internal */
+    _scope: EffectScope;
+    /** @internal */
+    _asyncDataPromises: Record<string, Promise<any> | undefined>;
+    /** @internal */
+    _asyncData: Record<string, {
+        data: Ref<unknown>;
+        pending: Ref<boolean>;
+        error: Ref<Error | undefined>;
+        status: Ref<AsyncDataRequestStatus>;
+        execute: (opts?: AsyncDataExecuteOptions) => Promise<void>;
+        /** @internal */
+        _default: () => unknown;
+        /** @internal */
+        _deps: number;
+        /** @internal */
+        _off: () => void;
+        /** @internal */
+        _init: boolean;
+        /** @internal */
+        _execute: (opts?: AsyncDataExecuteOptions) => Promise<void>;
+        /** @internal */
+        _hash?: Record<string, string | undefined>;
+        /** @internal */
+        _abortController?: AbortController;
+    } | undefined>;
+    /** @internal */
+    _loadingIndicator?: LoadingIndicator;
+    /** @internal */
+    _loadingIndicatorDeps?: number;
+    /** @internal */
+    _middleware: {
+        global: RouteMiddleware[];
+        named: Record<string, RouteMiddleware>;
+    };
+    /** @internal */
+    _processingMiddleware?: string | boolean;
+    /** @internal */
+    _once: {
+        [key: string]: Promise<any>;
+    };
+    /** @internal */
+    _observer?: {
+        observe: (element: Element, callback: () => void) => () => void;
+    };
+    /** @internal */
+    _appConfig: AppConfig;
+    /** @internal */
+    _route: RouteLocationNormalizedLoaded & {
+        sync?: () => void;
+    };
+    /** @internal */
+    _islandPromises?: Record<string, Promise<any>>;
+    /** @internal */
+    _payloadRevivers: Record<string, (data: any) => any>;
+    /** @internal */
+    _routeAnnouncer?: RouteAnnouncer;
+    /** @internal */
+    _routeAnnouncerDeps?: number;
+    $config: RuntimeConfig;
+    isHydrating?: boolean;
+    deferHydration: () => () => void | Promise<void>;
+    ssrContext?: NuxtSSRContext;
+    payload: NuxtPayload;
+    static: {
+        data: Record<string, any>;
+    };
+    provide: (name: string, value: any) => void;
+}
+export interface NuxtApp extends _NuxtApp {
+}
+export declare const NuxtPluginIndicator = "__nuxt_plugin";
+export interface PluginMeta {
+    name?: string;
+    enforce?: 'pre' | 'default' | 'post';
+    /**
+     * Await for other named plugins to finish before running this plugin.
+     */
+    dependsOn?: NuxtAppLiterals['pluginName'][];
+    /**
+     * This allows more granular control over plugin order and should only be used by advanced users.
+     * It overrides the value of `enforce` and is used to sort plugins.
+     */
+    order?: number;
+}
+export interface PluginEnvContext {
+    /**
+     * This enable the plugin for islands components.
+     * Require `experimental.componentsIslands`.
+     * @default true
+     */
+    islands?: boolean;
+}
+export interface ResolvedPluginMeta {
+    name?: string;
+    parallel?: boolean;
+}
+export interface Plugin<Injections extends Record<string, unknown> = Record<string, unknown>> {
+    (nuxt: _NuxtApp): Promise<void> | Promise<{
+        provide?: Injections;
+    }> | void | {
+        provide?: Injections;
+    };
+    [NuxtPluginIndicator]?: true;
+    meta?: ResolvedPluginMeta;
+}
+export interface ObjectPlugin<Injections extends Record<string, unknown> = Record<string, unknown>> extends PluginMeta {
+    hooks?: Partial<RuntimeNuxtHooks>;
+    setup?: Plugin<Injections>;
+    env?: PluginEnvContext;
+    /**
+     * Execute plugin in parallel with other parallel plugins.
+     * @default false
+     */
+    parallel?: boolean;
+    /**
+     * @internal
+     */
+    _name?: string;
+}
+/** @deprecated Use `ObjectPlugin` */
+export type ObjectPluginInput<Injections extends Record<string, unknown> = Record<string, unknown>> = ObjectPlugin<Injections>;
+export interface CreateOptions {
+    vueApp: NuxtApp['vueApp'];
+    ssrContext?: NuxtApp['ssrContext'];
+    /**
+     * The id of the Nuxt application, overrides the default id specified in the Nuxt config (default: `nuxt-app`).
+     */
+    id?: NuxtApp['_id'];
+}
+/** @since 3.0.0 */
+export declare function createNuxtApp(options: CreateOptions): NuxtApp;
+/** @since 3.12.0 */
+export declare function registerPluginHooks(nuxtApp: NuxtApp, plugin: Plugin & ObjectPlugin<any>): void;
+/** @since 3.0.0 */
+export declare function applyPlugin(nuxtApp: NuxtApp, plugin: Plugin & ObjectPlugin<any>): Promise<void>;
+/** @since 3.0.0 */
+export declare function applyPlugins(nuxtApp: NuxtApp, plugins: Array<Plugin & ObjectPlugin<any>>): Promise<void>;
+/** @since 3.0.0 */
+export declare function defineNuxtPlugin<T extends Record<string, unknown>>(plugin: Plugin<T> | ObjectPlugin<T>): Plugin<T> & ObjectPlugin<T>;
+export declare const definePayloadPlugin: typeof defineNuxtPlugin;
+/** @since 3.0.0 */
+export declare function isNuxtPlugin(plugin: unknown): plugin is Function & Record<"__nuxt_plugin", unknown>;
+/**
+ * Ensures that the setup function passed in has access to the Nuxt instance via `useNuxtApp`.
+ * @param nuxt A Nuxt instance
+ * @param setup The function to call
+ * @since 3.0.0
+ */
+export declare function callWithNuxt<T extends (...args: any[]) => any>(nuxt: NuxtApp | _NuxtApp, setup: T, args?: Parameters<T>): ReturnType<T> | Promise<ReturnType<T>>;
+/**
+ * Returns the current Nuxt instance.
+ *
+ * Returns `null` if Nuxt instance is unavailable.
+ * @since 3.10.0
+ */
+export declare function tryUseNuxtApp(): NuxtApp | null;
+/**
+ * Returns the current Nuxt instance.
+ *
+ * Throws an error if Nuxt instance is unavailable.
+ * @since 3.0.0
+ */
+export declare function useNuxtApp(): NuxtApp;
+/** @since 3.0.0 */
+export declare function useRuntimeConfig(_event?: H3Event<EventHandlerRequest>): RuntimeConfig;
+/** @since 3.0.0 */
+export declare function defineAppConfig<C extends AppConfigInput>(config: C): C;
+export {};