@popperjs/core

const afterMain: string;

const afterRead: string;

const afterWrite: string;

const applyStyles: ApplyStylesModifier;

const arrow: ArrowModifier;

const auto: string;

const basePlacements: BasePlacement[];

const beforeMain: string;

const beforeRead: string;

const beforeWrite: string;

const bottom: string;

const clippingParents: string;

const computeStyles: ComputeStylesModifier;

const end: string;

const eventListeners: EventListenersModifier;

const flip: FlipModifier;

const hide: HideModifier;

const left: string;

const main: string;

const modifierPhases: ModifierPhases[];

const offset: OffsetModifier;

const placements: Placement[];

const popper: string;

const popperOffsets: PopperOffsetsModifier;

const preventOverflow: PreventOverflowModifier;

const read: string;

const reference: string;

const right: string;

const start: string;

const top: string;

const variationPlacements: VariationPlacement[];

const viewport: string;

const write: string;

createPopper: <TModifier extends Partial<Modifier<any, any>>>(
    reference: Element | import('./types').VirtualElement,
    popper: HTMLElement,
    options?: Partial<OptionsGeneric<TModifier>>
) => import('./types').Instance;

createPopperBase: <TModifier extends Partial<Modifier<any, any>>>(
    reference: Element | VirtualElement,
    popper: HTMLElement,
    options?: Partial<OptionsGeneric<TModifier>>
) => Instance;

createPopperLite: <TModifier extends Partial<Modifier<any, any>>>(
    reference: Element | import('./types').VirtualElement,
    popper: HTMLElement,
    options?: Partial<OptionsGeneric<TModifier>>
) => import('./types').Instance;

detectOverflow: (state: State, options?: Partial<Options>) => SideObject;

popperGenerator: (
    generatorOptions?: PopperGeneratorArgs
) => <TModifier extends Partial<Modifier<any, any>>>(
    reference: Element | VirtualElement,
    popper: HTMLElement,
    options?: Partial<OptionsGeneric<TModifier>>
) => Instance;

type AutoPlacement = 'auto' | 'auto-start' | 'auto-end';

type BasePlacement = typeof top | typeof bottom | typeof right | typeof left;

type Boundary = Element | Array<Element> | typeof clippingParents;

type ClientRectObject = {
    x: number;
    y: number;
    top: number;
    left: number;
    right: number;
    bottom: number;
    width: number;
    height: number;
};

type ComputedPlacement = VariationPlacement | BasePlacement;

type Context = typeof popper | typeof reference;

type EventListeners = {
    scroll: boolean;
    resize: boolean;
};

type Instance = {
    state: State;
    destroy: () => void;
    forceUpdate: () => void;
    update: () => Promise<Partial<State>>;
    setOptions: (
        setOptionsAction: SetAction<Partial<OptionsGeneric<any>>>
    ) => Promise<Partial<State>>;
};

type Modifier<Name, Options extends Obj> = {
    name: Name;
    enabled: boolean;
    phase: ModifierPhases;
    requires?: Array<string>;
    requiresIfExists?: Array<string>;
    fn: (arg0: ModifierArguments<Options>) => State | void;
    effect?: (arg0: ModifierArguments<Options>) => (() => void) | void;
    options?: Partial<Options>;
    data?: Obj;
};

type ModifierArguments<Options extends Obj> = {
    state: State;
    instance: Instance;
    options: Partial<Options>;
    name: string;
};

type ModifierPhases =
    | typeof beforeRead
    | typeof read
    | typeof afterRead
    | typeof beforeMain
    | typeof main
    | typeof afterMain
    | typeof beforeWrite
    | typeof write
    | typeof afterWrite;

type Obj = {
    [key: string]: any;
};

type Offsets = {
    y: number;
    x: number;
};

type Options = {
    placement: Placement;
    modifiers: Array<Partial<Modifier<any, any>>>;
    strategy: PositioningStrategy;
    onFirstUpdate?: (arg0: Partial<State>) => void;
};

type OptionsGeneric<TModifier> = {
    placement: Placement;
    modifiers: Array<TModifier>;
    strategy: PositioningStrategy;
    onFirstUpdate?: (arg0: Partial<State>) => void;
};

type Padding = number | Partial<SideObject>;

type Placement = AutoPlacement | BasePlacement | VariationPlacement;

type PositioningStrategy = 'absolute' | 'fixed';

type Rect = {
    width: number;
    height: number;
    x: number;
    y: number;
};

type RootBoundary = typeof viewport | 'document';

type SideObject = {
    top: number;
    left: number;
    right: number;
    bottom: number;
};

type State = {
    elements: {
        reference: Element | VirtualElement;
        popper: HTMLElement;
        arrow?: HTMLElement;
    };
    options: OptionsGeneric<any>;
    placement: Placement;
    strategy: PositioningStrategy;
    orderedModifiers: Array<Modifier<any, any>>;
    rects: StateRects;
    scrollParents: {
        reference: Array<Element | Window | VisualViewport>;
        popper: Array<Element | Window | VisualViewport>;
    };
    styles: {
        [key: string]: Partial<CSSStyleDeclaration>;
    };
    attributes: {
        [key: string]: {
            [key: string]: string | boolean;
        };
    };
    modifiersData: {
        arrow?: {
            x?: number;
            y?: number;
            centerOffset: number;
        };
        hide?: {
            isReferenceHidden: boolean;
            hasPopperEscaped: boolean;
            referenceClippingOffsets: SideObject;
            popperEscapeOffsets: SideObject;
        };
        offset?: OffsetData;
        preventOverflow?: Offsets;
        popperOffsets?: Offsets;
        [key: string]: any;
    };
    reset: boolean;
};

type StateOffsets = {
    popper: Offsets;
    arrow?: Offsets;
};

type StateRects = {
    reference: Rect;
    popper: Rect;
};

type StrictModifiers =
    | Partial<OffsetModifier>
    | Partial<ApplyStylesModifier>
    | Partial<ArrowModifier>
    | Partial<HideModifier>
    | Partial<ComputeStylesModifier>
    | Partial<EventListenersModifier>
    | Partial<FlipModifier>
    | Partial<PreventOverflowModifier>
    | Partial<PopperOffsetsModifier>;

type UpdateCallback = (arg0: State) => void;

type Variation = typeof start | typeof end;

type VariationPlacement =
    | 'top-start'
    | 'top-end'
    | 'bottom-start'
    | 'bottom-end'
    | 'right-start'
    | 'right-end'
    | 'left-start'
    | 'left-end';

type VirtualElement = {
    getBoundingClientRect: () => ClientRect | DOMRect;
    contextElement?: Element;
};

type VisualViewport = EventTarget & {
    width: number;
    height: number;
    offsetLeft: number;
    offsetTop: number;
    scale: number;
};

type Window = {
    innerHeight: number;
    offsetHeight: number;
    innerWidth: number;
    offsetWidth: number;
    pageXOffset: number;
    pageYOffset: number;
    getComputedStyle: typeof getComputedStyle;
    addEventListener(type: any, listener: any, optionsOrUseCapture?: any): void;
    removeEventListener(type: any, listener: any, optionsOrUseCapture?: any): void;
    Element: Element;
    HTMLElement: HTMLElement;
    Node: Node;
    toString(): '[object Window]';
    devicePixelRatio: number;
    visualViewport?: VisualViewport;
    ShadowRoot: ShadowRoot;
};