import { Duration, Effect, Option, Schema as S } from 'effect';
import * as Command from 'foldkit/command';
import { type ChildAttribute, type Html } from 'foldkit/html';
import * as Mount from 'foldkit/mount';
import { type Reflect } from 'foldkit/submodel';
import * as Update from 'foldkit/update';
import { AnchorConfig } from '../anchor/index.js';
import { Message, OutMessage } from './message.js';
/** Schema for the tooltip component's state. `isOpen` is visibility; `isHovered` tracks pointer on trigger; `isFocused` tracks tooltip-affirming focus on the trigger (focus arriving without a preceding mouse press, like keyboard, touch, or pen; mouse-click-induced focus is excluded since it doesn't affirm the user wants the tooltip visible); `isDismissed` suppresses re-opening after the user dismissed the tooltip (via Escape) until they disengage (leave or blur). `showDelay` is the hover-to-show duration. `maybeLastPointerType` records the most recent pointer type that pressed the trigger, so a mouse-click-induced focus can be distinguished from other focus. */
export declare const Model: S.Struct<{
    readonly id: S.String;
    readonly isOpen: S.Boolean;
    readonly isHovered: S.Boolean;
    readonly isFocused: S.Boolean;
    readonly isDismissed: S.Boolean;
    readonly showDelay: S.DurationFromMillis;
    readonly pendingShowVersion: S.Number;
    readonly maybeLastPointerType: S.Option<S.String>;
}>;
export type Model = typeof Model.Type;
/** Returns the bare DOM id of the tooltip trigger button, derived from the
 *  tooltip's base id. Use this to associate an external label with the
 *  trigger via a native `<label for={Tooltip.triggerId(id)}>` or an
 *  `aria-labelledby` reference. */
export declare const triggerId: (id: string) => string;
/** Configuration for creating a tooltip model with `init`. */
export type InitConfig = Readonly<{
    id: string;
    showDelay?: Duration.Input;
}>;
/** Creates an initial tooltip model from a config. Defaults to hidden. */
export declare const init: (config: InitConfig) => Model;
/** Waits for the tooltip's show delay before emitting
 *  `CompletedWaitBeforeShowing`. */
export declare const WaitBeforeShowing: Command.CommandDefinitionWithArgs<"WaitBeforeShowing", {
    delay: S.DurationFromMillis;
    version: S.Number;
}, Effect.Effect<{
    readonly _tag: "CompletedWaitBeforeShowing";
    readonly version: number;
}, never, never>>;
/** The anchor-positioning Mount this Tooltip renders on its panel. */
export declare const AnchorTooltip: Mount.MountDefinitionWithArgs<"AnchorTooltip", {
    buttonId: S.String;
    anchor: S.Struct<{
        readonly placement: S.optional<S.Literals<readonly ["top", "right", "bottom", "left", "top-start", "top-end", "right-start", "right-end", "bottom-start", "bottom-end", "left-start", "left-end"]>>;
        readonly gap: S.optional<S.Number>;
        readonly offset: S.optional<S.Number>;
        readonly padding: S.optional<S.Union<readonly [S.Number, S.Struct<{
            readonly top: S.optionalKey<S.Number>;
            readonly right: S.optionalKey<S.Number>;
            readonly bottom: S.optionalKey<S.Number>;
            readonly left: S.optionalKey<S.Number>;
        }>]>>;
        readonly portal: S.optional<S.Boolean>;
        readonly isPlacementLocked: S.optional<S.Boolean>;
    }>;
}, {
    readonly _tag: "CompletedAnchorTooltip";
}>;
/** Processes a Tooltip Message and returns the next Model, optional Commands,
 *  and an optional OutMessage. `Shown`/`Hidden` fire only on `isOpen`
 *  transitions, so consumers don't get spurious events for messages that
 *  only update hover/focus/delay state without changing visibility. */
export declare const update: (model: Model, message: Message) => Update.ReturnWithOutMessage<Model, Message, OutMessage>;
/** Reflects an externally-sourced hover show-delay onto the Model without
 *  emitting an OutMessage. Use to mirror an external config value (a user
 *  preference, a restored setting) onto the tooltip. */
export declare const reflectShowDelay: Reflect<Model, Duration.Input>;
/** Render-time payload published to the consumer's `toView`.
 *
 *  - `trigger`: attribute bundle for the trigger element. Carries the
 *    hover/focus/keyboard handlers + ARIA `aria-describedby` linking to
 *    the panel.
 *  - `panel`: attribute bundle for the panel element. Carries the
 *    `role="tooltip"`, the anchor Mount that positions the panel via
 *    Floating UI, and a `data-open` attribute when visible.
 *  - `isVisible`: derived state. The consumer decides whether to render
 *    the panel conditionally on this. */
export type RenderInfo = Readonly<{
    trigger: ReadonlyArray<ChildAttribute>;
    panel: ReadonlyArray<ChildAttribute>;
    isVisible: boolean;
}>;
/** Per-render view inputs passed to `view` via `h.submodel`'s `viewInputs` field. */
export type ViewInputs = Readonly<{
    anchor: AnchorConfig;
    toView: (render: RenderInfo) => Html;
    isDisabled?: boolean;
    ariaLabel?: string;
    ariaLabelledBy?: string;
}>;
/** Renders a headless tooltip with an anchored non-interactive panel.
 *  Shows on hover (after delay) or focus (from keyboard, touch, or pen;
 *  mouse-click focus is excluded). Hides on leave, blur, or Escape. */
export declare const view: import("foldkit/submodel").View<{
    readonly id: string;
    readonly isOpen: boolean;
    readonly isHovered: boolean;
    readonly isFocused: boolean;
    readonly isDismissed: boolean;
    readonly showDelay: Duration.Duration;
    readonly pendingShowVersion: number;
    readonly maybeLastPointerType: Option.Option<string>;
}, {
    readonly _tag: "EnteredTrigger";
} | {
    readonly _tag: "LeftTrigger";
} | {
    readonly _tag: "FocusedTrigger";
} | {
    readonly _tag: "BlurredTrigger";
} | {
    readonly _tag: "PressedEscape";
} | {
    readonly _tag: "PressedPointerOnTrigger";
    readonly pointerType: string;
} | {
    readonly _tag: "CompletedWaitBeforeShowing";
    readonly version: number;
} | {
    readonly _tag: "CompletedAnchorTooltip";
}, Readonly<{
    anchor: AnchorConfig;
    toView: (render: RenderInfo) => Html;
    isDisabled?: boolean;
    ariaLabel?: string;
    ariaLabelledBy?: string;
}>>;
//# sourceMappingURL=tooltip.d.ts.map