/**
 * Internals behind `<DockviewVue>`'s scoped slots. Deliberately not
 * re-exported from the package entry point.
 */
import { type InjectionKey, type Slot, type Slots } from 'vue';
import type { VueComponent } from './utils';
declare const SLOT_REFERENCE: unique symbol;
/**
 * Points a renderer at a named slot of the host component instead of a
 * component. Created via {@link createSlotReference}.
 *
 * @internal
 */
export interface VueSlotReference {
    readonly [SLOT_REFERENCE]: true;
    readonly name: string;
}
export declare function createSlotReference(name: string): VueSlotReference;
export declare function isSlotReference(value: unknown): value is VueSlotReference;
/**
 * The host's slot functions, keyed by slot name, held in a
 * `shallowReactive` record so that each {@link VueSlotOutlet} only tracks
 * the one slot it renders.
 */
export type VueSlotFunctions = Record<string, Slot | undefined>;
/**
 * Provided by a host (`dockview.vue`) so that {@link VueSlotOutlet} can look
 * up the host's slots. `functions` is what outlets track; `slots` is the
 * host's own slots object, read for Vue's compiled-slot flag.
 */
export interface VueSlotContext {
    readonly functions: VueSlotFunctions;
    readonly slots: Slots;
}
export declare const VUE_SLOT_CONTEXT: InjectionKey<VueSlotContext>;
/**
 * Create the reactive slot record for a host, plus a `sync` to call from the
 * host's `onBeforeUpdate`. `sync` only writes entries whose function actually
 * changed, so outlets re-render only when their own slot is replaced (dynamic
 * `v-if` slots, render-function slots), not on every host re-render.
 *
 * Entries for which `retain(name)` is true are kept when their slot is
 * removed, so outlets already showing them keep their last content.
 */
export declare function createSlotFunctions(slots: Slots, retain?: (name: string) => boolean): {
    functions: VueSlotFunctions;
    sync: () => void;
};
/**
 * Renders the host slot `slotName`, passing the renderer's `params` as the
 * slot props. Mounted through the same {@link VueRendererRegistry} teleport
 * path as components, so it lives inside the host's component tree and the
 * slot content keeps the parent's reactivity, event handlers and injections.
 *
 * Rendering goes through `renderSlot`, as a compiled `<slot>` does. It reads
 * the slot and the compiled-slot flag (`_`) from the object it is given, and
 * renders stable compiled slots as stable fragments that patch without a
 * full diff, so the host's flag is passed alongside the tracked function.
 */
export declare const VueSlotOutlet: VueComponent;
export {};