import type { ReactiveController, ReactiveControllerHost } from "./ReactiveController.ts";
type ReactiveControllerHostAdapterHooks = {
    /**
     * A callback that performs an update of the adapted element or component.
     *
     * @remarks
     *
     * To clarify, this is not the same as `requestUpdate` which is synchronous,
     * and may not perform an update.
     *
     * In contrast, this callback should always perform an update,
     * and it may return a promise that resolves when the update is complete.
     *
     * @internal scope: workspace
     */
    performUpdate(): void | Promise<void>;
};
/**
 * A private symbol used to store the `updateComplete` promise
 */
declare const _updateComplete: unique symbol;
/**
 * A class that adapts a `ReactiveControllerHost` to a view.
 *
 * @alpha This is an experimental API and will change in the future.
 */
export declare class ReactiveControllerHostAdapter implements ReactiveControllerHost {
    #private;
    debug: boolean;
    debugLog(...args: any[]): void;
    /**
     * @see updateComplete
     *
     * @internal scope: package
     */
    private [_updateComplete];
    /**
     * A promise of a boolean that indicates if the update resolved without triggering another update.
     * This behavior is for compatibility with Lit's `ReactiveControllerHost` interface.
     *
     * @see {@link ReactiveControllerHost['updateComplete']}
     * @see {@link https://lit.dev/docs/components/lifecycle/#updatecomplete}
     *
     * @public
     */
    get updateComplete(): Promise<boolean>;
    constructor(hooks: ReactiveControllerHostAdapterHooks);
    performPendingUpdate(): Promise<void>;
    /**
     * Adds a controller to the host.
     *
     * @remarks
     *
     * This method is idempotent.
     * The same controller instance can't be added multiple times.
     *
     * @public
     */
    addController(controller: ReactiveController): void;
    /**
     * Removes a controller from the host.
     *
     * @remarks
     *
     * This method is idempotent.
     *
     * @public
     */
    removeController(controller: ReactiveController): void;
    /**
     * Removes all registered controllers from the host.
     *
     * @remarks
     *
     * This is useful for cleaning up all controllers at once,
     * for example when the host is being destroyed or reset.
     *
     * This method is used during hot module replacement.
     *
     * @internal scope: workspace
     */
    clearControllers(): void;
    /**
     * Called when the host is connected to the DOM.
     *
     * @see https://developer.mozilla.org/en-US/docs/Web/API/Web_components/Using_custom_elements
     *
     * @public
     */
    connectedCallback(): void;
    /**
     * Called when the host will update.
     *
     * @remarks
     *
     * These are non-standard methods, but were added for
     * consistency with the `connectedCallback` and `disconnectedCallback`
     * methods.
     *
     * @public
     */
    updateCallback(): void;
    /**
     * Called when the host has updated.
     *
     * @remarks
     *
     * These are non-standard methods, but were added for
     * consistency with the `connectedCallback` and `disconnectedCallback`
     * methods.
     *
     * @public
     */
    updatedCallback(): void;
    /**
     * Called when the host is disconnected from the DOM.
     */
    disconnectedCallback(): void;
    /**
     * This method is called when the host is requested to update,
     * by an external source.
     *
     * @public
     */
    requestUpdate(): void;
    /**
     * @internal scope: test
     */
    _getReactiveControllers(): ReactiveController[];
}
export {};
//# sourceMappingURL=ReactiveControllerHostAdapter.d.ts.map