@react-types/shared 3.0.0-nightly-641446f65-240905

package/src/dnd.d.ts

@@ -0,0 +1,286 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import {Key, RefObject} from '@react-types/shared';
+
+export interface DragDropEvent {
+  /** The x coordinate of the event, relative to the target element. */
+  x: number,
+  /** The y coordinate of the event, relative to the target element. */
+  y: number
+}
+
+export type DropOperation = 'copy' | 'link' | 'move' | 'cancel';
+
+export interface DragItem {
+  [type: string]: string
+}
+
+export interface DragStartEvent extends DragDropEvent {
+  /** The event type. */
+  type: 'dragstart'
+}
+
+export interface DragMoveEvent extends DragDropEvent {
+  /** The event type. */
+  type: 'dragmove'
+}
+
+export interface DragEndEvent extends DragDropEvent {
+  /** The event type. */
+  type: 'dragend',
+  /** The drop operation that occurred. */
+  dropOperation: DropOperation
+}
+
+export interface DropEnterEvent extends DragDropEvent {
+  /** The event type. */
+  type: 'dropenter'
+}
+
+export interface DropMoveEvent extends DragDropEvent {
+  /** The event type. */
+  type: 'dropmove'
+}
+
+export interface DropActivateEvent extends DragDropEvent {
+  /** The event type. */
+  type: 'dropactivate'
+}
+
+export interface DropExitEvent extends DragDropEvent {
+  /** The event type. */
+  type: 'dropexit'
+}
+
+export interface TextDropItem {
+  /** The item kind. */
+  kind: 'text',
+  /**
+   * The drag types available for this item.
+   * These are often mime types, but may be custom app-specific types.
+   */
+  types: Set<string>,
+  /** Returns the data for the given type as a string. */
+  getText(type: string): Promise<string>
+}
+
+export interface FileDropItem {
+  /** The item kind. */
+  kind: 'file',
+  /** The file type (usually a mime type). */
+  type: string,
+  /** The file name. */
+  name: string,
+  /** Returns the contents of the file as a blob. */
+  getFile(): Promise<File>,
+  /** Returns the contents of the file as a string. */
+  getText(): Promise<string>
+}
+
+export interface DirectoryDropItem {
+  /** The item kind. */
+  kind: 'directory',
+  /** The directory name. */
+  name: string,
+  /** Returns the entries contained within the directory. */
+  getEntries(): AsyncIterable<FileDropItem | DirectoryDropItem>
+}
+
+export type DropItem = TextDropItem | FileDropItem | DirectoryDropItem;
+
+export interface DropEvent extends DragDropEvent {
+  /** The event type. */
+  type: 'drop',
+  /** The drop operation that should occur. */
+  dropOperation: DropOperation,
+  /** The dropped items. */
+  items: DropItem[]
+}
+
+export type DropPosition = 'on' | 'before' | 'after';
+export interface RootDropTarget {
+  /** The event type. */
+  type: 'root'
+}
+
+export interface ItemDropTarget {
+  /** The drop target type. */
+  type: 'item',
+  /** The item key. */
+  key: Key,
+  /** The drop position relative to the item. */
+  dropPosition: DropPosition
+}
+
+export type DropTarget = RootDropTarget | ItemDropTarget;
+
+export interface DroppableCollectionEnterEvent extends DropEnterEvent {
+  /** The drop target. */
+  target: DropTarget
+}
+
+export interface DroppableCollectionMoveEvent extends DropMoveEvent {
+  /** The drop target. */
+  target: DropTarget
+}
+
+export interface DroppableCollectionActivateEvent extends DropActivateEvent {
+  /** The drop target. */
+  target: DropTarget
+}
+
+export interface DroppableCollectionExitEvent extends DropExitEvent {
+  /** The drop target. */
+  target: DropTarget
+}
+
+export interface DroppableCollectionDropEvent extends DropEvent {
+  /** The drop target. */
+  target: DropTarget
+}
+
+export interface DroppableCollectionInsertDropEvent {
+  /** The dropped items. */
+  items: DropItem[],
+  /** The drop operation that should occur. */
+  dropOperation: DropOperation,
+   /** The drop target. */
+  target: ItemDropTarget
+}
+
+export interface DroppableCollectionRootDropEvent {
+  /** The dropped items. */
+  items: DropItem[],
+  /** The drop operation that should occur. */
+  dropOperation: DropOperation
+}
+
+export interface DroppableCollectionOnItemDropEvent {
+  /** The dropped items. */
+  items: DropItem[],
+  /** The drop operation that should occur. */
+  dropOperation: DropOperation,
+  /** Whether the drag originated within the same collection as the drop. */
+  isInternal: boolean,
+  /** The drop target. */
+  target: ItemDropTarget
+}
+
+export interface DroppableCollectionReorderEvent {
+  /** The keys of the items that were reordered. */
+  keys: Set<Key>,
+  /** The drop operation that should occur. */
+  dropOperation: DropOperation,
+  /** The drop target. */
+  target: ItemDropTarget
+}
+
+export interface DragTypes {
+  /** Returns whether the drag contains data of the given type. */
+  has(type: string | symbol): boolean
+}
+
+export interface DropTargetDelegate {
+  /**
+   * Returns a drop target within a collection for the given x and y coordinates.
+   * The point is provided relative to the top left corner of the collection container.
+   * A drop target can be checked to see if it is valid using the provided `isValidDropTarget` function.
+   */
+  getDropTargetFromPoint(x: number, y: number, isValidDropTarget: (target: DropTarget) => boolean): DropTarget | null
+}
+
+export interface DroppableCollectionUtilityOptions {
+  /**
+   * The drag types that the droppable collection accepts. If the collection accepts directories, include `DIRECTORY_DRAG_TYPE` in your array of allowed types.
+   * @default 'all'
+   */
+  acceptedDragTypes?: 'all' | Array<string | symbol>,
+  /**
+   * Handler that is called when external items are dropped "between" items.
+   */
+  onInsert?: (e: DroppableCollectionInsertDropEvent) => void,
+  /**
+   * Handler that is called when external items are dropped on the droppable collection's root.
+   */
+  onRootDrop?: (e: DroppableCollectionRootDropEvent) => void,
+  /**
+   * Handler that is called when items are dropped "on" an item.
+   */
+  onItemDrop?: (e: DroppableCollectionOnItemDropEvent) => void,
+  /**
+   * Handler that is called when items are reordered via drag in the source collection.
+   */
+  onReorder?: (e: DroppableCollectionReorderEvent) => void,
+  /**
+   * A function returning whether a given target in the droppable collection is a valid "on" drop target for the current drag types.
+   */
+  shouldAcceptItemDrop?: (target: ItemDropTarget, types: DragTypes) => boolean
+}
+
+export interface DroppableCollectionBaseProps {
+  /** Handler that is called when a valid drag enters a drop target. */
+  onDropEnter?: (e: DroppableCollectionEnterEvent) => void,
+  /**
+   * Handler that is called after a valid drag is held over a drop target for a period of time.
+   * @private
+   */
+  onDropActivate?: (e: DroppableCollectionActivateEvent) => void,
+  /** Handler that is called when a valid drag exits a drop target. */
+  onDropExit?: (e: DroppableCollectionExitEvent) => void,
+  /**
+   * Handler that is called when a valid drag is dropped on a drop target. When defined, this overrides other
+   * drop handlers such as `onInsert`, and `onItemDrop`.
+   */
+  onDrop?: (e: DroppableCollectionDropEvent) => void,
+  /**
+   * A function returning the drop operation to be performed when items matching the given types are dropped
+   * on the drop target.
+   */
+  getDropOperation?: (target: DropTarget, types: DragTypes, allowedOperations: DropOperation[]) => DropOperation
+}
+
+export interface DroppableCollectionProps extends DroppableCollectionUtilityOptions, DroppableCollectionBaseProps {}
+
+export interface DraggableCollectionStartEvent extends DragStartEvent {
+  /** The keys of the items that were dragged. */
+  keys: Set<Key>
+}
+
+export interface DraggableCollectionMoveEvent extends DragMoveEvent {
+  /** The keys of the items that were dragged. */
+  keys: Set<Key>
+}
+
+export interface DraggableCollectionEndEvent extends DragEndEvent {
+  /** The keys of the items that were dragged. */
+  keys: Set<Key>,
+  /** Whether the drop ended within the same collection as it originated. */
+  isInternal: boolean
+}
+
+export type DragPreviewRenderer = (items: DragItem[], callback: (node: HTMLElement) => void) => void;
+
+export interface DraggableCollectionProps {
+  /** Handler that is called when a drag operation is started. */
+  onDragStart?: (e: DraggableCollectionStartEvent) => void,
+  /** Handler that is called when the drag is moved. */
+  onDragMove?: (e: DraggableCollectionMoveEvent) => void,
+  /** Handler that is called when the drag operation is ended, either as a result of a drop or a cancellation. */
+  onDragEnd?: (e: DraggableCollectionEndEvent) => void,
+  /** A function that returns the items being dragged. */
+  getItems: (keys: Set<Key>) => DragItem[],
+  /** The ref of the element that will be rendered as the drag preview while dragging. */
+  preview?: RefObject<DragPreviewRenderer | null>,
+  /** Function that returns the drop operations that are allowed for the dragged items. If not provided, all drop operations are allowed. */
+  getAllowedDropOperations?: () => DropOperation[]
+}

package/src/dom.d.ts

@@ -0,0 +1,215 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import {
+  AriaAttributes,
+  AriaRole,
+  ClipboardEventHandler,
+  CompositionEventHandler,
+  CSSProperties,
+  FormEventHandler,
+  HTMLAttributeAnchorTarget,
+  HTMLAttributeReferrerPolicy,
+  DOMAttributes as ReactDOMAttributes,
+  ReactEventHandler
+} from 'react';
+
+export interface AriaLabelingProps {
+  /**
+   * Defines a string value that labels the current element.
+   */
+  'aria-label'?: string,
+
+  /**
+   * Identifies the element (or elements) that labels the current element.
+   */
+  'aria-labelledby'?: string,
+
+  /**
+   * Identifies the element (or elements) that describes the object.
+   */
+  'aria-describedby'?: string,
+
+  /**
+   * Identifies the element (or elements) that provide a detailed, extended description for the object.
+   */
+  'aria-details'?: string
+}
+
+export interface AriaValidationProps {
+  // https://www.w3.org/TR/wai-aria-1.2/#aria-errormessage
+  /**
+   * Identifies the element that provides an error message for the object.
+   */
+  'aria-errormessage'?: string
+}
+
+// A set of common DOM props that are allowed on any component
+// Ensure this is synced with DOMPropNames in filterDOMProps
+export interface DOMProps {
+  /**
+   * The element's unique identifier. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/id).
+   */
+  id?: string
+}
+
+export interface FocusableDOMProps extends DOMProps {
+  /**
+   * Whether to exclude the element from the sequential tab order. If true,
+   * the element will not be focusable via the keyboard by tabbing. This should
+   * be avoided except in rare scenarios where an alternative means of accessing
+   * the element or its functionality via the keyboard is available.
+   */
+  excludeFromTabOrder?: boolean
+}
+
+
+export interface TextInputDOMEvents {
+  // Clipboard events
+  /**
+   * Handler that is called when the user copies text. See [MDN](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/oncopy).
+   */
+   onCopy?: ClipboardEventHandler<HTMLInputElement>,
+
+   /**
+    * Handler that is called when the user cuts text. See [MDN](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/oncut).
+    */
+   onCut?: ClipboardEventHandler<HTMLInputElement>,
+
+   /**
+    * Handler that is called when the user pastes text. See [MDN](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/onpaste).
+    */
+   onPaste?: ClipboardEventHandler<HTMLInputElement>,
+
+   // Composition events
+   /**
+    * Handler that is called when a text composition system starts a new text composition session. See [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Element/compositionstart_event).
+    */
+   onCompositionStart?: CompositionEventHandler<HTMLInputElement>,
+
+   /**
+    * Handler that is called when a text composition system completes or cancels the current text composition session. See [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Element/compositionend_event).
+    */
+   onCompositionEnd?: CompositionEventHandler<HTMLInputElement>,
+
+   /**
+    * Handler that is called when a new character is received in the current text composition session. See [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Element/compositionupdate_event).
+    */
+   onCompositionUpdate?: CompositionEventHandler<HTMLInputElement>,
+
+   // Selection events
+   /**
+    * Handler that is called when text in the input is selected. See [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Element/select_event).
+    */
+   onSelect?: ReactEventHandler<HTMLInputElement>,
+
+   // Input events
+   /**
+    * Handler that is called when the input value is about to be modified. See [MDN](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/beforeinput_event).
+    */
+   onBeforeInput?: FormEventHandler<HTMLInputElement>,
+   /**
+    * Handler that is called when the input value is modified. See [MDN](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/input_event).
+    */
+   onInput?: FormEventHandler<HTMLInputElement>
+}
+
+export interface InputDOMProps {
+  /**
+   * The name of the input element, used when submitting an HTML form. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefname).
+   */
+  name?: string
+}
+
+// DOM props that apply to all text inputs
+// Ensure this is synced with useTextField
+export interface TextInputDOMProps extends DOMProps, InputDOMProps, TextInputDOMEvents {
+  /**
+   * Describes the type of autocomplete functionality the input should provide if any. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefautocomplete).
+   */
+  autoComplete?: string,
+
+  /**
+   * The maximum number of characters supported by the input. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefmaxlength).
+   */
+  maxLength?: number,
+
+  /**
+   * The minimum number of characters required by the input. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefminlength).
+   */
+  minLength?: number,
+
+  /**
+   * Regex pattern that the value of the input must match to be valid. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefpattern).
+   */
+  pattern?: string,
+
+  /**
+   * Content that appears in the input when it is empty. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefplaceholder).
+   */
+  placeholder?: string,
+
+  /**
+   * The type of input to render. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdeftype).
+   */
+  type?: 'text' | 'search' | 'url' | 'tel' | 'email' | 'password' | (string & {}),
+
+  /**
+   * Hints at the type of data that might be entered by the user while editing the element or its contents. See [MDN](https://html.spec.whatwg.org/multipage/interaction.html#input-modalities:-the-inputmode-attribute).
+   */
+  inputMode?: 'none' | 'text' | 'tel' | 'url' | 'email' | 'numeric' | 'decimal' | 'search'
+}
+
+/**
+ * This type allows configuring link props with router options and type-safe URLs via TS module augmentation.
+ * By default, this is an empty type. Extend with `href` and `routerOptions` properties to configure your router.
+ */
+export interface RouterConfig {}
+
+export type Href = RouterConfig extends {href: infer H} ? H : string;
+export type RouterOptions = RouterConfig extends {routerOptions: infer O} ? O : never;
+
+// Make sure to update filterDOMProps.ts when updating this.
+export interface LinkDOMProps {
+  /** A URL to link to. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#href). */
+  href?: Href,
+  /** Hints at the human language of the linked URL. See[MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#hreflang). */
+  hrefLang?: string,
+  /** The target window for the link. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#target). */
+  target?: HTMLAttributeAnchorTarget,
+  /** The relationship between the linked resource and the current page. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel). */
+  rel?: string,
+  /** Causes the browser to download the linked URL. A string may be provided to suggest a file name. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#download). */
+  download?: boolean | string,
+  /** A space-separated list of URLs to ping when the link is followed. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#ping). */
+  ping?: string,
+  /** How much of the referrer to send when following the link. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#referrerpolicy). */
+  referrerPolicy?: HTMLAttributeReferrerPolicy,
+  /** Options for the configured client side router. */
+  routerOptions?: RouterOptions
+}
+
+/** Any focusable element, including both HTML and SVG elements. */
+export interface FocusableElement extends Element, HTMLOrSVGElement {}
+
+/** All DOM attributes supported across both HTML and SVG elements. */
+export interface DOMAttributes<T = FocusableElement> extends AriaAttributes, ReactDOMAttributes<T> {
+  id?: string | undefined,
+  role?: AriaRole | undefined,
+  tabIndex?: number | undefined,
+  style?: CSSProperties | undefined,
+  className?: string | undefined
+}
+
+export interface GroupDOMAttributes extends Omit<DOMAttributes<HTMLElement>, 'role'> {
+  role?: 'group' | 'region' | 'presentation'
+}

package/src/events.d.ts

@@ -0,0 +1,177 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import {
+  FocusEvent,
+  KeyboardEvent as ReactKeyboardEvent,
+  SyntheticEvent
+} from 'react';
+
+// Event bubbling can be problematic in real-world applications, so the default for React Spectrum components
+// is not to propagate. This can be overridden by calling continuePropagation() on the event.
+export type BaseEvent<T extends SyntheticEvent> = T & {
+  /**
+   * Use continuePropagation.
+   * @deprecated */
+  stopPropagation(): void,
+  continuePropagation(): void
+}
+
+export type KeyboardEvent = BaseEvent<ReactKeyboardEvent<any>>;
+
+export type PointerType = 'mouse' | 'pen' | 'touch' | 'keyboard' | 'virtual';
+
+export interface PressEvent {
+  /** The type of press event being fired. */
+  type: 'pressstart' | 'pressend' | 'pressup' | 'press',
+  /** The pointer type that triggered the press event. */
+  pointerType: PointerType,
+  /** The target element of the press event. */
+  target: Element,
+  /** Whether the shift keyboard modifier was held during the press event. */
+  shiftKey: boolean,
+  /** Whether the ctrl keyboard modifier was held during the press event. */
+  ctrlKey: boolean,
+  /** Whether the meta keyboard modifier was held during the press event. */
+  metaKey: boolean,
+  /** Whether the alt keyboard modifier was held during the press event. */
+  altKey: boolean,
+  /** X position relative to the target. */
+  x: number,
+  /** Y position relative to the target. */
+  y: number,
+  /**
+   * By default, press events stop propagation to parent elements.
+   * In cases where a handler decides not to handle a specific event,
+   * it can call `continuePropagation()` to allow a parent to handle it.
+   */
+  continuePropagation(): void
+}
+
+export interface LongPressEvent extends Omit<PressEvent, 'type' | 'continuePropagation'> {
+  /** The type of long press event being fired. */
+  type: 'longpressstart' | 'longpressend' | 'longpress'
+}
+
+export interface HoverEvent {
+  /** The type of hover event being fired. */
+  type: 'hoverstart' | 'hoverend',
+  /** The pointer type that triggered the hover event. */
+  pointerType: 'mouse' | 'pen',
+  /** The target element of the hover event. */
+  target: HTMLElement
+}
+
+export interface KeyboardEvents {
+  /** Handler that is called when a key is pressed. */
+  onKeyDown?: (e: KeyboardEvent) => void,
+  /** Handler that is called when a key is released. */
+  onKeyUp?: (e: KeyboardEvent) => void
+}
+
+export interface FocusEvents<Target = Element> {
+  /** Handler that is called when the element receives focus. */
+  onFocus?: (e: FocusEvent<Target>) => void,
+  /** Handler that is called when the element loses focus. */
+  onBlur?: (e: FocusEvent<Target>) => void,
+  /** Handler that is called when the element's focus status changes. */
+  onFocusChange?: (isFocused: boolean) => void
+}
+
+export interface HoverEvents {
+  /** Handler that is called when a hover interaction starts. */
+  onHoverStart?: (e: HoverEvent) => void,
+  /** Handler that is called when a hover interaction ends. */
+  onHoverEnd?: (e: HoverEvent) => void,
+  /** Handler that is called when the hover state changes. */
+  onHoverChange?: (isHovering: boolean) => void
+}
+
+export interface PressEvents {
+  /** Handler that is called when the press is released over the target. */
+  onPress?: (e: PressEvent) => void,
+  /** Handler that is called when a press interaction starts. */
+  onPressStart?: (e: PressEvent) => void,
+  /**
+   * Handler that is called when a press interaction ends, either
+   * over the target or when the pointer leaves the target.
+   */
+  onPressEnd?: (e: PressEvent) => void,
+  /** Handler that is called when the press state changes. */
+  onPressChange?: (isPressed: boolean) => void,
+  /**
+   * Handler that is called when a press is released over the target, regardless of
+   * whether it started on the target or not.
+   */
+  onPressUp?: (e: PressEvent) => void
+}
+
+export interface FocusableProps<Target = Element> extends FocusEvents<Target>, KeyboardEvents {
+  /** Whether the element should receive focus on render. */
+  autoFocus?: boolean
+}
+
+interface BaseMoveEvent {
+  /** The pointer type that triggered the move event. */
+  pointerType: PointerType,
+  /** Whether the shift keyboard modifier was held during the move event. */
+  shiftKey: boolean,
+  /** Whether the ctrl keyboard modifier was held during the move event. */
+  ctrlKey: boolean,
+  /** Whether the meta keyboard modifier was held during the move event. */
+  metaKey: boolean,
+  /** Whether the alt keyboard modifier was held during the move event. */
+  altKey: boolean
+}
+
+export interface MoveStartEvent extends BaseMoveEvent {
+  /** The type of move event being fired. */
+  type: 'movestart'
+}
+
+export interface MoveMoveEvent extends BaseMoveEvent {
+  /** The type of move event being fired. */
+  type: 'move',
+  /** The amount moved in the X direction since the last event. */
+  deltaX: number,
+  /** The amount moved in the Y direction since the last event. */
+  deltaY: number
+
+}
+
+export interface MoveEndEvent extends BaseMoveEvent {
+  /** The type of move event being fired. */
+  type: 'moveend'
+}
+
+export type MoveEvent = MoveStartEvent | MoveMoveEvent | MoveEndEvent;
+
+export interface MoveEvents {
+  /** Handler that is called when a move interaction starts. */
+  onMoveStart?: (e: MoveStartEvent) => void,
+  /** Handler that is called when the element is moved. */
+  onMove?: (e: MoveMoveEvent) => void,
+  /** Handler that is called when a move interaction ends. */
+  onMoveEnd?: (e: MoveEndEvent) => void
+}
+
+export interface ScrollEvent {
+  /** The amount moved in the X direction since the last event. */
+  deltaX: number,
+  /** The amount moved in the Y direction since the last event. */
+  deltaY: number
+}
+
+export interface ScrollEvents {
+  /** Handler that is called when the scroll wheel moves. */
+  onScroll?: (e: ScrollEvent) => void
+}