export type BaseAttributes = {
    trigger?: string;
    content?: string;
    swap?: string;
};
/**
 * Each element in the library extends the `Base` class. It provides methods
 * for selecting elements via HTML attributes along with other helpers.
 *
 * By default, `trigger`s and `content` will be selected via the `data-trigger` and
 * `data-content` attributes. Alternatively, you can set the `trigger` or
 * `content` attribute to a CSS selector to change the default selector from
 * `[data-trigger]` or `[data-content]` to a selector of your choosing.
 * This can be useful if you have multiple elements within one another.
 *
 * Each element can have multiple `trigger`s, but will only have one `content`.
 */
export declare class Base extends HTMLElement {
    #private;
    constructor();
    /**
     * Event for the `trigger` to execute.
     *
     * For example, set to `"mouseover"` to execute the event when the user hovers the mouse over the `trigger`, instead of when they click it.
     *
     * @default "click"
     */
    get event(): keyof HTMLElementEventMap;
    set event(value: keyof HTMLElementEventMap);
    /**
     * @param message message to announce to screen readers
     */
    announce(message: string): void;
    /**
     * @returns All of the elements that match the `trigger` selector.
     * @default this.querySelectorAll("[data-trigger]")
     */
    getTrigger<T extends HTMLElement = HTMLElement>(): NodeListOf<T>;
    /**
     * @param instance The instance of the desired element to validate against,
     * ex: `HTMLDialogElement`. Defaults to `HTMLElement`.
     * @returns The element that matches the `content` selector.
     * @default this.querySelector("[data-content]")
     */
    getContent<T extends HTMLElement = HTMLElement>(instance?: {
        new (): T;
    }): T;
    /**
     * Finds the `HTMLElement | HTMLTemplateElement` via the `swap` selector and
     * swaps `this.content()` with the content of the element found.
     *
     * @param revert Wait time (ms) before swapping back, set to `false` to not revert.
     * default: `800`
     */
    swapContent(revert?: number | false): void;
    /**
     * Wrapper around `document.body.addEventListener` that ensures when the
     * element is removed from the DOM, these event listeners are cleaned up.
     * @param type
     * @param listener
     * @param options
     */
    safeListener<K extends keyof DocumentEventMap, T extends HTMLElement | Window | Document = HTMLElement>(type: K, listener: (this: T, ev: DocumentEventMap[K]) => any, element?: T, options?: AddEventListenerOptions): void;
    /**
     * @param listener Listener to attach to all of the `trigger` elements.
     */
    triggerListener<T extends HTMLElement, K extends keyof HTMLElementEventMap>(listener: (this: T, e: HTMLElementEventMap[K]) => any, type?: K, options?: AddEventListenerOptions): void;
    /**
     * Passed into `queueMicrotask` in `connectedCallback`. It is overridden in each component that needs to run `connectedCallback`.
     *
     * The reason for this is to make these elements work better with frameworks like Svelte. For SSR this isn't necessary, but when client side rendering, the HTML within the custom element isn't available before `connectedCallback` is called. By waiting until the next microtask, the HTML content is available---then for example, listeners can be attached to elements inside.
     */
    mount(): void;
    /** Called when custom element is added to the page. */
    connectedCallback(): void;
    /**
     * Passed into `disconnectedCallback`, since `Base` needs to run `disconnectedCallback` as well. It is overridden in each element that needs to run `disconnectedCallback`.
     */
    destroy(): void;
    /** Called when custom element is removed from the page. */
    disconnectedCallback(): void;
}