import '../../../assert/js/assert.js';
import '../../../tandem/js/PhetioIDUtils.js';
import '../../../globals.js';
import Bounds2 from '../../../dot/js/Bounds2.js';
import Transform3 from '../../../dot/js/Transform3.js';
import Vector2 from '../../../dot/js/Vector2.js';
import { AllDragListenerOptions, KeyboardListener, KeyboardListenerOptions, Node, OneKeyStroke, SceneryEvent, SceneryListenerCallback, SceneryListenerNullableCallback } from '../imports.js';
import TProperty from '../../../axon/js/TProperty.js';
import TReadOnlyProperty from '../../../axon/js/TReadOnlyProperty.js';
import { PhetioObjectOptions } from '../../../tandem/js/PhetioObject.js';
import PickOptional from '../../../phet-core/js/types/PickOptional.js';
import StrictOmit from '../../../phet-core/js/types/StrictOmit.js';
import { EnabledComponentOptions } from '../../../axon/js/EnabledComponent.js';
declare const keyboardDraggingKeys: readonly ["arrowLeft", "arrowRight", "arrowUp", "arrowDown", "w", "a", "s", "d"];
declare const leftRightKeys: readonly ["arrowLeft", "arrowRight", "a", "d"];
declare const upDownKeys: readonly ["arrowUp", "arrowDown", "w", "s"];
type KeyboardDragListenerKeyStroke = typeof keyboardDraggingKeys | typeof leftRightKeys | typeof upDownKeys;
type KeyboardDragDirection = 'both' | 'leftRight' | 'upDown';
export declare const KeyboardDragDirectionToKeyStringPropertiesMap: Map<KeyboardDragDirection, TProperty<OneKeyStroke>[]>;
export type KeyboardDragListenerDOMEvent = KeyboardEvent;
export type KeyboardDragListenerCallback<Listener extends KeyboardDragListener = KeyboardDragListener> = SceneryListenerCallback<Listener, KeyboardDragListenerDOMEvent>;
export type KeyboardDragListenerNullableCallback<Listener extends KeyboardDragListener = KeyboardDragListener> = SceneryListenerNullableCallback<Listener, KeyboardDragListenerDOMEvent>;
type SelfOptions<Listener extends KeyboardDragListener> = {
    dragDelta?: number;
    shiftDragDelta?: number;
    dragSpeed?: number;
    shiftDragSpeed?: number;
    keyboardDragDirection?: KeyboardDragDirection;
    moveOnHoldDelay?: number;
    moveOnHoldInterval?: number;
} & AllDragListenerOptions<Listener, KeyboardDragListenerDOMEvent> & Pick<PhetioObjectOptions, 'tandem' | 'phetioReadOnly'>;
type ParentOptions = StrictOmit<KeyboardListenerOptions<KeyboardDragListenerKeyStroke>, 'keys'>;
export type KeyboardDragListenerOptions = SelfOptions<KeyboardDragListener> & // Options specific to this class
PickOptional<ParentOptions, 'focus' | 'blur'> & // Only focus/blur are optional from the superclass
EnabledComponentOptions;
declare class KeyboardDragListener extends KeyboardListener<KeyboardDragListenerKeyStroke> {
    private readonly _start;
    private readonly _drag;
    private readonly _end;
    private _dragBoundsProperty;
    private readonly _mapPosition;
    private readonly _translateNode;
    private _transform;
    private readonly _positionProperty;
    private _dragSpeed;
    private _shiftDragSpeed;
    private _dragDelta;
    private _shiftDragDelta;
    private readonly _moveOnHoldDelay;
    private leftKeyDownProperty;
    private rightKeyDownProperty;
    private upKeyDownProperty;
    private downKeyDownProperty;
    private dragStartAction;
    private dragEndAction;
    private dragAction;
    private startNextKeyboardEvent;
    private restartTimerNextKeyboardEvent;
    private readonly _disposeKeyboardDragListener;
    private readonly _pointerListener;
    private _pointer;
    private readonly useDragSpeed;
    modelDelta: Vector2;
    modelPoint: Vector2;
    private vectorDelta;
    private readonly callbackTimer;
    private readonly boundStepListener;
    constructor(providedOptions?: KeyboardDragListenerOptions);
    /**
     * Calculates a delta for movement from the time step. Only used for `dragSpeed`. This is bound and added to
     * the stepTimer when dragging starts.
     */
    private stepForSpeed;
    /**
     * Given a delta from dragSpeed or dragDelta, determine the direction of movement and move the object accordingly
     * by using the dragAction.
     */
    private moveFromDelta;
    /**
     * Convert a point in the view (parent) coordinate frame to the model coordinate frame.
     */
    private parentToModelPoint;
    private localToParentPoint;
    /**
     * Returns the drag bounds in model coordinates.
     */
    getDragBounds(): Bounds2 | null;
    get dragBounds(): Bounds2 | null;
    /**
     * Sets the drag transform of the listener.
     */
    setTransform(transform: Transform3 | TReadOnlyProperty<Transform3> | null): void;
    set transform(transform: Transform3 | TReadOnlyProperty<Transform3> | null);
    get transform(): Transform3 | TReadOnlyProperty<Transform3> | null;
    /**
     * Returns the transform of the listener.
     */
    getTransform(): Transform3 | TReadOnlyProperty<Transform3> | null;
    /**
     * Getter for the dragSpeed property, see options.dragSpeed for more info.
     */
    get dragSpeed(): number;
    /**
     * Setter for the dragSpeed property, see options.dragSpeed for more info.
     */
    set dragSpeed(dragSpeed: number);
    /**
     * Getter for the shiftDragSpeed property, see options.shiftDragSpeed for more info.
     */
    get shiftDragSpeed(): number;
    /**
     * Setter for the shiftDragSpeed property, see options.shiftDragSpeed for more info.
     */
    set shiftDragSpeed(shiftDragSpeed: number);
    /**
     * Getter for the dragDelta property, see options.dragDelta for more info.
     */
    get dragDelta(): number;
    /**
     * Setter for the dragDelta property, see options.dragDelta for more info.
     */
    set dragDelta(dragDelta: number);
    /**
     * Getter for the shiftDragDelta property, see options.shiftDragDelta for more info.
     */
    get shiftDragDelta(): number;
    /**
     * Setter for the shiftDragDelta property, see options.shiftDragDelta for more info.
     */
    set shiftDragDelta(shiftDragDelta: number);
    /**
     * Are keys pressed that would move the target Node to the left?
     */
    movingLeft(): boolean;
    /**
     * Are keys pressed that would move the target Node to the right?
     */
    movingRight(): boolean;
    /**
     * Are keys pressed that would move the target Node up?
     */
    movingUp(): boolean;
    /**
     * Are keys pressed that would move the target Node down?
     */
    movingDown(): boolean;
    /**
     * Get the current target Node of the drag.
     */
    getCurrentTarget(): Node;
    /**
     * Returns true when this listener is currently dragging. The pointer must be assigned (drag started) and it
     * must be attached to this _pointerListener (otherwise it is interacting with another target).
     */
    private isDragging;
    /**
     * Scenery internal. Part of the events API. Do not call directly.
     *
     * Does specific work for the keydown event. This is called during scenery event dispatch, and AFTER any global
     * key state updates. This is important because interruption needs to happen after hotkeyManager has fully processed
     * the key state. And this implementation assumes that the keydown event will happen after Hotkey updates
     * (see startNextKeyboardEvent).
     */
    keydown(event: SceneryEvent<KeyboardEvent>): void;
    /**
     * Apply a mapping from the drag target's model position to an allowed model position.
     *
     * A common example is using dragBounds, where the position of the drag target is constrained to within a bounding
     * box. This is done by mapping points outside the bounding box to the closest position inside the box. More
     * general mappings can be used.
     *
     * Should be overridden (or use mapPosition) if a custom transformation is needed.
     *
     * @returns - A point in the model coordinate frame
     */
    protected mapModelPoint(modelPoint: Vector2): Vector2;
    /**
     * If the pointer is set, remove the listener from it and clear the reference.
     */
    private clearPointer;
    /**
     * Make eligible for garbage collection.
     */
    dispose(): void;
}
export default KeyboardDragListener;
//# sourceMappingURL=KeyboardDragListener.d.ts.map