import type { Measurable } from '@oku-ui/utils';
import type { PropType, Ref } from 'vue';
import type { Scope } from '@oku-ui/provide';
import type { OkuElement, PrimitiveProps } from '@oku-ui/primitive';
import type { Padding } from '@floating-ui/vue';
import type { ArrowElement, ArrowNaviteElement, ArrowProps } from '@oku-ui/arrow';
import type { Align, Side } from './utils';
export type ScopePopper<T> = T & {
    scopeOkuPopper?: Scope;
};
export declare const scopePopperProps: {
    scopeOkuPopper: {
        type: PropType<Scope<any>>;
        required: boolean;
    };
};
export declare const POPPER_NAME = "OkuPopper";
export declare const ARROW_NAME = "OkuPopperArrow";
export declare const CONTENT_NAME = "OkuPopperContent";
export declare const ANCHOR_NAME = "OkuPopperAnchor";
export declare const createPopperProvider: <ProvideValueType extends object | null>(rootComponentName: string, defaultValue?: ProvideValueType | undefined) => readonly [(props: ProvideValueType & {
    scope: Scope<ProvideValueType>;
}) => void, (consumerName: string, scope: Scope<ProvideValueType | undefined>) => ProvideValueType], createPopperScope: import("@oku-ui/provide/dist/createProvide").CreateScope;
export type PopperProvideValue = {
    anchor: Ref<Measurable | null>;
    onAnchorChange(anchor: Measurable | null): void;
};
export declare const popperProvider: (props: PopperProvideValue & {
    scope: Scope<PopperProvideValue>;
}) => void, usePopperInject: (consumerName: string, scope: Scope<PopperProvideValue | undefined>) => PopperProvideValue;
export interface PopperProps {
}
export type PopperAnchorNaviteElement = OkuElement<'div'>;
export type PopperAnchorElement = HTMLDivElement;
export interface PopperAnchorProps extends PrimitiveProps {
    virtualRef?: Ref<Measurable | null>;
}
export declare const popperAnchorProps: {
    props: {
        asChild: BooleanConstructor;
        virtualRef: {
            type: PropType<Measurable | null>;
            required: boolean;
            default: undefined;
        };
    };
    emits: {};
};
type PopperContentContextValue = {
    placedSide: Ref<Side | undefined>;
    onArrowChange(arrow: HTMLSpanElement | null): void;
    arrowX?: Ref<number | undefined>;
    arrowY?: Ref<number | undefined>;
    shouldHideArrow: Ref<boolean | undefined>;
};
export declare const popperContentProvider: (props: PopperContentContextValue & {
    scope: Scope<PopperContentContextValue>;
}) => void, usePopperContentInject: (consumerName: string, scope: Scope<PopperContentContextValue | undefined>) => PopperContentContextValue;
type Boundary = Element | null;
export type PopperContentNaviteElement = OkuElement<'div'>;
export type PopperContentElement = HTMLDivElement;
export interface PopperContentProps extends PrimitiveProps {
    side?: Side;
    sideOffset?: number;
    align?: Align;
    alignOffset?: number;
    arrowPadding?: number;
    avoidCollisions?: boolean;
    collisionBoundary?: Boundary | Boundary[];
    collisionPadding?: Padding;
    sticky?: 'partial' | 'always';
    hideWhenDetached?: boolean;
    updatePositionStrategy?: 'optimized' | 'always';
}
export type PopperContentEmits = {
    placed: [void];
};
export declare const popperContentProps: {
    props: {
        side: {
            type: PropType<"top" | "right" | "bottom" | "left">;
            required: boolean;
            default: string;
            validator: (value: Side) => boolean;
        };
        sideOffset: {
            type: NumberConstructor;
            required: boolean;
            default: number;
        };
        align: {
            type: PropType<"start" | "center" | "end">;
            required: boolean;
            default: string;
            validator: (value: Align) => boolean;
        };
        alignOffset: {
            type: NumberConstructor;
            required: boolean;
            default: number;
        };
        arrowPadding: {
            type: NumberConstructor;
            required: boolean;
            default: number;
        };
        avoidCollisions: {
            type: BooleanConstructor;
            required: boolean;
            default: boolean;
        };
        collisionBoundary: {
            type: PropType<Boundary | Boundary[]>;
            required: boolean;
            default: () => never[];
        };
        collisionPadding: {
            type: PropType<Padding>;
            required: boolean;
            default: number;
        };
        sticky: {
            type: PropType<"partial" | "always">;
            required: boolean;
            default: string;
        };
        hideWhenDetached: {
            type: BooleanConstructor;
            required: boolean;
            default: boolean;
        };
        updatePositionStrategy: {
            type: PropType<"always" | "optimized">;
            required: boolean;
            default: string;
        };
        layoutShift: {
            type: BooleanConstructor;
            required: boolean;
            default: boolean;
        };
        dir: {
            type: PropType<"ltr" | "rtl">;
        };
    };
    emits: {
        placed: () => boolean;
    };
};
export declare const OPPOSITE_SIDE: Record<Side, Side>;
export type PopperArrowNaviteElement = ArrowNaviteElement;
export type PopperArrowElement = ArrowElement;
export interface PopperArrowProps extends ArrowProps {
}
export declare const popperArrowProps: {
    props: {
        asChild: BooleanConstructor;
        width: {
            type: PropType<number>;
            default: number;
        };
        height: {
            type: PropType<number>;
            default: number;
        };
    };
    emits: {};
};
export {};