import { ExtractPropInput, StyleValue } from "@fastkit/vue-utils";
import { App, CSSProperties, ComponentPropsOptions, ComponentPublicInstance, EmitsOptions, ExtractPropTypes, HTMLAttributes, InjectionKey, ObjectEmitsOptions, PropType, Ref, SetupContext, SlotsType, StyleValue as StyleValue$1, Transition, VNode, VNodeChild } from "vue";
import { UseKeyboardRef } from "@fastkit/vue-keyboard";
import { RouteLocationNormalized } from "vue-router";
import { JavaScriptTransition } from "@fastkit/vue-transitions";
import { ResizeDirectivePayload, UseWindowRef } from "@fastkit/vue-resize";
//#region src/schemes/dynamic.d.ts
interface StackableComponent {
  new (): ComponentPublicInstance<any, any, any, any, any, any, any, any, any, any, any, any>;
}
type ComponentProps<T extends StackableComponent> = InstanceType<T>['$props'];
type ComponentSlots<T extends StackableComponent> = Omit<InstanceType<T>['$slots'], 'default'> & {
  default?: DefaultSlot;
};
type SlotLike = (...args: any[]) => any;
type SlotsLike = Record<keyof any, SlotLike>;
type NormalizeSlot<Slot extends SlotLike | undefined> = (...args: Parameters<Exclude<Slot, undefined>>) => VNodeChild;
type RawSlots<Slots extends SlotsLike> = { [K in keyof Slots]: NormalizeSlot<Slots[K]> | VNodeChild; };
type DefaultSlot = (stackControl: VStackControl) => VNodeChild;
type DefaultContent = VNodeChild | DefaultSlot;
type ExtractDynamicStackProps<T extends StackableComponent, _Slots = ComponentSlots<T>> = (ComponentProps<T> & {
  content?: DefaultContent;
}) | null;
type ExtractDynamicStackSlots<T extends StackableComponent, _Slots = ComponentSlots<T>> = RawSlots<_Slots extends SlotsLike ? _Slots : SlotsLike>;
type DynamicStackPayload<Payload = any> = Promise<Payload>;
type StackableLauncher<T extends StackableComponent, Payload = any, _Props = ExtractDynamicStackProps<T>> = ((content: DefaultContent) => DynamicStackPayload<Payload>) & ((props: _Props, content: DefaultContent) => DynamicStackPayload<Payload>) & ((props: _Props, slots: ExtractDynamicStackSlots<T>) => DynamicStackPayload<Payload>);
interface DynamicStackSettings<T extends StackableComponent> {
  Ctor: T;
  props: any;
  slots: any;
}
declare function resolveDynamicStackSettings<T extends StackableComponent>(Ctor: T, contentOrProps: DefaultContent | ExtractDynamicStackProps<T>, contentOrSlots?: DefaultContent | ExtractDynamicStackSlots<T>, propsResolver?: (props: ExtractDynamicStackProps<T>) => ExtractDynamicStackProps<T>): DynamicStackSettings<T>;
type DynamicStackResolver = (value: any) => void;
interface DynamicStackInternalSetting {
  id: number;
  setting: DynamicStackSettings<any>;
  remove: () => void;
  resolve: DynamicStackResolver;
  reject: () => any;
}
//#endregion
//#region src/injections.d.ts
declare const VueStackInjectionKey: InjectionKey<VueStackService>;
//#endregion
//#region src/service.d.ts
interface VueStackServiceOptions {
  zIndex?: number;
  snackbarDefaultPosition?: 'top' | 'bottom';
}
/**
 * Stack service
 */
declare class VueStackService {
  private readonly _controls;
  private readonly __controls;
  /** z-index as a reference for all stacks */
  readonly zIndex: number;
  /** Snackbar default position */
  readonly snackbarDefaultPosition: 'top' | 'bottom';
  private _increment;
  private readonly _dynamicSettings;
  /**
   * List of mounted stack control instances
   *
   * @see {@link VStackControl}
   */
  get controls(): VStackControl[];
  /**
   * List of dynamic stack display settings
   *
   * @see {@link DynamicStackInternalSetting}
   */
  get dynamicSettings(): DynamicStackInternalSetting[];
  constructor(opts?: VueStackServiceOptions);
  /** Generate a new stack ID */
  genId(): number;
  /**
   * Add a stack control
   *
   * @param control - Stack control
   * @returns If added, its index within the list. -1 if it already exists
   */
  add(control: VStackControl): number;
  /**
   * Remove stack
   *
   * @param control - Stack control
   * @returns If removed, its index. -1 if it doesn't exist
   */
  remove(control: VStackControl): VStackControl[];
  /**
   * Check if any stack is animated
   *
   * @returns - `true` if animation is in progress
   */
  someTransitioning(): boolean;
  /**
   * Get all displayed stacks
   *
   * @returns All displayed stacks
   */
  getActiveStacks(): VStackControl[];
  /**
   * Retrieve the stack currently displayed in the foreground.
   *
   * @param filter - Filter to exclude stacks
   * @returns Stack currently displayed in the foreground
   */
  getFront(filter?: (control: VStackControl) => boolean): VStackControl | undefined;
  /**
   * Update the `--v-stack-current-z-index` CSS custom property on
   * `document.documentElement` to reflect the z-index of the frontmost
   * active stack.
   */
  updateCurrentZIndexVar(): void;
  /**
   * Check if the specified stack is currently displayed in the foreground
   *
   * @param control - The stack to check
   * @returns Stack currently displayed in the foreground
   * @returns `true` if it is currently displayed in the foreground
   */
  isFront(control: VStackControl, filter?: (control: VStackControl) => boolean): boolean;
  private removeDynamicSetting;
  dynamic<T extends StackableComponent, Payload = any>(Ctor: T, content: DefaultContent): DynamicStackPayload<Payload>;
  dynamic<T extends StackableComponent, Payload = any>(Ctor: T, props: ExtractDynamicStackProps<T>, content: DefaultContent, propsResolver?: (props: ExtractDynamicStackProps<T>) => ExtractDynamicStackProps<T>): DynamicStackPayload<Payload>;
  dynamic<T extends StackableComponent, Payload = any>(Ctor: T, props: ExtractDynamicStackProps<T>, slots: ExtractDynamicStackSlots<T>, propsResolver?: (props: ExtractDynamicStackProps<T>) => ExtractDynamicStackProps<T>): DynamicStackPayload<Payload>;
  createLauncher<T extends StackableComponent, Payload = any>(Ctor: T, propsResolver?: (props: ExtractDynamicStackProps<T>) => ExtractDynamicStackProps<T>): StackableLauncher<T, Payload>;
}
//#endregion
//#region src/schemes/control.d.ts
type DelayTimerProps = 'openDelay' | 'closeDelay';
/**
 * Reason for becoming hidden
 *
 * - `indeterminate` Not determined reason
 * - `resolved` - User performed an 'OK'-like action
 * - `canceled` - User performed a 'Cancel'-like action
 */
type StackableCloseReason = 'indeterminate' | 'resolved' | 'canceled';
/**
 * Configuration for closing the stack with the Tab key
 *
 * - `always` Always close.
 * - `not-focused` When the Tab key is pressed and the active element of the document is outside the stack and its activator.
 */
type StackableTabCloseSetting = 'always' | 'not-focused';
/**
 * Configuration for closing the stack with the Tab key
 *
 * If `true` is specified, it is treated as `always`.
 *
 * @see {@link StackableTabCloseSetting}
 */
type StackableTabCloseSpec = boolean | StackableTabCloseSetting;
type VStackNavigationGuard = (to: RouteLocationNormalized, from: RouteLocationNormalized) => boolean | Promise<boolean>;
/**
 * Handler function for resolving the stack.
 *
 * Handler function for resolving the stack, which may include validation processes or asynchronous submission tasks.
 *
 * @returns A boolean or undefined value or a Promise that resolves to a boolean or undefined value.
 *   - If `false`, the stack resolution is canceled.
 */
type StackableResolveHandler = (ctx: VStackControl) => boolean | void | undefined | Promise<boolean | void | undefined>;
/**
 * Attributes to apply to the stack element's activator
 */
interface VStackActivatorAttributes {
  /** VNode ref */
  ref: Ref;
  /** Click handler */
  onClick?: (ev: PointerEvent) => void;
  /** Context menu handler */
  onContextmenu?: (ev: PointerEvent) => void;
  /** Mouse enter handler */
  onMouseenter?: (ev: MouseEvent) => void;
  /** Mouse leave handler */
  onMouseleave?: (ev: MouseEvent) => void;
  /** Focus handler */
  onFocus?: (ev: FocusEvent) => void;
}
/** State of the stack control */
interface VStackControlState {
  /** Display state */
  isActive: boolean;
  /** Activator element */
  readonly activator: HTMLElement | undefined;
  /**
   * Reason for becoming hidden
   *
   * @see {@link StackableCloseReason}
   */
  closeReason: StackableCloseReason;
  /** Initial value */
  initialValue: any;
  /** Input value */
  inputValue: any;
  /**
   * If the asynchronous resolution handler is in progress, its type.
   */
  guardInProgressType: null | 'cancel' | 'resolve';
  /** During display animation */
  showing: boolean;
  /** During hide animation */
  closing: boolean;
  /** During guard animation */
  guardAnimating: boolean;
  /** Guard animation timer ID */
  guardAnimateTimeId: number | null;
  /** Activation order */
  activateOrder: number;
  /** Auto-hide timer ID */
  timeoutId: number | null;
  /** List of delay request timer IDs */
  delayTimers: number[];
  /** Rendering required */
  needRender: boolean;
  /** Component mounted */
  booted: boolean;
  /** Component destroyed */
  isDestroyed: boolean;
  /** Whether the activator element is being hovered. */
  isActivatorHovered: boolean;
  /** Whether the stack content is being hovered. */
  isContentHovered: boolean;
}
/**
 * Close option
 */
interface VStackCloseOptions {
  /**
   * Force close
   *
   * When the `persistent` setting is enabled, the stack will not close unless this option is also activated.
   */
  force?: boolean;
  /**
   * Reason for becoming hidden
   *
   * @see {@link StackableCloseReason}
   */
  reason?: StackableCloseReason;
}
/**
 * Check if the specified value is an instance of the stack control
 *
 * @param source - The value to check
 * @returns - If it is a stack control, returns `true`
 */
declare function isStackControl(source: unknown): source is VStackControl;
/**
 * Stack control
 */
interface VStackControl {
  readonly __isStackControl: true;
  readonly props: VStackProps;
  /** Display state */
  readonly isActive: boolean;
  /**
   * The value entered into the stack
   *
   * This is always `undefined` if the `closeReason` is not `resolved`.
   */
  value: any;
  /**
   * Stack service
   *
   * @see {@link VueStackService}
   */
  readonly $service: VueStackService;
  /** List of class attributes */
  readonly classes: any[];
  /** List of style attributes */
  readonly styles: StyleValue[];
  /** During animation */
  readonly transitioning: boolean;
  /** Activation order */
  readonly activateOrder: number;
  /** Timeout setting (milliseconds) */
  readonly timeout: number;
  /**
   * Persistently display
   *
   * If this setting is enabled, it will attempt to block hide requests or page transitions
   */
  readonly persistent: boolean;
  /** The user has performed a confirmation action, such as 'OK,' for the stack display */
  readonly isResolved: boolean;
  /** The user has performed a negative action, such as 'Cancel,' for the stack display */
  readonly isCanceled: boolean;
  /** z index */
  readonly zIndex: number;
  /** Restore focus after hiding */
  readonly focusRestorable: boolean;
  /** Close when the ESC key is pressed */
  readonly closeOnEsc: boolean;
  /**
   * Close when the ESC key is pressed
   *
   * @see {@link StackableTabCloseSetting}
   */
  readonly closeOnTab: false | StackableTabCloseSetting;
  /** Close on navigation occurrence */
  readonly closeOnNavigation: boolean;
  /** Close when clicking outside the stack area */
  readonly closeOnOutsideClick: boolean;
  /** Delay time for display (in milliseconds) */
  readonly openDelay: number;
  /** Delay time for hiding (in milliseconds) */
  readonly closeDelay: number;
  /** Component destroyed */
  readonly isDestroyed: boolean;
  /** Stack content element */
  readonly contentRef: Ref<HTMLElement | null>;
  /** Activator element */
  readonly activator: HTMLElement | undefined;
  /** Backdrop element */
  readonly backdropRef: Ref<HTMLElement | null>;
  /** Stack type */
  readonly stackType?: string | symbol;
  /**
   * Inactivate the stack and disable all display processing
   */
  readonly disabled: boolean;
  /**
   * If the asynchronous resolution handler is in progress, its type.
   */
  readonly guardInProgressType: null | 'cancel' | 'resolve';
  /**
   * A boolean flag indicating whether the guard process is currently in progress.
   * When true, it signifies that the guard is actively executing.
   */
  readonly guardInProgress: boolean;
  /**
   * The VStackControl instance in the parent hierarchy of the component tree.
   */
  readonly parent: VStackControl | undefined;
  /**
   * List of VStackControl instances located below this component in the component tree.
   */
  readonly children: VStackControl[];
  /**
   * List of all nested VStackControl instances, including children.
   */
  readonly allChildren: VStackControl[];
  /**
   * Whether the mouse pointer is hovering over its activator or stack content.
   */
  readonly isHovered: boolean;
  /**
   * Whether the specified element is part of its activator or stack element.
   * @param el - Element
   */
  contains(el: Element): boolean;
  /** @private */
  readonly _: {
    readonly attrs: Record<string, unknown>;
    /**
     * State of the stack control
     *
     * @see {@link VStackControlState}
     */
    readonly state: VStackControlState;
    /**
     * Attributes to apply to the stack element's activator
     *
     * @see {@link VStackActivatorAttributes}
     */
    readonly activatorAttrs: VStackActivatorAttributes;
    /** Transition settings */
    readonly Transition: {
      readonly Ctor: typeof Transition;
      readonly props: any;
    };
    /**
     * Keyboard composable
     *
     * @see {@link UseKeyboardRef}
     */
    readonly keyboard: UseKeyboardRef;
    /** Listener object related to transitions */
    readonly transitionListeners: {
      onBeforeEnter: (el: HTMLElement) => void;
      onAfterEnter: (el: HTMLElement) => void;
      onEnterCancelled: (el: HTMLElement) => void;
      onBeforeLeave: (el: HTMLElement) => void;
      onAfterLeave: (el: HTMLElement) => void;
      onLeaveCancelled: (el: HTMLElement) => void;
    };
    /** Handler to trap focus */
    focusTrapper?: (ev: FocusEvent) => void;
    /**
     * Set the active state
     * @param isActive - active state
     * @param withEmit - Notify of changes
     */
    setIsActive(isActive: boolean, withEmit?: boolean): void;
    /** Clear the auto-hide timer */
    clearTimeoutId(): void;
    /** Perform delayed processing */
    runDelay(prop: number | DelayTimerProps, cb: () => any): void;
    /** Clear the delayed processing queue */
    clearDelay(): void;
    /** Trap focus */
    trapFocus(ev?: FocusEvent): boolean | void;
    /** Prepare handler for focus trapping */
    setupFocusTrapper(): void;
    /** Remove handler for focus trapping */
    removeFocusTrapper(): void;
    /** Update focus trap settings */
    checkFocusTrap(): void;
    /** Set rendering request */
    setNeedRender(needRender: boolean): void;
    /** Process for determining hide on outside-click */
    outsideClickCloseConditional(ev: PointerEvent, pre?: boolean): boolean;
    /** Clear guard effect */
    clearGuardEffect(): void;
    joinChild(child: VStackControl): () => void;
  };
  /**
   * Set the activator
   *
   * @param query - Specifying the activator element or its query
   *
   * @see {@link VStackActivatorQuery}
   */
  setActivator(query: VStackActivatorQuery): this;
  /** Show the stack */
  show(): Promise<void>;
  /** Toggle the display state */
  toggle(): Promise<void>;
  /**
   * Close the stack
   *
   * @param opts - Close option
   *
   * @see {@link VStackCloseOptions}
   */
  close(opts?: VStackCloseOptions): Promise<void>;
  /**
   * Confirm the stack input
   *
   * The stack will close with the `force` option.
   *
   * @param payload - The confirmed value (if any)
   */
  resolve(payload?: any): Promise<void | undefined | false>;
  /**
   * Cancel the stack input
   *
   * @param force - Forcefully close
   */
  cancel(force?: boolean): Promise<void>;
  /**
   * Render the stack
   *
   * @param fn - Renderer
   * @param opts - Rendering options
   */
  render(fn: (children: VNodeChild | undefined, opts: {
    withClickOutside: (node: VNode) => VNode;
  }) => VNode, opts?: {
    transition?: (child?: VNode) => VNode;
  }): VNode;
  /** Bring the stack to the forefront */
  toFront(): void;
  /** Reset the stack input */
  resetValue(): void;
  /**
   * Check if the stack is in the foreground
   * @param filter - Exclude filter for specific stacks
   */
  isFront(filter?: (control: VStackControl) => boolean): boolean;
  /**
   * If the specified element is a comprehensive descendant of this stack or is the same, it returns the included element.
   *
   * @param other - The element to be checked.
   * @param includingActivator - Check if it might be included in the activator element.
   */
  getContainsOrSameElement(other: Node | Event | EventTarget | null | undefined, includingActivator?: boolean): HTMLElement | undefined;
  /**
   * If the specified element is a comprehensive descendant of this stack or is the same, it returns `true`.
   *
   * @param other - The element to be checked.
   * @param includingActivator - Check if it might be included in the activator element.
   */
  containsOrSameElement(other: Node | Event | EventTarget | null | undefined, includingActivator?: boolean): boolean;
  /** Execute guard effect */
  guardEffect(): void;
}
declare const stackableEmits: {
  /**
   * Update display state
   * @param modelValue - display state
   */
  'update:modelValue': (modelValue: boolean) => boolean;
  /**
   * When updating the display state
   * @param modelValue - display state
   */
  change: (modelValue: boolean) => boolean;
  /**
   * When updating the stack input
   * @param value - Stack input
   */
  payload: (value: any) => boolean;
  /**
   * When the stack is displayed
   * @param control - Stack control
   */
  show: (control: VStackControl) => boolean;
  /**
   * When the stack is closed
   * @param control - Stack control
   */
  close: (control: VStackControl) => boolean;
  /**
   * Before the enter transition starts
   * @param el - Element
   * @param control - Stack control
   */
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  /**
   * After the enter transition starts
   * @param el - Element
   * @param control - Stack control
   */
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  /**
   * When the enter transition start is canceled
   * @param el - Element
   * @param control - Stack control
   */
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  /**
   * Before the leave transition starts
   * @param el - Element
   * @param control - Stack control
   */
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  /**
   * After the leave transition starts
   * @param el - Element
   * @param control - Stack control
   */
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  /**
   * When the leave transition start is canceled
   * @param el - Element
   * @param control - Stack control
   */
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
};
type StackableEmits = typeof stackableEmits;
/**
 * Payload for the activator slot
 */
interface VStackActivatorPayload {
  /**
   * Attributes to apply to the stack element's activator
   *
   * @see {@link VStackActivatorAttributes}
   */
  get attrs(): VStackActivatorAttributes;
  /**
   * Stack control
   *
   * @see {@link VStackControl}
   */
  get control(): VStackControl;
}
type VStackSlots = {
  default?: (control: VStackControl) => VNodeChild;
  /**
   * Activator rendering slot
   *
   * @param payload - Payload for the activator slot
   *
   * @see {@link VStackActivatorPayload}
   */
  activator?: (payload: VStackActivatorPayload) => VNodeChild;
};
declare const V_STACK_SLOTS: import("@fastkit/vue-utils").DefinedSlots<VStackSlots>;
type MergeSlots<A extends SlotsType, B extends SlotsType> = SlotsType<NonNullable<A[keyof A]> & NonNullable<B[keyof B]>>;
type MergeStackBaseSlots<Slots extends SlotsType> = MergeSlots<Slots, typeof V_STACK_SLOTS>;
interface CreateStackablePropsOptions {
  /** @default "v-stack-fade" */
  defaultTransition?: string;
  /** @default false */
  defaultFocusTrap?: boolean;
  /** @default false */
  defaultFocusRestorable?: boolean;
  /** @default false */
  defaultScrollLock?: boolean;
  /** @default false */
  defaultBackdrop?: string | boolean;
  /** @default true */
  defaultCloseOnOutsideClick?: boolean;
  /** @default true */
  defaultCloseOnNavigation?: boolean;
  /** @default true */
  defaultCloseOnEsc?: boolean;
  /** @default false */
  defaultCloseOnTab?: StackableTabCloseSpec;
  /** @default 0 */
  defaultTimeout?: number;
  /** @default false */
  defaultPersistent?: boolean;
}
interface VStackObjectTransitionProp<T extends string | JavaScriptTransition> {
  transition: T;
  props?: T extends JavaScriptTransition ? T['props'] : typeof Transition.props;
}
type RawVStackObjectTransitionProp<T extends string | JavaScriptTransition> = string | VStackObjectTransitionProp<T>;
/**
 * Specifying the activator element or its query
 */
type VStackActivatorQuery = string | Event | Element | ComponentPublicInstance | (() => Element | ComponentPublicInstance | void | undefined | null);
type VStackActivatorAttrsObject = HTMLAttributes & Record<string, any>;
type VStackActivatorAttrsFn = (ctx: {
  control: VStackControl;
}) => VStackActivatorAttrsObject | undefined;
type VStackActivatorAttrsSpec = VStackActivatorAttrsFn | VStackActivatorAttrsObject;
declare function createStackableProps<T extends string | JavaScriptTransition>(opts?: CreateStackablePropsOptions): {
  'v-slots': PropType<{
    default?: ((control: VStackControl) => VNodeChild) | undefined;
    activator?: ((payload: VStackActivatorPayload) => VNodeChild) | undefined;
  }>;
  /** Display state */
  modelValue: BooleanConstructor;
  /** Do not display until the component is mounted */
  lazyBoot: BooleanConstructor;
  /** Stack input */
  value: null;
  /** Class attributes */
  class: null;
  /** Style attributes */
  style: PropType<StyleValue$1>;
  /**
   * Transition settings
   *
   * @see {@link RawVStackObjectTransitionProp}
   */
  transition: {
    type: PropType<RawVStackObjectTransitionProp<T>>;
    default: string;
  };
  /**
   * Always draw the stack even when it is invisible
   *
   * If your application relies on drawing small elements in the stack, try this setting
   */
  alwaysRender: BooleanConstructor;
  /**
   * Display a backdrop behind the stack
   *
   * If string is specified, it will be displayed in that color
   */
  backdrop: {
    type: PropType<boolean | string>;
    default: string | boolean;
  };
  /**
   * Trap user focus
   */
  focusTrap: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * Restore focus when stack is hidden
   */
  focusRestorable: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * Lock document scrolling
   */
  scrollLock: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * Show stack on activator click
   */
  openOnClick: {
    type: BooleanConstructor;
    default: undefined;
  };
  /**
   * Show stack when hovering over activator
   */
  openOnHover: BooleanConstructor;
  /**
   * Display stack when opening context menu on activator
   */
  openOnContextmenu: BooleanConstructor;
  /**
   * Show stack when focus is on activator
   */
  openOnFocus: {
    type: BooleanConstructor;
    default: undefined;
  };
  /**
   * Time to delay display (in milliseconds)
   */
  openDelay: {
    type: PropType<string | number>;
    default: string | number;
  };
  /**
   * Time to delay hiding (in milliseconds)
   */
  closeDelay: {
    type: PropType<string | number>;
    default: string | number;
  };
  /**
   * Close stack when clicking outside the stack
   */
  closeOnOutsideClick: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * Close stack when ECS key is pressed
   */
  closeOnEsc: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * Close when the ESC key is pressed
   *
   * @see {@link StackableTabCloseSpec}
   */
  closeOnTab: {
    type: PropType<StackableTabCloseSpec>;
    default: StackableTabCloseSpec;
  };
  /**
   * Close stack when navigation occurs
   */
  closeOnNavigation: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * Persistently display
   *
   * If this setting is enabled, it will attempt to block hide requests or page transitions
   */
  persistent: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * Inactivate the stack and disable all display processing
   */
  disabled: BooleanConstructor;
  /** z index */
  zIndex: {
    type: PropType<string | number>;
    default: string | number;
  };
  /** Timeout setting (milliseconds) */
  timeout: {
    type: PropType<string | number>;
    default: string | number;
  };
  /**
   * Guard navigation while viewing stacks
   *
   * @see {@link VStackNavigationGuard}
   */
  navigationGuard: {
    type: PropType<boolean | VStackNavigationGuard>;
    default: boolean;
  };
  /**
   * Show hidden guard effects
   */
  guardEffect: {
    type: (BooleanConstructor | StringConstructor)[];
    default: boolean;
  };
  /**
   * Elements to include in the click-outside-directive check
   *
   * By specifying this, it is possible to skip the hiding process when clicking outside the stack elements.
   */
  includeElements: PropType<() => Element[]>;
  /**
   * Specifying the activator element or its query
   *
   * @see {@link VStackActivatorQuery}
   */
  activator: PropType<VStackActivatorQuery>;
  /**
   * Handler function for when the stack is resolved with a positive value.
   *
   * Which may include validation processes or asynchronous submission tasks.
   *
   * @returns A boolean or undefined value or a Promise that resolves to a boolean or undefined value.
   *   - If `false`, the stack resolution is canceled.
   *
   * @see {@link StackableResolveHandler}
   */
  resolveHandler: PropType<StackableResolveHandler>;
  /**
   * Handler function for when the stack is resolved with a negative value.
   *
   * Which may include validation processes or asynchronous submission tasks.
   *
   * @returns A boolean or undefined value or a Promise that resolves to a boolean or undefined value.
   *   - If `false`, the stack resolution is canceled.
   *
   * @see {@link StackableResolveHandler}
   */
  cancelHandler: PropType<StackableResolveHandler>;
  /**
   * Additional attributes to apply to the element attributes of the activator slot parameters
   *
   * If set, the attributes will be added to the `attrs` property
   * object of the activator slot.
   *
   * @see {@link VStackActivatorAttrsSpec}
   */
  activatorAttrs: PropType<VStackActivatorAttrsSpec>;
};
type StackablePropsOptions = ReturnType<typeof createStackableProps>;
type VStackProps = ExtractPropTypes<StackablePropsOptions>;
type VStackSetupContext = SetupContext<typeof stackableEmits>;
declare function createStackableDefine(opts?: CreateStackablePropsOptions): {
  props: {
    'v-slots': PropType<{
      default?: ((control: VStackControl) => VNodeChild) | undefined;
      activator?: ((payload: VStackActivatorPayload) => VNodeChild) | undefined;
    }>;
    /** Display state */
    modelValue: BooleanConstructor;
    /** Do not display until the component is mounted */
    lazyBoot: BooleanConstructor;
    /** Stack input */
    value: null;
    /** Class attributes */
    class: null;
    /** Style attributes */
    style: PropType<StyleValue$1>;
    /**
     * Transition settings
     *
     * @see {@link RawVStackObjectTransitionProp}
     */
    transition: {
      type: PropType<RawVStackObjectTransitionProp<string | JavaScriptTransition>>;
      default: string;
    };
    /**
     * Always draw the stack even when it is invisible
     *
     * If your application relies on drawing small elements in the stack, try this setting
     */
    alwaysRender: BooleanConstructor;
    /**
     * Display a backdrop behind the stack
     *
     * If string is specified, it will be displayed in that color
     */
    backdrop: {
      type: PropType<boolean | string>;
      default: string | boolean;
    };
    /**
     * Trap user focus
     */
    focusTrap: {
      type: BooleanConstructor;
      default: boolean;
    };
    /**
     * Restore focus when stack is hidden
     */
    focusRestorable: {
      type: BooleanConstructor;
      default: boolean;
    };
    /**
     * Lock document scrolling
     */
    scrollLock: {
      type: BooleanConstructor;
      default: boolean;
    };
    /**
     * Show stack on activator click
     */
    openOnClick: {
      type: BooleanConstructor;
      default: undefined;
    };
    /**
     * Show stack when hovering over activator
     */
    openOnHover: BooleanConstructor;
    /**
     * Display stack when opening context menu on activator
     */
    openOnContextmenu: BooleanConstructor;
    /**
     * Show stack when focus is on activator
     */
    openOnFocus: {
      type: BooleanConstructor;
      default: undefined;
    };
    /**
     * Time to delay display (in milliseconds)
     */
    openDelay: {
      type: PropType<string | number>;
      default: string | number;
    };
    /**
     * Time to delay hiding (in milliseconds)
     */
    closeDelay: {
      type: PropType<string | number>;
      default: string | number;
    };
    /**
     * Close stack when clicking outside the stack
     */
    closeOnOutsideClick: {
      type: BooleanConstructor;
      default: boolean;
    };
    /**
     * Close stack when ECS key is pressed
     */
    closeOnEsc: {
      type: BooleanConstructor;
      default: boolean;
    };
    /**
     * Close when the ESC key is pressed
     *
     * @see {@link StackableTabCloseSpec}
     */
    closeOnTab: {
      type: PropType<StackableTabCloseSpec>;
      default: StackableTabCloseSpec;
    };
    /**
     * Close stack when navigation occurs
     */
    closeOnNavigation: {
      type: BooleanConstructor;
      default: boolean;
    };
    /**
     * Persistently display
     *
     * If this setting is enabled, it will attempt to block hide requests or page transitions
     */
    persistent: {
      type: BooleanConstructor;
      default: boolean;
    };
    /**
     * Inactivate the stack and disable all display processing
     */
    disabled: BooleanConstructor;
    /** z index */
    zIndex: {
      type: PropType<string | number>;
      default: string | number;
    };
    /** Timeout setting (milliseconds) */
    timeout: {
      type: PropType<string | number>;
      default: string | number;
    };
    /**
     * Guard navigation while viewing stacks
     *
     * @see {@link VStackNavigationGuard}
     */
    navigationGuard: {
      type: PropType<boolean | VStackNavigationGuard>;
      default: boolean;
    };
    /**
     * Show hidden guard effects
     */
    guardEffect: {
      type: (BooleanConstructor | StringConstructor)[];
      default: boolean;
    };
    /**
     * Elements to include in the click-outside-directive check
     *
     * By specifying this, it is possible to skip the hiding process when clicking outside the stack elements.
     */
    includeElements: PropType<() => Element[]>;
    /**
     * Specifying the activator element or its query
     *
     * @see {@link VStackActivatorQuery}
     */
    activator: PropType<VStackActivatorQuery>;
    /**
     * Handler function for when the stack is resolved with a positive value.
     *
     * Which may include validation processes or asynchronous submission tasks.
     *
     * @returns A boolean or undefined value or a Promise that resolves to a boolean or undefined value.
     *   - If `false`, the stack resolution is canceled.
     *
     * @see {@link StackableResolveHandler}
     */
    resolveHandler: PropType<StackableResolveHandler>;
    /**
     * Handler function for when the stack is resolved with a negative value.
     *
     * Which may include validation processes or asynchronous submission tasks.
     *
     * @returns A boolean or undefined value or a Promise that resolves to a boolean or undefined value.
     *   - If `false`, the stack resolution is canceled.
     *
     * @see {@link StackableResolveHandler}
     */
    cancelHandler: PropType<StackableResolveHandler>;
    /**
     * Additional attributes to apply to the element attributes of the activator slot parameters
     *
     * If set, the attributes will be added to the `attrs` property
     * object of the activator slot.
     *
     * @see {@link VStackActivatorAttrsSpec}
     */
    activatorAttrs: PropType<VStackActivatorAttrsSpec>;
  };
  emits: {
    /**
     * Update display state
     * @param modelValue - display state
     */
    'update:modelValue': (modelValue: boolean) => boolean;
    /**
     * When updating the display state
     * @param modelValue - display state
     */
    change: (modelValue: boolean) => boolean;
    /**
     * When updating the stack input
     * @param value - Stack input
     */
    payload: (value: any) => boolean;
    /**
     * When the stack is displayed
     * @param control - Stack control
     */
    show: (control: VStackControl) => boolean;
    /**
     * When the stack is closed
     * @param control - Stack control
     */
    close: (control: VStackControl) => boolean;
    /**
     * Before the enter transition starts
     * @param el - Element
     * @param control - Stack control
     */
    beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
    /**
     * After the enter transition starts
     * @param el - Element
     * @param control - Stack control
     */
    afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
    /**
     * When the enter transition start is canceled
     * @param el - Element
     * @param control - Stack control
     */
    enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
    /**
     * Before the leave transition starts
     * @param el - Element
     * @param control - Stack control
     */
    beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
    /**
     * After the leave transition starts
     * @param el - Element
     * @param control - Stack control
     */
    afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
    /**
     * When the leave transition start is canceled
     * @param el - Element
     * @param control - Stack control
     */
    leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  };
};
//#endregion
//#region src/schemes/action.d.ts
interface VStackActionContext {
  control: VStackControl;
  key: string | number;
  onClick: (control: VStackControl, ev: PointerEvent) => any;
}
type VStackActionFn = (ctx: VStackActionContext) => VNodeChild;
interface VStackAction {
  key: string | number;
  content: VStackActionFn;
  onClick?: (control: VStackControl, ev: PointerEvent) => any;
}
declare function createStackActionProps(): {
  actions: {
    type: PropType<VStackAction[]>;
    default: () => never[];
  };
};
type VStackActionProps = ExtractPropTypes<ReturnType<typeof createStackActionProps>>;
interface VStackActionControl {
  readonly control: VStackControl;
  readonly actions: VStackAction[];
  readonly $actions: VNodeChild[];
}
type VStackBuiltinActionType = 'ok' | 'cancel' | 'close';
interface VStackBuiltinActionContext {
  service: VueStackService;
  control: VStackControl;
  key: string | number;
  bindings: {
    onClick?: (ev: PointerEvent) => void;
  };
}
type VStackBuiltinAction = (context: VStackBuiltinActionContext) => VNodeChild;
type VStackBuiltinActions = Record<VStackBuiltinActionType, VStackBuiltinAction>;
declare const BUILTIN_ACTION_HANDLERS: Record<VStackBuiltinActionType, (control: VStackControl, ev: PointerEvent) => any>;
//#endregion
//#region src/plugin.d.ts
declare module 'vue' {
  interface ComponentCustomProperties {
    $vstack: VueStackService;
  }
}
declare class VueStackPlugin {
  static install(app: App, opts?: VueStackServiceOptions): void;
}
declare function installVueStackPlugin(app: App, opts?: VueStackServiceOptions): App<any>;
//#endregion
//#region src/composables/service.d.ts
declare function useVueStack(): VueStackService;
//#endregion
//#region src/composables/control.d.ts
type VStackCloseReason = 'indeterminate' | 'resolved' | 'canceled';
interface UseStackControlOptions {
  onActivated?: (isActive: boolean, control: VStackControl) => any;
  onContentMounted?: (content: HTMLElement, control: VStackControl) => any;
  onContentDetached?: (control: VStackControl) => any;
  transitionResolver?: (control: VStackControl) => string;
  /**
   * A string or symbol used to identify the stack
   *
   * If set, the activator element will be given an attribute
   * in the form of `data-v-stack-type="${stackType}"`.
   */
  stackType?: string | symbol;
  manualAttrs?: boolean;
  /**
   * Additional attributes to apply to the element attributes of the activator slot parameters
   *
   * If set, the attributes will be added to the `attrs` property
   * object of the activator slot.
   *
   * @see {@link VStackActivatorAttrsSpec}
   */
  activatorAttrs?: VStackActivatorAttrsSpec;
}
declare function useStackControl(props: VStackProps, ctx: VStackSetupContext, opts?: UseStackControlOptions): VStackControl;
//#endregion
//#region src/composables/component.d.ts
type StackableSetupContext<Props extends Readonly<ComponentPropsOptions>, Emits extends EmitsOptions, Slots extends SlotsType, CustomAPI extends Record<keyof any, any>> = {
  readonly control: VStackControl;
  readonly props: ExtractPropTypes<StackablePropsOptions & Props>;
  readonly setupContext: SetupContext<StackableEmits & Emits, Slots>;
} & CustomAPI;
interface DefineStackableSettings<Props extends Readonly<ComponentPropsOptions>, Emits extends EmitsOptions, Slots extends SlotsType, CustomAPI extends Record<keyof any, any> = {}> {
  name?: string;
  setup?: (ctx: StackableSetupContext<Props, Emits, Slots, CustomAPI>) => ((children: VNodeChild, ctx: StackableSetupContext<Props, Emits, Slots, CustomAPI>) => VNode) | void;
  render?: (children: VNodeChild, ctx: StackableSetupContext<Props, Emits, Slots, CustomAPI>) => VNode;
}
/**
 * @TODO Utility to temporarily deal with the fact that emits options can no longer be merged since vue3.4.
 */
type EmitsToPropOptions<T extends EmitsOptions> = T extends string[] ? { [K in string & `on${Capitalize<T[number]>}`]: PropType<(...args: any[]) => any>; } : T extends ObjectEmitsOptions ? { [K in string & `on${Capitalize<string & keyof T>}`]: K extends `on${infer C}` ? T[Uncapitalize<C>] extends null ? never : PropType<(...args: T[Uncapitalize<C>] extends ((...args: infer P) => any) ? P : never) => any> : never; } : {};
declare function setupStackableComponent<Props extends Readonly<ComponentPropsOptions>, Emits extends EmitsOptions = EmitsOptions, Slots extends SlotsType = SlotsType, CustomAPI extends Record<keyof any, any> = Record<keyof any, any>>(props: any, setupContext: any, options?: UseStackControlOptions): StackableSetupContext<Props, Emits, Slots, CustomAPI>;
//#endregion
//#region src/composables/action.d.ts
interface UseStackActionOptions {
  resolver?: (actions: VStackAction[]) => VStackAction[];
}
declare function useStackAction(props: VStackActionProps, control: VStackControl, opts?: UseStackActionOptions): VStackActionControl;
//#endregion
//#region src/components/VDynamicStacks.d.ts
declare const VDynamicStacks: import("vue").DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
//#endregion
//#region src/components/VDialog.d.ts
interface CreateDialogSchemeOptions {
  /**
   * @default "v-stack-slide-y"
   */
  defaultTransition?: string;
  /**
   * @default true
   */
  defaultScrollLock?: boolean;
  /**
   * @default false
   */
  defaultBackdrop?: string | boolean;
  /** @default true */
  defaultCloseOnOutsideClick?: boolean;
  /** @default false */
  defaultPersistent?: boolean;
}
interface DefineDialogSettings<Props extends Readonly<ComponentPropsOptions>, Emits extends EmitsOptions, Slots extends SlotsType> extends DefineStackableSettings<Props, Emits, Slots>, CreateDialogSchemeOptions {
  props?: Props;
  emits?: Emits;
  slots?: Slots;
  attrs?: Record<string, any>;
  manualAttrs?: boolean;
}
declare function defineDialogComponent<Props extends Readonly<ComponentPropsOptions> = {}, Emits extends EmitsOptions = {}, Slots extends SlotsType = SlotsType<{}>>(settings: DefineDialogSettings<Props, Emits, Slots>): import("vue").DefineComponent<import("vue").ComponentObjectPropsOptions<{
  [x: string]: unknown;
}> extends {
  'v-slots': import("vue").PropType<{
    default?: ((control: VStackControl) => import("vue").VNodeChild) | undefined;
    activator?: ((payload: VStackActivatorPayload) => import("vue").VNodeChild) | undefined;
  }>;
  modelValue: BooleanConstructor;
  lazyBoot: BooleanConstructor;
  value: null;
  class: null;
  style: import("vue").PropType<import("vue").StyleValue>;
  transition: {
    type: import("vue").PropType<RawVStackObjectTransitionProp<string | import("@fastkit/vue-transitions").JavaScriptTransition>>;
    default: string;
  };
  alwaysRender: BooleanConstructor;
  backdrop: {
    type: import("vue").PropType<boolean | string>;
    default: string | boolean;
  };
  focusTrap: {
    type: BooleanConstructor;
    default: boolean;
  };
  focusRestorable: {
    type: BooleanConstructor;
    default: boolean;
  };
  scrollLock: {
    type: BooleanConstructor;
    default: boolean;
  };
  openOnClick: {
    type: BooleanConstructor;
    default: undefined;
  };
  openOnHover: BooleanConstructor;
  openOnContextmenu: BooleanConstructor;
  openOnFocus: {
    type: BooleanConstructor;
    default: undefined;
  };
  openDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeOnOutsideClick: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnEsc: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnTab: {
    type: import("vue").PropType<StackableTabCloseSpec>;
    default: StackableTabCloseSpec;
  };
  closeOnNavigation: {
    type: BooleanConstructor;
    default: boolean;
  };
  persistent: {
    type: BooleanConstructor;
    default: boolean;
  };
  disabled: BooleanConstructor;
  zIndex: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  timeout: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  navigationGuard: {
    type: import("vue").PropType<boolean | VStackNavigationGuard>;
    default: boolean;
  };
  guardEffect: {
    type: (BooleanConstructor | StringConstructor)[];
    default: boolean;
  };
  includeElements: import("vue").PropType<() => Element[]>;
  activator: import("vue").PropType<VStackActivatorQuery>;
  resolveHandler: import("vue").PropType<StackableResolveHandler>;
  cancelHandler: import("vue").PropType<StackableResolveHandler>;
  activatorAttrs: import("vue").PropType<VStackActivatorAttrsSpec>;
} & Props & EmitsToPropOptions<{
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits> ? {} : import("vue").ExtractPropTypes<{
  'v-slots': import("vue").PropType<{
    default?: ((control: VStackControl) => import("vue").VNodeChild) | undefined;
    activator?: ((payload: VStackActivatorPayload) => import("vue").VNodeChild) | undefined;
  }>;
  modelValue: BooleanConstructor;
  lazyBoot: BooleanConstructor;
  value: null;
  class: null;
  style: import("vue").PropType<import("vue").StyleValue>;
  transition: {
    type: import("vue").PropType<RawVStackObjectTransitionProp<string | import("@fastkit/vue-transitions").JavaScriptTransition>>;
    default: string;
  };
  alwaysRender: BooleanConstructor;
  backdrop: {
    type: import("vue").PropType<boolean | string>;
    default: string | boolean;
  };
  focusTrap: {
    type: BooleanConstructor;
    default: boolean;
  };
  focusRestorable: {
    type: BooleanConstructor;
    default: boolean;
  };
  scrollLock: {
    type: BooleanConstructor;
    default: boolean;
  };
  openOnClick: {
    type: BooleanConstructor;
    default: undefined;
  };
  openOnHover: BooleanConstructor;
  openOnContextmenu: BooleanConstructor;
  openOnFocus: {
    type: BooleanConstructor;
    default: undefined;
  };
  openDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeOnOutsideClick: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnEsc: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnTab: {
    type: import("vue").PropType<StackableTabCloseSpec>;
    default: StackableTabCloseSpec;
  };
  closeOnNavigation: {
    type: BooleanConstructor;
    default: boolean;
  };
  persistent: {
    type: BooleanConstructor;
    default: boolean;
  };
  disabled: BooleanConstructor;
  zIndex: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  timeout: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  navigationGuard: {
    type: import("vue").PropType<boolean | VStackNavigationGuard>;
    default: boolean;
  };
  guardEffect: {
    type: (BooleanConstructor | StringConstructor)[];
    default: boolean;
  };
  includeElements: import("vue").PropType<() => Element[]>;
  activator: import("vue").PropType<VStackActivatorQuery>;
  resolveHandler: import("vue").PropType<StackableResolveHandler>;
  cancelHandler: import("vue").PropType<StackableResolveHandler>;
  activatorAttrs: import("vue").PropType<VStackActivatorAttrsSpec>;
} & Props & EmitsToPropOptions<{
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} extends {
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits ? {} : {
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits, string, import("vue").PublicProps, Readonly<import("vue").ComponentObjectPropsOptions<{
  [x: string]: unknown;
}> extends {
  'v-slots': import("vue").PropType<{
    default?: ((control: VStackControl) => import("vue").VNodeChild) | undefined;
    activator?: ((payload: VStackActivatorPayload) => import("vue").VNodeChild) | undefined;
  }>;
  modelValue: BooleanConstructor;
  lazyBoot: BooleanConstructor;
  value: null;
  class: null;
  style: import("vue").PropType<import("vue").StyleValue>;
  transition: {
    type: import("vue").PropType<RawVStackObjectTransitionProp<string | import("@fastkit/vue-transitions").JavaScriptTransition>>;
    default: string;
  };
  alwaysRender: BooleanConstructor;
  backdrop: {
    type: import("vue").PropType<boolean | string>;
    default: string | boolean;
  };
  focusTrap: {
    type: BooleanConstructor;
    default: boolean;
  };
  focusRestorable: {
    type: BooleanConstructor;
    default: boolean;
  };
  scrollLock: {
    type: BooleanConstructor;
    default: boolean;
  };
  openOnClick: {
    type: BooleanConstructor;
    default: undefined;
  };
  openOnHover: BooleanConstructor;
  openOnContextmenu: BooleanConstructor;
  openOnFocus: {
    type: BooleanConstructor;
    default: undefined;
  };
  openDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeOnOutsideClick: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnEsc: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnTab: {
    type: import("vue").PropType<StackableTabCloseSpec>;
    default: StackableTabCloseSpec;
  };
  closeOnNavigation: {
    type: BooleanConstructor;
    default: boolean;
  };
  persistent: {
    type: BooleanConstructor;
    default: boolean;
  };
  disabled: BooleanConstructor;
  zIndex: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  timeout: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  navigationGuard: {
    type: import("vue").PropType<boolean | VStackNavigationGuard>;
    default: boolean;
  };
  guardEffect: {
    type: (BooleanConstructor | StringConstructor)[];
    default: boolean;
  };
  includeElements: import("vue").PropType<() => Element[]>;
  activator: import("vue").PropType<VStackActivatorQuery>;
  resolveHandler: import("vue").PropType<StackableResolveHandler>;
  cancelHandler: import("vue").PropType<StackableResolveHandler>;
  activatorAttrs: import("vue").PropType<VStackActivatorAttrsSpec>;
} & Props & EmitsToPropOptions<{
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits> ? {} : import("vue").ExtractPropTypes<{
  'v-slots': import("vue").PropType<{
    default?: ((control: VStackControl) => import("vue").VNodeChild) | undefined;
    activator?: ((payload: VStackActivatorPayload) => import("vue").VNodeChild) | undefined;
  }>;
  modelValue: BooleanConstructor;
  lazyBoot: BooleanConstructor;
  value: null;
  class: null;
  style: import("vue").PropType<import("vue").StyleValue>;
  transition: {
    type: import("vue").PropType<RawVStackObjectTransitionProp<string | import("@fastkit/vue-transitions").JavaScriptTransition>>;
    default: string;
  };
  alwaysRender: BooleanConstructor;
  backdrop: {
    type: import("vue").PropType<boolean | string>;
    default: string | boolean;
  };
  focusTrap: {
    type: BooleanConstructor;
    default: boolean;
  };
  focusRestorable: {
    type: BooleanConstructor;
    default: boolean;
  };
  scrollLock: {
    type: BooleanConstructor;
    default: boolean;
  };
  openOnClick: {
    type: BooleanConstructor;
    default: undefined;
  };
  openOnHover: BooleanConstructor;
  openOnContextmenu: BooleanConstructor;
  openOnFocus: {
    type: BooleanConstructor;
    default: undefined;
  };
  openDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeOnOutsideClick: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnEsc: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnTab: {
    type: import("vue").PropType<StackableTabCloseSpec>;
    default: StackableTabCloseSpec;
  };
  closeOnNavigation: {
    type: BooleanConstructor;
    default: boolean;
  };
  persistent: {
    type: BooleanConstructor;
    default: boolean;
  };
  disabled: BooleanConstructor;
  zIndex: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  timeout: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  navigationGuard: {
    type: import("vue").PropType<boolean | VStackNavigationGuard>;
    default: boolean;
  };
  guardEffect: {
    type: (BooleanConstructor | StringConstructor)[];
    default: boolean;
  };
  includeElements: import("vue").PropType<() => Element[]>;
  activator: import("vue").PropType<VStackActivatorQuery>;
  resolveHandler: import("vue").PropType<StackableResolveHandler>;
  cancelHandler: import("vue").PropType<StackableResolveHandler>;
  activatorAttrs: import("vue").PropType<VStackActivatorAttrsSpec>;
} & Props & EmitsToPropOptions<{
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits>>> & Readonly<import("vue").EmitsToProps<{} extends {
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits ? {} : {
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits>>, import("vue").ExtractDefaultPropTypes<{
  'v-slots': import("vue").PropType<{
    default?: ((control: VStackControl) => import("vue").VNodeChild) | undefined;
    activator?: ((payload: VStackActivatorPayload) => import("vue").VNodeChild) | undefined;
  }>;
  modelValue: BooleanConstructor;
  lazyBoot: BooleanConstructor;
  value: null;
  class: null;
  style: import("vue").PropType<import("vue").StyleValue>;
  transition: {
    type: import("vue").PropType<RawVStackObjectTransitionProp<string | import("@fastkit/vue-transitions").JavaScriptTransition>>;
    default: string;
  };
  alwaysRender: BooleanConstructor;
  backdrop: {
    type: import("vue").PropType<boolean | string>;
    default: string | boolean;
  };
  focusTrap: {
    type: BooleanConstructor;
    default: boolean;
  };
  focusRestorable: {
    type: BooleanConstructor;
    default: boolean;
  };
  scrollLock: {
    type: BooleanConstructor;
    default: boolean;
  };
  openOnClick: {
    type: BooleanConstructor;
    default: undefined;
  };
  openOnHover: BooleanConstructor;
  openOnContextmenu: BooleanConstructor;
  openOnFocus: {
    type: BooleanConstructor;
    default: undefined;
  };
  openDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeOnOutsideClick: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnEsc: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnTab: {
    type: import("vue").PropType<StackableTabCloseSpec>;
    default: StackableTabCloseSpec;
  };
  closeOnNavigation: {
    type: BooleanConstructor;
    default: boolean;
  };
  persistent: {
    type: BooleanConstructor;
    default: boolean;
  };
  disabled: BooleanConstructor;
  zIndex: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  timeout: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  navigationGuard: {
    type: import("vue").PropType<boolean | VStackNavigationGuard>;
    default: boolean;
  };
  guardEffect: {
    type: (BooleanConstructor | StringConstructor)[];
    default: boolean;
  };
  includeElements: import("vue").PropType<() => Element[]>;
  activator: import("vue").PropType<VStackActivatorQuery>;
  resolveHandler: import("vue").PropType<StackableResolveHandler>;
  cancelHandler: import("vue").PropType<StackableResolveHandler>;
  activatorAttrs: import("vue").PropType<VStackActivatorAttrsSpec>;
} & Props & EmitsToPropOptions<{
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits>>, MergeStackBaseSlots<Slots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
//#endregion
//#region src/components/VSnackbarTransition.d.ts
declare const stackSnackbarTransitionProps: {
  top: BooleanConstructor;
  bottom: BooleanConstructor;
  left: BooleanConstructor;
  right: BooleanConstructor;
};
type SnackbarTransitionPropsOptions = typeof stackSnackbarTransitionProps;
//#endregion
//#region src/components/VSnackbar.d.ts
type SnackbarPropsOptions = SnackbarTransitionPropsOptions;
/**
 * Snackbar position
 */
interface SnackPosition {
  top: boolean;
  bottom: boolean;
  left: boolean;
  right: boolean;
}
interface SnackbarAPI {
  /**
   * Snackbar position
   *
   * @see {@link SnackPosition}
   */
  readonly position: SnackPosition;
  readonly attrs: Record<string, any>;
}
interface DefineSnackbarSettings<Props extends Readonly<ComponentPropsOptions>, Emits extends EmitsOptions, Slots extends SlotsType> extends DefineStackableSettings<Props & SnackbarPropsOptions, Emits, Slots, SnackbarAPI> {
  props?: Props;
  emits?: Emits;
  slots?: Slots;
  /**
   * @default "v-stack-fade"
   */
  defaultTransition?: string;
  /**
   * @default 6000
   */
  defaultTimeout?: number;
}
declare function defineSnackbarComponent<Props extends Readonly<ComponentPropsOptions> = {}, Emits extends EmitsOptions = {}, Slots extends SlotsType = SlotsType<{}>>(settings: DefineSnackbarSettings<Props, Emits, Slots>): import("vue").DefineComponent<import("vue").ComponentObjectPropsOptions<{
  [x: string]: unknown;
}> extends {
  top: BooleanConstructor;
  bottom: BooleanConstructor;
  left: BooleanConstructor;
  right: BooleanConstructor;
  'v-slots': import("vue").PropType<{
    default?: ((control: VStackControl) => import("vue").VNodeChild) | undefined;
    activator?: ((payload: VStackActivatorPayload) => import("vue").VNodeChild) | undefined;
  }>;
  modelValue: BooleanConstructor;
  lazyBoot: BooleanConstructor;
  value: null;
  class: null;
  style: import("vue").PropType<import("vue").StyleValue>;
  transition: {
    type: import("vue").PropType<RawVStackObjectTransitionProp<string | import("@fastkit/vue-transitions").JavaScriptTransition>>;
    default: string;
  };
  alwaysRender: BooleanConstructor;
  backdrop: {
    type: import("vue").PropType<boolean | string>;
    default: string | boolean;
  };
  focusTrap: {
    type: BooleanConstructor;
    default: boolean;
  };
  focusRestorable: {
    type: BooleanConstructor;
    default: boolean;
  };
  scrollLock: {
    type: BooleanConstructor;
    default: boolean;
  };
  openOnClick: {
    type: BooleanConstructor;
    default: undefined;
  };
  openOnHover: BooleanConstructor;
  openOnContextmenu: BooleanConstructor;
  openOnFocus: {
    type: BooleanConstructor;
    default: undefined;
  };
  openDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeOnOutsideClick: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnEsc: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnTab: {
    type: import("vue").PropType<StackableTabCloseSpec>;
    default: StackableTabCloseSpec;
  };
  closeOnNavigation: {
    type: BooleanConstructor;
    default: boolean;
  };
  persistent: {
    type: BooleanConstructor;
    default: boolean;
  };
  disabled: BooleanConstructor;
  zIndex: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  timeout: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  navigationGuard: {
    type: import("vue").PropType<boolean | VStackNavigationGuard>;
    default: boolean;
  };
  guardEffect: {
    type: (BooleanConstructor | StringConstructor)[];
    default: boolean;
  };
  includeElements: import("vue").PropType<() => Element[]>;
  activator: import("vue").PropType<VStackActivatorQuery>;
  resolveHandler: import("vue").PropType<StackableResolveHandler>;
  cancelHandler: import("vue").PropType<StackableResolveHandler>;
  activatorAttrs: import("vue").PropType<VStackActivatorAttrsSpec>;
} & Props & EmitsToPropOptions<{
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits> ? {} : import("vue").ExtractPropTypes<{
  top: BooleanConstructor;
  bottom: BooleanConstructor;
  left: BooleanConstructor;
  right: BooleanConstructor;
  'v-slots': import("vue").PropType<{
    default?: ((control: VStackControl) => import("vue").VNodeChild) | undefined;
    activator?: ((payload: VStackActivatorPayload) => import("vue").VNodeChild) | undefined;
  }>;
  modelValue: BooleanConstructor;
  lazyBoot: BooleanConstructor;
  value: null;
  class: null;
  style: import("vue").PropType<import("vue").StyleValue>;
  transition: {
    type: import("vue").PropType<RawVStackObjectTransitionProp<string | import("@fastkit/vue-transitions").JavaScriptTransition>>;
    default: string;
  };
  alwaysRender: BooleanConstructor;
  backdrop: {
    type: import("vue").PropType<boolean | string>;
    default: string | boolean;
  };
  focusTrap: {
    type: BooleanConstructor;
    default: boolean;
  };
  focusRestorable: {
    type: BooleanConstructor;
    default: boolean;
  };
  scrollLock: {
    type: BooleanConstructor;
    default: boolean;
  };
  openOnClick: {
    type: BooleanConstructor;
    default: undefined;
  };
  openOnHover: BooleanConstructor;
  openOnContextmenu: BooleanConstructor;
  openOnFocus: {
    type: BooleanConstructor;
    default: undefined;
  };
  openDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeOnOutsideClick: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnEsc: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnTab: {
    type: import("vue").PropType<StackableTabCloseSpec>;
    default: StackableTabCloseSpec;
  };
  closeOnNavigation: {
    type: BooleanConstructor;
    default: boolean;
  };
  persistent: {
    type: BooleanConstructor;
    default: boolean;
  };
  disabled: BooleanConstructor;
  zIndex: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  timeout: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  navigationGuard: {
    type: import("vue").PropType<boolean | VStackNavigationGuard>;
    default: boolean;
  };
  guardEffect: {
    type: (BooleanConstructor | StringConstructor)[];
    default: boolean;
  };
  includeElements: import("vue").PropType<() => Element[]>;
  activator: import("vue").PropType<VStackActivatorQuery>;
  resolveHandler: import("vue").PropType<StackableResolveHandler>;
  cancelHandler: import("vue").PropType<StackableResolveHandler>;
  activatorAttrs: import("vue").PropType<VStackActivatorAttrsSpec>;
} & Props & EmitsToPropOptions<{
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} extends {
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits ? {} : {
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits, string, import("vue").PublicProps, Readonly<import("vue").ComponentObjectPropsOptions<{
  [x: string]: unknown;
}> extends {
  top: BooleanConstructor;
  bottom: BooleanConstructor;
  left: BooleanConstructor;
  right: BooleanConstructor;
  'v-slots': import("vue").PropType<{
    default?: ((control: VStackControl) => import("vue").VNodeChild) | undefined;
    activator?: ((payload: VStackActivatorPayload) => import("vue").VNodeChild) | undefined;
  }>;
  modelValue: BooleanConstructor;
  lazyBoot: BooleanConstructor;
  value: null;
  class: null;
  style: import("vue").PropType<import("vue").StyleValue>;
  transition: {
    type: import("vue").PropType<RawVStackObjectTransitionProp<string | import("@fastkit/vue-transitions").JavaScriptTransition>>;
    default: string;
  };
  alwaysRender: BooleanConstructor;
  backdrop: {
    type: import("vue").PropType<boolean | string>;
    default: string | boolean;
  };
  focusTrap: {
    type: BooleanConstructor;
    default: boolean;
  };
  focusRestorable: {
    type: BooleanConstructor;
    default: boolean;
  };
  scrollLock: {
    type: BooleanConstructor;
    default: boolean;
  };
  openOnClick: {
    type: BooleanConstructor;
    default: undefined;
  };
  openOnHover: BooleanConstructor;
  openOnContextmenu: BooleanConstructor;
  openOnFocus: {
    type: BooleanConstructor;
    default: undefined;
  };
  openDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeOnOutsideClick: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnEsc: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnTab: {
    type: import("vue").PropType<StackableTabCloseSpec>;
    default: StackableTabCloseSpec;
  };
  closeOnNavigation: {
    type: BooleanConstructor;
    default: boolean;
  };
  persistent: {
    type: BooleanConstructor;
    default: boolean;
  };
  disabled: BooleanConstructor;
  zIndex: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  timeout: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  navigationGuard: {
    type: import("vue").PropType<boolean | VStackNavigationGuard>;
    default: boolean;
  };
  guardEffect: {
    type: (BooleanConstructor | StringConstructor)[];
    default: boolean;
  };
  includeElements: import("vue").PropType<() => Element[]>;
  activator: import("vue").PropType<VStackActivatorQuery>;
  resolveHandler: import("vue").PropType<StackableResolveHandler>;
  cancelHandler: import("vue").PropType<StackableResolveHandler>;
  activatorAttrs: import("vue").PropType<VStackActivatorAttrsSpec>;
} & Props & EmitsToPropOptions<{
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits> ? {} : import("vue").ExtractPropTypes<{
  top: BooleanConstructor;
  bottom: BooleanConstructor;
  left: BooleanConstructor;
  right: BooleanConstructor;
  'v-slots': import("vue").PropType<{
    default?: ((control: VStackControl) => import("vue").VNodeChild) | undefined;
    activator?: ((payload: VStackActivatorPayload) => import("vue").VNodeChild) | undefined;
  }>;
  modelValue: BooleanConstructor;
  lazyBoot: BooleanConstructor;
  value: null;
  class: null;
  style: import("vue").PropType<import("vue").StyleValue>;
  transition: {
    type: import("vue").PropType<RawVStackObjectTransitionProp<string | import("@fastkit/vue-transitions").JavaScriptTransition>>;
    default: string;
  };
  alwaysRender: BooleanConstructor;
  backdrop: {
    type: import("vue").PropType<boolean | string>;
    default: string | boolean;
  };
  focusTrap: {
    type: BooleanConstructor;
    default: boolean;
  };
  focusRestorable: {
    type: BooleanConstructor;
    default: boolean;
  };
  scrollLock: {
    type: BooleanConstructor;
    default: boolean;
  };
  openOnClick: {
    type: BooleanConstructor;
    default: undefined;
  };
  openOnHover: BooleanConstructor;
  openOnContextmenu: BooleanConstructor;
  openOnFocus: {
    type: BooleanConstructor;
    default: undefined;
  };
  openDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeOnOutsideClick: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnEsc: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnTab: {
    type: import("vue").PropType<StackableTabCloseSpec>;
    default: StackableTabCloseSpec;
  };
  closeOnNavigation: {
    type: BooleanConstructor;
    default: boolean;
  };
  persistent: {
    type: BooleanConstructor;
    default: boolean;
  };
  disabled: BooleanConstructor;
  zIndex: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  timeout: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  navigationGuard: {
    type: import("vue").PropType<boolean | VStackNavigationGuard>;
    default: boolean;
  };
  guardEffect: {
    type: (BooleanConstructor | StringConstructor)[];
    default: boolean;
  };
  includeElements: import("vue").PropType<() => Element[]>;
  activator: import("vue").PropType<VStackActivatorQuery>;
  resolveHandler: import("vue").PropType<StackableResolveHandler>;
  cancelHandler: import("vue").PropType<StackableResolveHandler>;
  activatorAttrs: import("vue").PropType<VStackActivatorAttrsSpec>;
} & Props & EmitsToPropOptions<{
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits>>> & Readonly<import("vue").EmitsToProps<{} extends {
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits ? {} : {
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits>>, import("vue").ExtractDefaultPropTypes<{
  top: BooleanConstructor;
  bottom: BooleanConstructor;
  left: BooleanConstructor;
  right: BooleanConstructor;
  'v-slots': import("vue").PropType<{
    default?: ((control: VStackControl) => import("vue").VNodeChild) | undefined;
    activator?: ((payload: VStackActivatorPayload) => import("vue").VNodeChild) | undefined;
  }>;
  modelValue: BooleanConstructor;
  lazyBoot: BooleanConstructor;
  value: null;
  class: null;
  style: import("vue").PropType<import("vue").StyleValue>;
  transition: {
    type: import("vue").PropType<RawVStackObjectTransitionProp<string | import("@fastkit/vue-transitions").JavaScriptTransition>>;
    default: string;
  };
  alwaysRender: BooleanConstructor;
  backdrop: {
    type: import("vue").PropType<boolean | string>;
    default: string | boolean;
  };
  focusTrap: {
    type: BooleanConstructor;
    default: boolean;
  };
  focusRestorable: {
    type: BooleanConstructor;
    default: boolean;
  };
  scrollLock: {
    type: BooleanConstructor;
    default: boolean;
  };
  openOnClick: {
    type: BooleanConstructor;
    default: undefined;
  };
  openOnHover: BooleanConstructor;
  openOnContextmenu: BooleanConstructor;
  openOnFocus: {
    type: BooleanConstructor;
    default: undefined;
  };
  openDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeDelay: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  closeOnOutsideClick: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnEsc: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnTab: {
    type: import("vue").PropType<StackableTabCloseSpec>;
    default: StackableTabCloseSpec;
  };
  closeOnNavigation: {
    type: BooleanConstructor;
    default: boolean;
  };
  persistent: {
    type: BooleanConstructor;
    default: boolean;
  };
  disabled: BooleanConstructor;
  zIndex: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  timeout: {
    type: import("vue").PropType<string | number>;
    default: string | number;
  };
  navigationGuard: {
    type: import("vue").PropType<boolean | VStackNavigationGuard>;
    default: boolean;
  };
  guardEffect: {
    type: (BooleanConstructor | StringConstructor)[];
    default: boolean;
  };
  includeElements: import("vue").PropType<() => Element[]>;
  activator: import("vue").PropType<VStackActivatorQuery>;
  resolveHandler: import("vue").PropType<StackableResolveHandler>;
  cancelHandler: import("vue").PropType<StackableResolveHandler>;
  activatorAttrs: import("vue").PropType<VStackActivatorAttrsSpec>;
} & Props & EmitsToPropOptions<{
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits>>, MergeStackBaseSlots<Slots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
//#endregion
//#region src/components/VMenu.d.ts
/**
 * Overlap settings with the activator
 *
 * - `allow` Allow overlapping if display space is insufficient
 * - `disallow` Do not allow overlapping even when display space is insufficient.
 * - `overlap` Overlap on the activator
 *
 * If internal position settings like (left, right, top, bottom)-inner are used, this configuration does not apply to that axis.
 */
type MenuOverlapSettings = 'allow' | 'disallow' | 'overlap';
type RawMenuOverlapSettings = MenuOverlapSettings | boolean;
interface CreateMenuSchemeOptions {
  /**
   * @default "v-menu-auto"
   */
  defaultTransition?: string;
  /**
   * @default true
   */
  defaultScrollLock?: boolean;
  defaultDistance?: number;
  defaultEdgeMargin?: number;
  defaultForceEdgeMargin?: boolean;
  defaultResizeWatchDebounce?: number;
  /**
   * @default false
   */
  defaultAllowOverflow?: boolean;
  /**
   * @default false
   */
  defaultOverlap?: RawMenuOverlapSettings;
  /** @default true */
  defaultCloseOnEsc?: boolean;
  /** @default true */
  defaultCloseOnTab?: StackableTabCloseSpec;
  /** @default false */
  defaultHideOnScroll?: boolean | string | number;
  /** @default true */
  defaultHideOnInvisible?: boolean;
}
type MenuSizeSpec = number | 'fit' | 'free';
type RawMenuMaxSize = MenuSizeSpec | ((window: UseWindowRef) => number | undefined);
declare function createMenuProps(options?: CreateMenuSchemeOptions): {
  /**
   * Horizontal Axis Position
   *
   * - `left` To the left of the activator.
   * - `left-inner` Align to the left edge of the activator.
   * - `center` Align to the center of the activator.
   * - `right` To the right of the activator.
   * - `right-inner` Align to the right edge of the activator.
   */
  x: PropType<VMenuXPosition>;
  /**
   * Vertical Axis Position
   *
   * - `top` To the top of the activator.
   * - `top-inner` Align to the top edge of the activator.
   * - `center` Align to the center of the activator.
   * - `bottom` To the bottom of the activator.
   * - `bottom-inner` Align to the bottom edge of the activator.
   */
  y: PropType<VMenuYPosition>;
  /**
   * Allow overflow from the screen.
   *
   * If this setting is not enabled, the element's size will be reduced when exceeding coordinates beyond the screen edge, subtracting the edge margin.
   */
  allowOverflow: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * width
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  width: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * height
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the height will match that of the activator.
   */
  height: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Minimum width
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  minWidth: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Minimum height
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  minHeight: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Maximum width
   *
   * It is possible to set values that can be configured as CSS or dynamic sizes through callback functions.
   *
   * This setting is ignored if `allowOverflow` is enabled.
   *
   * @see {@link RAW_MENU_MAX_SIZE_PROP}
   */
  maxWidth: PropType<RawMenuMaxSize>;
  /**
   * Maximum height
   *
   * It is possible to set values that can be configured as CSS or dynamic sizes through callback functions.
   *
   * This setting is ignored if `allowOverflow` is enabled.
   *
   * @see {@link RAW_MENU_MAX_SIZE_PROP}
   */
  maxHeight: PropType<RawMenuMaxSize>;
  /**
   * Distance from the activator (in pixels).
   *
   * If a position setting, such as (left, right, top, bottom)-inner, is used, the distance is not applied to that axis.
   */
  distance: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Margin from the screen edge
   *
   * By default, it is controlled to ensure that the coordinates, subtracted by this margin from the screen edge, do not overflow.
   */
  edgeMargin: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Force margin at edge
   *
   * By default, even if `edgeMargin` is set, the activator may snap outside that margin. Enabling this option forces the component to always maintain the specified `edgeMargin` from the screen edge.
   */
  forceEdgeMargin: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * Overlap settings with the activator
   *
   * - `allow` | `false` Allow overlapping if display space is insufficient
   * - `disallow` Do not allow overlapping even when display space is insufficient.
   * - `overlap` | `true` Overlap on the activator
   *
   * If internal position settings like (left, right, top, bottom)-inner are used, this configuration does not apply to that axis.
   *
   * @see {@link MenuOverlapSettings}
   */
  overlap: {
    type: PropType<MenuOverlapSettings | boolean>;
    default: RawMenuOverlapSettings;
  };
  resizeWatchDebounce: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Hide when scrolling
   *
   * If a value is specified, the tooltip will be hidden after scrolling by the specified number of pixels (px).
   */
  hideOnScroll: {
    type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
    default: string | number | boolean;
  };
  /**
   * Hide the stack element when the activator is scrolled out of view.
   */
  hideOnInvisible: {
    type: BooleanConstructor;
    default: boolean;
  };
};
declare function createMenuScheme(options?: CreateMenuSchemeOptions): {
  props: {
    /**
     * Horizontal Axis Position
     *
     * - `left` To the left of the activator.
     * - `left-inner` Align to the left edge of the activator.
     * - `center` Align to the center of the activator.
     * - `right` To the right of the activator.
     * - `right-inner` Align to the right edge of the activator.
     */
    x: PropType<VMenuXPosition>;
    /**
     * Vertical Axis Position
     *
     * - `top` To the top of the activator.
     * - `top-inner` Align to the top edge of the activator.
     * - `center` Align to the center of the activator.
     * - `bottom` To the bottom of the activator.
     * - `bottom-inner` Align to the bottom edge of the activator.
     */
    y: PropType<VMenuYPosition>;
    /**
     * Allow overflow from the screen.
     *
     * If this setting is not enabled, the element's size will be reduced when exceeding coordinates beyond the screen edge, subtracting the edge margin.
     */
    allowOverflow: {
      type: BooleanConstructor;
      default: boolean;
    };
    /**
     * width
     *
     * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
     */
    width: {
      type: PropType<number | "fit" | "free">;
      default: undefined;
    };
    /**
     * height
     *
     * Either specify a pixel size or use "fit". When "fit" is chosen, the height will match that of the activator.
     */
    height: {
      type: PropType<number | "fit" | "free">;
      default: undefined;
    };
    /**
     * Minimum width
     *
     * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
     */
    minWidth: {
      type: PropType<number | "fit" | "free">;
      default: undefined;
    };
    /**
     * Minimum height
     *
     * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
     */
    minHeight: {
      type: PropType<number | "fit" | "free">;
      default: undefined;
    };
    /**
     * Maximum width
     *
     * It is possible to set values that can be configured as CSS or dynamic sizes through callback functions.
     *
     * This setting is ignored if `allowOverflow` is enabled.
     *
     * @see {@link RAW_MENU_MAX_SIZE_PROP}
     */
    maxWidth: PropType<RawMenuMaxSize>;
    /**
     * Maximum height
     *
     * It is possible to set values that can be configured as CSS or dynamic sizes through callback functions.
     *
     * This setting is ignored if `allowOverflow` is enabled.
     *
     * @see {@link RAW_MENU_MAX_SIZE_PROP}
     */
    maxHeight: PropType<RawMenuMaxSize>;
    /**
     * Distance from the activator (in pixels).
     *
     * If a position setting, such as (left, right, top, bottom)-inner, is used, the distance is not applied to that axis.
     */
    distance: {
      type: NumberConstructor;
      default: number;
    };
    /**
     * Margin from the screen edge
     *
     * By default, it is controlled to ensure that the coordinates, subtracted by this margin from the screen edge, do not overflow.
     */
    edgeMargin: {
      type: NumberConstructor;
      default: number;
    };
    /**
     * Force margin at edge
     *
     * By default, even if `edgeMargin` is set, the activator may snap outside that margin. Enabling this option forces the component to always maintain the specified `edgeMargin` from the screen edge.
     */
    forceEdgeMargin: {
      type: BooleanConstructor;
      default: boolean;
    };
    /**
     * Overlap settings with the activator
     *
     * - `allow` | `false` Allow overlapping if display space is insufficient
     * - `disallow` Do not allow overlapping even when display space is insufficient.
     * - `overlap` | `true` Overlap on the activator
     *
     * If internal position settings like (left, right, top, bottom)-inner are used, this configuration does not apply to that axis.
     *
     * @see {@link MenuOverlapSettings}
     */
    overlap: {
      type: PropType<MenuOverlapSettings | boolean>;
      default: RawMenuOverlapSettings;
    };
    resizeWatchDebounce: {
      type: NumberConstructor;
      default: number;
    };
    /**
     * Hide when scrolling
     *
     * If a value is specified, the tooltip will be hidden after scrolling by the specified number of pixels (px).
     */
    hideOnScroll: {
      type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
      default: string | number | boolean;
    };
    /**
     * Hide the stack element when the activator is scrolled out of view.
     */
    hideOnInvisible: {
      type: BooleanConstructor;
      default: boolean;
    };
    'v-slots': PropType<{
      default?: ((control: VStackControl) => import("vue").VNodeChild) | undefined;
      activator?: ((payload: VStackActivatorPayload) => import("vue").VNodeChild) | undefined;
    }>;
    modelValue: BooleanConstructor;
    lazyBoot: BooleanConstructor;
    value: null;
    class: null;
    style: PropType<import("vue").StyleValue>;
    transition: {
      type: PropType<RawVStackObjectTransitionProp<string | import("@fastkit/vue-transitions").JavaScriptTransition>>;
      default: string;
    };
    alwaysRender: BooleanConstructor;
    backdrop: {
      type: PropType<boolean | string>;
      default: string | boolean;
    };
    focusTrap: {
      type: BooleanConstructor;
      default: boolean;
    };
    focusRestorable: {
      type: BooleanConstructor;
      default: boolean;
    };
    scrollLock: {
      type: BooleanConstructor;
      default: boolean;
    };
    openOnClick: {
      type: BooleanConstructor;
      default: undefined;
    };
    openOnHover: BooleanConstructor;
    openOnContextmenu: BooleanConstructor;
    openOnFocus: {
      type: BooleanConstructor;
      default: undefined;
    };
    openDelay: {
      type: PropType<string | number>;
      default: string | number;
    };
    closeDelay: {
      type: PropType<string | number>;
      default: string | number;
    };
    closeOnOutsideClick: {
      type: BooleanConstructor;
      default: boolean;
    };
    closeOnEsc: {
      type: BooleanConstructor;
      default: boolean;
    };
    closeOnTab: {
      type: PropType<StackableTabCloseSpec>;
      default: StackableTabCloseSpec;
    };
    closeOnNavigation: {
      type: BooleanConstructor;
      default: boolean;
    };
    persistent: {
      type: BooleanConstructor;
      default: boolean;
    };
    disabled: BooleanConstructor;
    zIndex: {
      type: PropType<string | number>;
      default: string | number;
    };
    timeout: {
      type: PropType<string | number>;
      default: string | number;
    };
    navigationGuard: {
      type: PropType<boolean | VStackNavigationGuard>;
      default: boolean;
    };
    guardEffect: {
      type: (BooleanConstructor | StringConstructor)[];
      default: boolean;
    };
    includeElements: PropType<() => Element[]>;
    activator: PropType<VStackActivatorQuery>;
    resolveHandler: PropType<StackableResolveHandler>;
    cancelHandler: PropType<StackableResolveHandler>;
    activatorAttrs: PropType<VStackActivatorAttrsSpec>;
  };
  emits: {
    'update:modelValue': (modelValue: boolean) => boolean;
    change: (modelValue: boolean) => boolean;
    payload: (value: any) => boolean;
    show: (control: VStackControl) => boolean;
    close: (control: VStackControl) => boolean;
    beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
    afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
    enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
    beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
    afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
    leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  };
};
type MenuPropsOptions = ReturnType<typeof createMenuProps>;
type MenuInput = ExtractPropInput<MenuPropsOptions>;
type MenuEmits = ReturnType<typeof createMenuScheme>['emits'];
type VMenuXPosition = 'left' | 'left-inner' | 'center' | 'right' | 'right-inner';
type VMenuYPosition = 'top' | 'top-inner' | 'center' | 'bottom' | 'bottom-inner';
interface VMenuRect {
  left: number;
  right: number;
  top: number;
  bottom: number;
  width: number;
  height: number;
}
interface VMenuRectInfo extends VMenuRect {
  positions: {
    top: boolean;
    bottom: boolean;
    left: boolean;
    right: boolean;
    xInner: boolean;
    yInner: boolean;
  };
  bubble: {
    styles: {
      '--bubble-top'?: string;
      '--bubble-bottom'?: string;
      '--bubble-left'?: string;
      '--bubble-right'?: string;
    };
  };
}
interface VMenuState {
  pageXOffset: number;
  pageYOffset: number;
  rect: VMenuRect | null;
  activatorRect: VMenuRect | null;
}
interface MenuAPI {
  readonly control: VStackControl;
  readonly attrs: Record<string, any>;
  readonly pageXOffset: number;
  readonly pageYOffset: number;
  readonly distance: number;
  readonly resizeWatchDebounce: number;
  readonly overlap: MenuOverlapSettings;
  readonly edgeMargin: number;
  readonly forceEdgeMargin: boolean;
  readonly minLeft: number;
  readonly minTop: number;
  readonly maxRight: number;
  readonly maxBottom: number;
  readonly rect: VMenuRectInfo | null;
  readonly styles: CSSProperties;
  readonly scrollerRef: Ref<HTMLElement | null>;
  readonly bodyRef: Ref<HTMLElement | null>;
  updatePageOffset(): void;
  updateMenuRect(menuBodyRect?: ResizeDirectivePayload): void;
  updateActivatorRect(): void;
  updateRects(menuBodyRect?: ResizeDirectivePayload): void;
}
interface DefineMenuSettings<Props extends Readonly<ComponentPropsOptions>, Emits extends EmitsOptions, Slots extends SlotsType> extends DefineStackableSettings<Props & MenuPropsOptions, Emits, Slots, MenuAPI>, CreateMenuSchemeOptions, Pick<UseStackControlOptions, 'activatorAttrs' | 'stackType'> {
  props?: Props;
  emits?: Emits;
  slots?: Slots;
  attrs?: Record<string, any> | ((ctx: StackableSetupContext<Props, Emits, Slots, MenuAPI>) => Record<string, any>);
}
declare function defineMenuComponent<Props extends Readonly<ComponentPropsOptions> = {}, Emits extends EmitsOptions = {}, Slots extends SlotsType = SlotsType<{}>>(settings: DefineMenuSettings<Props, Emits, Slots>): import("vue").DefineComponent<import("vue").ComponentObjectPropsOptions<{
  [x: string]: unknown;
}> extends {
  /**
   * Horizontal Axis Position
   *
   * - `left` To the left of the activator.
   * - `left-inner` Align to the left edge of the activator.
   * - `center` Align to the center of the activator.
   * - `right` To the right of the activator.
   * - `right-inner` Align to the right edge of the activator.
   */
  x: PropType<VMenuXPosition>;
  /**
   * Vertical Axis Position
   *
   * - `top` To the top of the activator.
   * - `top-inner` Align to the top edge of the activator.
   * - `center` Align to the center of the activator.
   * - `bottom` To the bottom of the activator.
   * - `bottom-inner` Align to the bottom edge of the activator.
   */
  y: PropType<VMenuYPosition>;
  /**
   * Allow overflow from the screen.
   *
   * If this setting is not enabled, the element's size will be reduced when exceeding coordinates beyond the screen edge, subtracting the edge margin.
   */
  allowOverflow: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * width
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  width: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * height
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the height will match that of the activator.
   */
  height: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Minimum width
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  minWidth: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Minimum height
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  minHeight: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Maximum width
   *
   * It is possible to set values that can be configured as CSS or dynamic sizes through callback functions.
   *
   * This setting is ignored if `allowOverflow` is enabled.
   *
   * @see {@link RAW_MENU_MAX_SIZE_PROP}
   */
  maxWidth: PropType<RawMenuMaxSize>;
  /**
   * Maximum height
   *
   * It is possible to set values that can be configured as CSS or dynamic sizes through callback functions.
   *
   * This setting is ignored if `allowOverflow` is enabled.
   *
   * @see {@link RAW_MENU_MAX_SIZE_PROP}
   */
  maxHeight: PropType<RawMenuMaxSize>;
  /**
   * Distance from the activator (in pixels).
   *
   * If a position setting, such as (left, right, top, bottom)-inner, is used, the distance is not applied to that axis.
   */
  distance: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Margin from the screen edge
   *
   * By default, it is controlled to ensure that the coordinates, subtracted by this margin from the screen edge, do not overflow.
   */
  edgeMargin: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Force margin at edge
   *
   * By default, even if `edgeMargin` is set, the activator may snap outside that margin. Enabling this option forces the component to always maintain the specified `edgeMargin` from the screen edge.
   */
  forceEdgeMargin: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * Overlap settings with the activator
   *
   * - `allow` | `false` Allow overlapping if display space is insufficient
   * - `disallow` Do not allow overlapping even when display space is insufficient.
   * - `overlap` | `true` Overlap on the activator
   *
   * If internal position settings like (left, right, top, bottom)-inner are used, this configuration does not apply to that axis.
   *
   * @see {@link MenuOverlapSettings}
   */
  overlap: {
    type: PropType<MenuOverlapSettings | boolean>;
    default: RawMenuOverlapSettings;
  };
  resizeWatchDebounce: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Hide when scrolling
   *
   * If a value is specified, the tooltip will be hidden after scrolling by the specified number of pixels (px).
   */
  hideOnScroll: {
    type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
    default: string | number | boolean;
  };
  /**
   * Hide the stack element when the activator is scrolled out of view.
   */
  hideOnInvisible: {
    type: BooleanConstructor;
    default: boolean;
  };
  'v-slots': PropType<{
    default?: ((control: VStackControl) => import("vue").VNodeChild) | undefined;
    activator?: ((payload: VStackActivatorPayload) => import("vue").VNodeChild) | undefined;
  }>;
  modelValue: BooleanConstructor;
  lazyBoot: BooleanConstructor;
  value: null;
  class: null;
  style: PropType<import("vue").StyleValue>;
  transition: {
    type: PropType<RawVStackObjectTransitionProp<string | import("@fastkit/vue-transitions").JavaScriptTransition>>;
    default: string;
  };
  alwaysRender: BooleanConstructor;
  backdrop: {
    type: PropType<boolean | string>;
    default: string | boolean;
  };
  focusTrap: {
    type: BooleanConstructor;
    default: boolean;
  };
  focusRestorable: {
    type: BooleanConstructor;
    default: boolean;
  };
  scrollLock: {
    type: BooleanConstructor;
    default: boolean;
  };
  openOnClick: {
    type: BooleanConstructor;
    default: undefined;
  };
  openOnHover: BooleanConstructor;
  openOnContextmenu: BooleanConstructor;
  openOnFocus: {
    type: BooleanConstructor;
    default: undefined;
  };
  openDelay: {
    type: PropType<string | number>;
    default: string | number;
  };
  closeDelay: {
    type: PropType<string | number>;
    default: string | number;
  };
  closeOnOutsideClick: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnEsc: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnTab: {
    type: PropType<StackableTabCloseSpec>;
    default: StackableTabCloseSpec;
  };
  closeOnNavigation: {
    type: BooleanConstructor;
    default: boolean;
  };
  persistent: {
    type: BooleanConstructor;
    default: boolean;
  };
  disabled: BooleanConstructor;
  zIndex: {
    type: PropType<string | number>;
    default: string | number;
  };
  timeout: {
    type: PropType<string | number>;
    default: string | number;
  };
  navigationGuard: {
    type: PropType<boolean | VStackNavigationGuard>;
    default: boolean;
  };
  guardEffect: {
    type: (BooleanConstructor | StringConstructor)[];
    default: boolean;
  };
  includeElements: PropType<() => Element[]>;
  activator: PropType<VStackActivatorQuery>;
  resolveHandler: PropType<StackableResolveHandler>;
  cancelHandler: PropType<StackableResolveHandler>;
  activatorAttrs: PropType<VStackActivatorAttrsSpec>;
} & Props & EmitsToPropOptions<{
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits> ? {} : ExtractPropTypes<{
  /**
   * Horizontal Axis Position
   *
   * - `left` To the left of the activator.
   * - `left-inner` Align to the left edge of the activator.
   * - `center` Align to the center of the activator.
   * - `right` To the right of the activator.
   * - `right-inner` Align to the right edge of the activator.
   */
  x: PropType<VMenuXPosition>;
  /**
   * Vertical Axis Position
   *
   * - `top` To the top of the activator.
   * - `top-inner` Align to the top edge of the activator.
   * - `center` Align to the center of the activator.
   * - `bottom` To the bottom of the activator.
   * - `bottom-inner` Align to the bottom edge of the activator.
   */
  y: PropType<VMenuYPosition>;
  /**
   * Allow overflow from the screen.
   *
   * If this setting is not enabled, the element's size will be reduced when exceeding coordinates beyond the screen edge, subtracting the edge margin.
   */
  allowOverflow: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * width
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  width: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * height
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the height will match that of the activator.
   */
  height: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Minimum width
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  minWidth: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Minimum height
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  minHeight: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Maximum width
   *
   * It is possible to set values that can be configured as CSS or dynamic sizes through callback functions.
   *
   * This setting is ignored if `allowOverflow` is enabled.
   *
   * @see {@link RAW_MENU_MAX_SIZE_PROP}
   */
  maxWidth: PropType<RawMenuMaxSize>;
  /**
   * Maximum height
   *
   * It is possible to set values that can be configured as CSS or dynamic sizes through callback functions.
   *
   * This setting is ignored if `allowOverflow` is enabled.
   *
   * @see {@link RAW_MENU_MAX_SIZE_PROP}
   */
  maxHeight: PropType<RawMenuMaxSize>;
  /**
   * Distance from the activator (in pixels).
   *
   * If a position setting, such as (left, right, top, bottom)-inner, is used, the distance is not applied to that axis.
   */
  distance: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Margin from the screen edge
   *
   * By default, it is controlled to ensure that the coordinates, subtracted by this margin from the screen edge, do not overflow.
   */
  edgeMargin: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Force margin at edge
   *
   * By default, even if `edgeMargin` is set, the activator may snap outside that margin. Enabling this option forces the component to always maintain the specified `edgeMargin` from the screen edge.
   */
  forceEdgeMargin: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * Overlap settings with the activator
   *
   * - `allow` | `false` Allow overlapping if display space is insufficient
   * - `disallow` Do not allow overlapping even when display space is insufficient.
   * - `overlap` | `true` Overlap on the activator
   *
   * If internal position settings like (left, right, top, bottom)-inner are used, this configuration does not apply to that axis.
   *
   * @see {@link MenuOverlapSettings}
   */
  overlap: {
    type: PropType<MenuOverlapSettings | boolean>;
    default: RawMenuOverlapSettings;
  };
  resizeWatchDebounce: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Hide when scrolling
   *
   * If a value is specified, the tooltip will be hidden after scrolling by the specified number of pixels (px).
   */
  hideOnScroll: {
    type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
    default: string | number | boolean;
  };
  /**
   * Hide the stack element when the activator is scrolled out of view.
   */
  hideOnInvisible: {
    type: BooleanConstructor;
    default: boolean;
  };
  'v-slots': PropType<{
    default?: ((control: VStackControl) => import("vue").VNodeChild) | undefined;
    activator?: ((payload: VStackActivatorPayload) => import("vue").VNodeChild) | undefined;
  }>;
  modelValue: BooleanConstructor;
  lazyBoot: BooleanConstructor;
  value: null;
  class: null;
  style: PropType<import("vue").StyleValue>;
  transition: {
    type: PropType<RawVStackObjectTransitionProp<string | import("@fastkit/vue-transitions").JavaScriptTransition>>;
    default: string;
  };
  alwaysRender: BooleanConstructor;
  backdrop: {
    type: PropType<boolean | string>;
    default: string | boolean;
  };
  focusTrap: {
    type: BooleanConstructor;
    default: boolean;
  };
  focusRestorable: {
    type: BooleanConstructor;
    default: boolean;
  };
  scrollLock: {
    type: BooleanConstructor;
    default: boolean;
  };
  openOnClick: {
    type: BooleanConstructor;
    default: undefined;
  };
  openOnHover: BooleanConstructor;
  openOnContextmenu: BooleanConstructor;
  openOnFocus: {
    type: BooleanConstructor;
    default: undefined;
  };
  openDelay: {
    type: PropType<string | number>;
    default: string | number;
  };
  closeDelay: {
    type: PropType<string | number>;
    default: string | number;
  };
  closeOnOutsideClick: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnEsc: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnTab: {
    type: PropType<StackableTabCloseSpec>;
    default: StackableTabCloseSpec;
  };
  closeOnNavigation: {
    type: BooleanConstructor;
    default: boolean;
  };
  persistent: {
    type: BooleanConstructor;
    default: boolean;
  };
  disabled: BooleanConstructor;
  zIndex: {
    type: PropType<string | number>;
    default: string | number;
  };
  timeout: {
    type: PropType<string | number>;
    default: string | number;
  };
  navigationGuard: {
    type: PropType<boolean | VStackNavigationGuard>;
    default: boolean;
  };
  guardEffect: {
    type: (BooleanConstructor | StringConstructor)[];
    default: boolean;
  };
  includeElements: PropType<() => Element[]>;
  activator: PropType<VStackActivatorQuery>;
  resolveHandler: PropType<StackableResolveHandler>;
  cancelHandler: PropType<StackableResolveHandler>;
  activatorAttrs: PropType<VStackActivatorAttrsSpec>;
} & Props & EmitsToPropOptions<{
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} extends {
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits ? {} : {
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits, string, import("vue").PublicProps, Readonly<import("vue").ComponentObjectPropsOptions<{
  [x: string]: unknown;
}> extends {
  /**
   * Horizontal Axis Position
   *
   * - `left` To the left of the activator.
   * - `left-inner` Align to the left edge of the activator.
   * - `center` Align to the center of the activator.
   * - `right` To the right of the activator.
   * - `right-inner` Align to the right edge of the activator.
   */
  x: PropType<VMenuXPosition>;
  /**
   * Vertical Axis Position
   *
   * - `top` To the top of the activator.
   * - `top-inner` Align to the top edge of the activator.
   * - `center` Align to the center of the activator.
   * - `bottom` To the bottom of the activator.
   * - `bottom-inner` Align to the bottom edge of the activator.
   */
  y: PropType<VMenuYPosition>;
  /**
   * Allow overflow from the screen.
   *
   * If this setting is not enabled, the element's size will be reduced when exceeding coordinates beyond the screen edge, subtracting the edge margin.
   */
  allowOverflow: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * width
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  width: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * height
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the height will match that of the activator.
   */
  height: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Minimum width
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  minWidth: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Minimum height
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  minHeight: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Maximum width
   *
   * It is possible to set values that can be configured as CSS or dynamic sizes through callback functions.
   *
   * This setting is ignored if `allowOverflow` is enabled.
   *
   * @see {@link RAW_MENU_MAX_SIZE_PROP}
   */
  maxWidth: PropType<RawMenuMaxSize>;
  /**
   * Maximum height
   *
   * It is possible to set values that can be configured as CSS or dynamic sizes through callback functions.
   *
   * This setting is ignored if `allowOverflow` is enabled.
   *
   * @see {@link RAW_MENU_MAX_SIZE_PROP}
   */
  maxHeight: PropType<RawMenuMaxSize>;
  /**
   * Distance from the activator (in pixels).
   *
   * If a position setting, such as (left, right, top, bottom)-inner, is used, the distance is not applied to that axis.
   */
  distance: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Margin from the screen edge
   *
   * By default, it is controlled to ensure that the coordinates, subtracted by this margin from the screen edge, do not overflow.
   */
  edgeMargin: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Force margin at edge
   *
   * By default, even if `edgeMargin` is set, the activator may snap outside that margin. Enabling this option forces the component to always maintain the specified `edgeMargin` from the screen edge.
   */
  forceEdgeMargin: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * Overlap settings with the activator
   *
   * - `allow` | `false` Allow overlapping if display space is insufficient
   * - `disallow` Do not allow overlapping even when display space is insufficient.
   * - `overlap` | `true` Overlap on the activator
   *
   * If internal position settings like (left, right, top, bottom)-inner are used, this configuration does not apply to that axis.
   *
   * @see {@link MenuOverlapSettings}
   */
  overlap: {
    type: PropType<MenuOverlapSettings | boolean>;
    default: RawMenuOverlapSettings;
  };
  resizeWatchDebounce: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Hide when scrolling
   *
   * If a value is specified, the tooltip will be hidden after scrolling by the specified number of pixels (px).
   */
  hideOnScroll: {
    type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
    default: string | number | boolean;
  };
  /**
   * Hide the stack element when the activator is scrolled out of view.
   */
  hideOnInvisible: {
    type: BooleanConstructor;
    default: boolean;
  };
  'v-slots': PropType<{
    default?: ((control: VStackControl) => import("vue").VNodeChild) | undefined;
    activator?: ((payload: VStackActivatorPayload) => import("vue").VNodeChild) | undefined;
  }>;
  modelValue: BooleanConstructor;
  lazyBoot: BooleanConstructor;
  value: null;
  class: null;
  style: PropType<import("vue").StyleValue>;
  transition: {
    type: PropType<RawVStackObjectTransitionProp<string | import("@fastkit/vue-transitions").JavaScriptTransition>>;
    default: string;
  };
  alwaysRender: BooleanConstructor;
  backdrop: {
    type: PropType<boolean | string>;
    default: string | boolean;
  };
  focusTrap: {
    type: BooleanConstructor;
    default: boolean;
  };
  focusRestorable: {
    type: BooleanConstructor;
    default: boolean;
  };
  scrollLock: {
    type: BooleanConstructor;
    default: boolean;
  };
  openOnClick: {
    type: BooleanConstructor;
    default: undefined;
  };
  openOnHover: BooleanConstructor;
  openOnContextmenu: BooleanConstructor;
  openOnFocus: {
    type: BooleanConstructor;
    default: undefined;
  };
  openDelay: {
    type: PropType<string | number>;
    default: string | number;
  };
  closeDelay: {
    type: PropType<string | number>;
    default: string | number;
  };
  closeOnOutsideClick: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnEsc: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnTab: {
    type: PropType<StackableTabCloseSpec>;
    default: StackableTabCloseSpec;
  };
  closeOnNavigation: {
    type: BooleanConstructor;
    default: boolean;
  };
  persistent: {
    type: BooleanConstructor;
    default: boolean;
  };
  disabled: BooleanConstructor;
  zIndex: {
    type: PropType<string | number>;
    default: string | number;
  };
  timeout: {
    type: PropType<string | number>;
    default: string | number;
  };
  navigationGuard: {
    type: PropType<boolean | VStackNavigationGuard>;
    default: boolean;
  };
  guardEffect: {
    type: (BooleanConstructor | StringConstructor)[];
    default: boolean;
  };
  includeElements: PropType<() => Element[]>;
  activator: PropType<VStackActivatorQuery>;
  resolveHandler: PropType<StackableResolveHandler>;
  cancelHandler: PropType<StackableResolveHandler>;
  activatorAttrs: PropType<VStackActivatorAttrsSpec>;
} & Props & EmitsToPropOptions<{
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits> ? {} : ExtractPropTypes<{
  /**
   * Horizontal Axis Position
   *
   * - `left` To the left of the activator.
   * - `left-inner` Align to the left edge of the activator.
   * - `center` Align to the center of the activator.
   * - `right` To the right of the activator.
   * - `right-inner` Align to the right edge of the activator.
   */
  x: PropType<VMenuXPosition>;
  /**
   * Vertical Axis Position
   *
   * - `top` To the top of the activator.
   * - `top-inner` Align to the top edge of the activator.
   * - `center` Align to the center of the activator.
   * - `bottom` To the bottom of the activator.
   * - `bottom-inner` Align to the bottom edge of the activator.
   */
  y: PropType<VMenuYPosition>;
  /**
   * Allow overflow from the screen.
   *
   * If this setting is not enabled, the element's size will be reduced when exceeding coordinates beyond the screen edge, subtracting the edge margin.
   */
  allowOverflow: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * width
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  width: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * height
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the height will match that of the activator.
   */
  height: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Minimum width
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  minWidth: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Minimum height
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  minHeight: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Maximum width
   *
   * It is possible to set values that can be configured as CSS or dynamic sizes through callback functions.
   *
   * This setting is ignored if `allowOverflow` is enabled.
   *
   * @see {@link RAW_MENU_MAX_SIZE_PROP}
   */
  maxWidth: PropType<RawMenuMaxSize>;
  /**
   * Maximum height
   *
   * It is possible to set values that can be configured as CSS or dynamic sizes through callback functions.
   *
   * This setting is ignored if `allowOverflow` is enabled.
   *
   * @see {@link RAW_MENU_MAX_SIZE_PROP}
   */
  maxHeight: PropType<RawMenuMaxSize>;
  /**
   * Distance from the activator (in pixels).
   *
   * If a position setting, such as (left, right, top, bottom)-inner, is used, the distance is not applied to that axis.
   */
  distance: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Margin from the screen edge
   *
   * By default, it is controlled to ensure that the coordinates, subtracted by this margin from the screen edge, do not overflow.
   */
  edgeMargin: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Force margin at edge
   *
   * By default, even if `edgeMargin` is set, the activator may snap outside that margin. Enabling this option forces the component to always maintain the specified `edgeMargin` from the screen edge.
   */
  forceEdgeMargin: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * Overlap settings with the activator
   *
   * - `allow` | `false` Allow overlapping if display space is insufficient
   * - `disallow` Do not allow overlapping even when display space is insufficient.
   * - `overlap` | `true` Overlap on the activator
   *
   * If internal position settings like (left, right, top, bottom)-inner are used, this configuration does not apply to that axis.
   *
   * @see {@link MenuOverlapSettings}
   */
  overlap: {
    type: PropType<MenuOverlapSettings | boolean>;
    default: RawMenuOverlapSettings;
  };
  resizeWatchDebounce: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Hide when scrolling
   *
   * If a value is specified, the tooltip will be hidden after scrolling by the specified number of pixels (px).
   */
  hideOnScroll: {
    type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
    default: string | number | boolean;
  };
  /**
   * Hide the stack element when the activator is scrolled out of view.
   */
  hideOnInvisible: {
    type: BooleanConstructor;
    default: boolean;
  };
  'v-slots': PropType<{
    default?: ((control: VStackControl) => import("vue").VNodeChild) | undefined;
    activator?: ((payload: VStackActivatorPayload) => import("vue").VNodeChild) | undefined;
  }>;
  modelValue: BooleanConstructor;
  lazyBoot: BooleanConstructor;
  value: null;
  class: null;
  style: PropType<import("vue").StyleValue>;
  transition: {
    type: PropType<RawVStackObjectTransitionProp<string | import("@fastkit/vue-transitions").JavaScriptTransition>>;
    default: string;
  };
  alwaysRender: BooleanConstructor;
  backdrop: {
    type: PropType<boolean | string>;
    default: string | boolean;
  };
  focusTrap: {
    type: BooleanConstructor;
    default: boolean;
  };
  focusRestorable: {
    type: BooleanConstructor;
    default: boolean;
  };
  scrollLock: {
    type: BooleanConstructor;
    default: boolean;
  };
  openOnClick: {
    type: BooleanConstructor;
    default: undefined;
  };
  openOnHover: BooleanConstructor;
  openOnContextmenu: BooleanConstructor;
  openOnFocus: {
    type: BooleanConstructor;
    default: undefined;
  };
  openDelay: {
    type: PropType<string | number>;
    default: string | number;
  };
  closeDelay: {
    type: PropType<string | number>;
    default: string | number;
  };
  closeOnOutsideClick: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnEsc: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnTab: {
    type: PropType<StackableTabCloseSpec>;
    default: StackableTabCloseSpec;
  };
  closeOnNavigation: {
    type: BooleanConstructor;
    default: boolean;
  };
  persistent: {
    type: BooleanConstructor;
    default: boolean;
  };
  disabled: BooleanConstructor;
  zIndex: {
    type: PropType<string | number>;
    default: string | number;
  };
  timeout: {
    type: PropType<string | number>;
    default: string | number;
  };
  navigationGuard: {
    type: PropType<boolean | VStackNavigationGuard>;
    default: boolean;
  };
  guardEffect: {
    type: (BooleanConstructor | StringConstructor)[];
    default: boolean;
  };
  includeElements: PropType<() => Element[]>;
  activator: PropType<VStackActivatorQuery>;
  resolveHandler: PropType<StackableResolveHandler>;
  cancelHandler: PropType<StackableResolveHandler>;
  activatorAttrs: PropType<VStackActivatorAttrsSpec>;
} & Props & EmitsToPropOptions<{
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits>>> & Readonly<import("vue").EmitsToProps<{} extends {
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits ? {} : {
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits>>, import("vue").ExtractDefaultPropTypes<{
  /**
   * Horizontal Axis Position
   *
   * - `left` To the left of the activator.
   * - `left-inner` Align to the left edge of the activator.
   * - `center` Align to the center of the activator.
   * - `right` To the right of the activator.
   * - `right-inner` Align to the right edge of the activator.
   */
  x: PropType<VMenuXPosition>;
  /**
   * Vertical Axis Position
   *
   * - `top` To the top of the activator.
   * - `top-inner` Align to the top edge of the activator.
   * - `center` Align to the center of the activator.
   * - `bottom` To the bottom of the activator.
   * - `bottom-inner` Align to the bottom edge of the activator.
   */
  y: PropType<VMenuYPosition>;
  /**
   * Allow overflow from the screen.
   *
   * If this setting is not enabled, the element's size will be reduced when exceeding coordinates beyond the screen edge, subtracting the edge margin.
   */
  allowOverflow: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * width
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  width: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * height
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the height will match that of the activator.
   */
  height: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Minimum width
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  minWidth: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Minimum height
   *
   * Either specify a pixel size or use "fit". When "fit" is chosen, the width will match that of the activator.
   */
  minHeight: {
    type: PropType<number | "fit" | "free">;
    default: undefined;
  };
  /**
   * Maximum width
   *
   * It is possible to set values that can be configured as CSS or dynamic sizes through callback functions.
   *
   * This setting is ignored if `allowOverflow` is enabled.
   *
   * @see {@link RAW_MENU_MAX_SIZE_PROP}
   */
  maxWidth: PropType<RawMenuMaxSize>;
  /**
   * Maximum height
   *
   * It is possible to set values that can be configured as CSS or dynamic sizes through callback functions.
   *
   * This setting is ignored if `allowOverflow` is enabled.
   *
   * @see {@link RAW_MENU_MAX_SIZE_PROP}
   */
  maxHeight: PropType<RawMenuMaxSize>;
  /**
   * Distance from the activator (in pixels).
   *
   * If a position setting, such as (left, right, top, bottom)-inner, is used, the distance is not applied to that axis.
   */
  distance: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Margin from the screen edge
   *
   * By default, it is controlled to ensure that the coordinates, subtracted by this margin from the screen edge, do not overflow.
   */
  edgeMargin: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Force margin at edge
   *
   * By default, even if `edgeMargin` is set, the activator may snap outside that margin. Enabling this option forces the component to always maintain the specified `edgeMargin` from the screen edge.
   */
  forceEdgeMargin: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * Overlap settings with the activator
   *
   * - `allow` | `false` Allow overlapping if display space is insufficient
   * - `disallow` Do not allow overlapping even when display space is insufficient.
   * - `overlap` | `true` Overlap on the activator
   *
   * If internal position settings like (left, right, top, bottom)-inner are used, this configuration does not apply to that axis.
   *
   * @see {@link MenuOverlapSettings}
   */
  overlap: {
    type: PropType<MenuOverlapSettings | boolean>;
    default: RawMenuOverlapSettings;
  };
  resizeWatchDebounce: {
    type: NumberConstructor;
    default: number;
  };
  /**
   * Hide when scrolling
   *
   * If a value is specified, the tooltip will be hidden after scrolling by the specified number of pixels (px).
   */
  hideOnScroll: {
    type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
    default: string | number | boolean;
  };
  /**
   * Hide the stack element when the activator is scrolled out of view.
   */
  hideOnInvisible: {
    type: BooleanConstructor;
    default: boolean;
  };
  'v-slots': PropType<{
    default?: ((control: VStackControl) => import("vue").VNodeChild) | undefined;
    activator?: ((payload: VStackActivatorPayload) => import("vue").VNodeChild) | undefined;
  }>;
  modelValue: BooleanConstructor;
  lazyBoot: BooleanConstructor;
  value: null;
  class: null;
  style: PropType<import("vue").StyleValue>;
  transition: {
    type: PropType<RawVStackObjectTransitionProp<string | import("@fastkit/vue-transitions").JavaScriptTransition>>;
    default: string;
  };
  alwaysRender: BooleanConstructor;
  backdrop: {
    type: PropType<boolean | string>;
    default: string | boolean;
  };
  focusTrap: {
    type: BooleanConstructor;
    default: boolean;
  };
  focusRestorable: {
    type: BooleanConstructor;
    default: boolean;
  };
  scrollLock: {
    type: BooleanConstructor;
    default: boolean;
  };
  openOnClick: {
    type: BooleanConstructor;
    default: undefined;
  };
  openOnHover: BooleanConstructor;
  openOnContextmenu: BooleanConstructor;
  openOnFocus: {
    type: BooleanConstructor;
    default: undefined;
  };
  openDelay: {
    type: PropType<string | number>;
    default: string | number;
  };
  closeDelay: {
    type: PropType<string | number>;
    default: string | number;
  };
  closeOnOutsideClick: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnEsc: {
    type: BooleanConstructor;
    default: boolean;
  };
  closeOnTab: {
    type: PropType<StackableTabCloseSpec>;
    default: StackableTabCloseSpec;
  };
  closeOnNavigation: {
    type: BooleanConstructor;
    default: boolean;
  };
  persistent: {
    type: BooleanConstructor;
    default: boolean;
  };
  disabled: BooleanConstructor;
  zIndex: {
    type: PropType<string | number>;
    default: string | number;
  };
  timeout: {
    type: PropType<string | number>;
    default: string | number;
  };
  navigationGuard: {
    type: PropType<boolean | VStackNavigationGuard>;
    default: boolean;
  };
  guardEffect: {
    type: (BooleanConstructor | StringConstructor)[];
    default: boolean;
  };
  includeElements: PropType<() => Element[]>;
  activator: PropType<VStackActivatorQuery>;
  resolveHandler: PropType<StackableResolveHandler>;
  cancelHandler: PropType<StackableResolveHandler>;
  activatorAttrs: PropType<VStackActivatorAttrsSpec>;
} & Props & EmitsToPropOptions<{
  'update:modelValue': (modelValue: boolean) => boolean;
  change: (modelValue: boolean) => boolean;
  payload: (value: any) => boolean;
  show: (control: VStackControl) => boolean;
  close: (control: VStackControl) => boolean;
  beforeEnter: (el: HTMLElement, control: VStackControl) => boolean;
  afterEnter: (el: HTMLElement, control: VStackControl) => boolean;
  enterCancelled: (el: HTMLElement, control: VStackControl) => boolean;
  beforeLeave: (el: HTMLElement, control: VStackControl) => boolean;
  afterLeave: (el: HTMLElement, control: VStackControl) => boolean;
  leaveCancelled: (el: HTMLElement, control: VStackControl) => boolean;
} & Emits>>, MergeStackBaseSlots<Slots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
//#endregion
export { BUILTIN_ACTION_HANDLERS, CreateStackablePropsOptions, DefaultContent, DefineDialogSettings, DefineMenuSettings, DefineSnackbarSettings, DefineStackableSettings, DynamicStackInternalSetting, DynamicStackPayload, DynamicStackResolver, DynamicStackSettings, EmitsToPropOptions, ExtractDynamicStackProps, ExtractDynamicStackSlots, MenuAPI, MenuEmits, MenuInput, MenuOverlapSettings, MenuPropsOptions, MergeStackBaseSlots, RawVStackObjectTransitionProp, StackableCloseReason, StackableComponent, StackableEmits, StackableLauncher, StackablePropsOptions, StackableResolveHandler, StackableSetupContext, StackableTabCloseSetting, StackableTabCloseSpec, UseStackActionOptions, UseStackControlOptions, VDynamicStacks, VMenuRect, VMenuRectInfo, VMenuState, VMenuXPosition, VMenuYPosition, VStackAction, VStackActionContext, VStackActionControl, VStackActionFn, VStackActionProps, VStackActivatorAttributes, VStackActivatorAttrsFn, VStackActivatorAttrsObject, VStackActivatorAttrsSpec, VStackActivatorPayload, VStackActivatorQuery, VStackBuiltinAction, VStackBuiltinActionContext, VStackBuiltinActionType, VStackBuiltinActions, VStackCloseOptions, VStackCloseReason, VStackControl, VStackControlState, VStackNavigationGuard, VStackObjectTransitionProp, VStackProps, VStackSetupContext, VStackSlots, V_STACK_SLOTS, VueStackInjectionKey, VueStackPlugin, VueStackService, VueStackServiceOptions, createMenuProps, createStackActionProps, createStackableDefine, createStackableProps, defineDialogComponent, defineMenuComponent, defineSnackbarComponent, installVueStackPlugin, isStackControl, resolveDynamicStackSettings, setupStackableComponent, stackableEmits, useStackAction, useStackControl, useVueStack };