import { WebStreamableHeadContext } from 'unhead/stream/server';
export { CreateStreamableServerHeadOptions, PreparedTemplate, StreamingTemplateParts, createBootstrapScript, prepareStreamingTemplate, prepareTemplate, renderSSRHeadShell, renderSSRHeadSuspenseChunk, renderShell, wrapStream } from 'unhead/stream/server';
import { ResolvableHead, SSRHeadPayload, CreateStreamableServerHeadOptions } from 'unhead/types';
import { V as VueHeadClient } from '../shared/vue.B8YcFbNO.js';
import 'vue';

/**
 * Vue-specific context returned by createStreamableHead.
 * Extends WebStreamableHeadContext with Vue-specific head type.
 */
interface VueStreamableHeadContext extends Omit<WebStreamableHeadContext<ResolvableHead>, 'head'> {
    /**
     * The Vue head instance to use with app.use(head)
     */
    head: VueHeadClient<any, SSRHeadPayload>;
}
/**
 * Creates a head instance configured for Vue streaming SSR.
 *
 * `wrapStream` is Vue-specific: Vue's `renderToWebStream` flushes chunks in
 * document order per resolved Suspense boundary, so any head entries added
 * during a chunk's render can be emitted as a self-deleting inline
 * `<script>` right after the chunk. The script executes at HTML parse
 * (updating the client head state progressively) and calls
 * `document.currentScript.remove()` so the DOM is clean before Vue
 * hydrates. This pattern is not safe for frameworks with out-of-order
 * Suspense reveals (React, Solid) or framework-specific chunk formats
 * (Svelte) — those continue to use an in-tree `<HeadStream />` component
 * whose output is serialized inside the framework's own stream.
 *
 * @example
 * ```ts
 * export async function render(url: string, template: string) {
 *   const { app, router } = createApp()
 *   const { head, wrapStream } = createStreamableHead()
 *
 *   app.use(head)
 *   app.mixin(VueHeadMixin)
 *   router.push(url)
 *
 *   const vueStream = renderToWebStream(app)
 *   await router.isReady()
 *
 *   return wrapStream(vueStream, template)
 * }
 * ```
 */
declare function createStreamableHead(options?: Omit<CreateStreamableServerHeadOptions, 'propResolvers'>): VueStreamableHeadContext;

export { VueHeadClient, createStreamableHead };
export type { VueStreamableHeadContext };