import type { Observable } from "rxjs";
import type { BeEvent, IDisposable } from "@itwin/core-bentley";
import type { HierarchyNode } from "@itwin/presentation-hierarchies-react";
import type { TreeCheckboxProps } from "./components/TreeNodeCheckbox.js";
/**
 * Data structure that describes instance visibility status.
 * @beta
 */
export interface VisibilityStatus {
    /** Instance visibility state. */
    state: "visible" | "partial" | "hidden";
    /** Specifies whether visibility changing is disabled or not. */
    isDisabled?: boolean;
    /** Tooltip that should be displayed when hovering over the visibility checkbox. */
    tooltip?: string;
}
/**
 * Handler that can be used to determine and change visibility of instances represented by tree nodes.
 * @beta
 */
export interface HierarchyVisibilityHandler extends IDisposable {
    /** Event used to notify tree about visibility changes from outside. */
    readonly onVisibilityChange: BeEvent<() => void>;
    /** Returns current visibility status for tree node. */
    getVisibilityStatus(node: HierarchyNode): Promise<VisibilityStatus> | VisibilityStatus;
    /** Changes visibility of the instance represented by tree node. */
    changeVisibility(node: HierarchyNode, on: boolean): Promise<void>;
}
interface UseHierarchyVisibilityProps {
    visibilityHandlerFactory: () => HierarchyVisibilityHandler;
}
export declare function useHierarchyVisibility({ visibilityHandlerFactory }: UseHierarchyVisibilityProps): TreeCheckboxProps & {
    triggerRefresh: () => void;
};
/**
 * Properties for an overridden method of a `HierarchyVisibilityHandler` implementation.
 * @beta
 */
export type HierarchyVisibilityHandlerOverridableMethodProps<TFunc> = TFunc extends (props: infer TProps) => infer TResult ? TProps & {
    /** A callback that produces the value from the original implementation. */
    readonly originalImplementation: () => TResult;
    /**
     * Reference to the hierarchy based handler.
     * @note Calling `getVisibility` or `changeVisibility` of this object invokes the overridden implementation as well.
     */
    readonly handler: HierarchyVisibilityHandler;
} : never;
/**
 * Function type for an overridden method of `HierarchyVisibilityHandler`.
 * @beta
 */
export type HierarchyVisibilityHandlerOverridableMethod<TFunc> = TFunc extends (...args: any[]) => infer TResult ? (props: HierarchyVisibilityHandlerOverridableMethodProps<TFunc>) => TResult : never;
export declare function createVisibilityHandlerResult<TResult, TOverrideProps>(handler: HierarchyVisibilityHandler, props: TOverrideProps, obs: Observable<TResult>, override: HierarchyVisibilityHandlerOverridableMethod<(props: TOverrideProps) => Promise<TResult>> | undefined): Observable<TResult>;
export {};
//# sourceMappingURL=UseHierarchyVisibility.d.ts.map