@react-native-oh-tpl/react-native-gesture-handler 2.12.1-0.0.1 → 2.12.6-1

package/lib/typescript/web/detectors/ScaleGestureDetector.d.ts

@@ -1,29 +0,0 @@
-import { AdaptedEvent } from '../interfaces';
-import PointerTracker from '../tools/PointerTracker';
-export interface ScaleGestureListener {
-    onScaleBegin: (detector: ScaleGestureDetector) => boolean;
-    onScale: (detector: ScaleGestureDetector) => boolean;
-    onScaleEnd: (detector: ScaleGestureDetector) => void;
-}
-export default class ScaleGestureDetector implements ScaleGestureListener {
-    onScaleBegin: (detector: ScaleGestureDetector) => boolean;
-    onScale: (detector: ScaleGestureDetector) => boolean;
-    onScaleEnd: (detector: ScaleGestureDetector) => void;
-    private focusX;
-    private focusY;
-    private currentSpan;
-    private prevSpan;
-    private initialSpan;
-    private currentTime;
-    private prevTime;
-    private inProgress;
-    private spanSlop;
-    private minSpan;
-    constructor(callbacks: ScaleGestureListener);
-    onTouchEvent(event: AdaptedEvent, tracker: PointerTracker): boolean;
-    getCurrentSpan(): number;
-    getFocusX(): number;
-    getFocusY(): number;
-    getTimeDelta(): number;
-    getScaleFactor(numOfPointers: number): number;
-}

package/lib/typescript/web/handlers/FlingGestureHandler.d.ts

@@ -1,27 +0,0 @@
-import { AdaptedEvent, Config } from '../interfaces';
-import GestureHandler from './GestureHandler';
-export default class FlingGestureHandler extends GestureHandler {
-    private numberOfPointersRequired;
-    private direction;
-    private maxDurationMs;
-    private minAcceptableDelta;
-    private delayTimeout;
-    private startX;
-    private startY;
-    private maxNumberOfPointersSimultaneously;
-    private keyPointer;
-    init(ref: number, propsRef: React.RefObject<unknown>): void;
-    updateGestureConfig({ enabled, ...props }: Config): void;
-    private startFling;
-    private tryEndFling;
-    private endFling;
-    protected onPointerDown(event: AdaptedEvent): void;
-    protected onPointerAdd(event: AdaptedEvent): void;
-    private newPointerAction;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerUp(event: AdaptedEvent): void;
-    protected onPointerRemove(event: AdaptedEvent): void;
-    private onUp;
-    activate(force?: boolean): void;
-    protected resetConfig(): void;
-}

package/lib/typescript/web/handlers/GestureHandler.d.ts

@@ -1,90 +0,0 @@
-import { State } from '../../State';
-import { Config, AdaptedEvent, PointerType } from '../interfaces';
-import EventManager from '../tools/EventManager';
-import PointerTracker from '../tools/PointerTracker';
-import { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
-export default abstract class GestureHandler {
-    private lastSentState;
-    protected currentState: State;
-    protected shouldCancellWhenOutside: boolean;
-    protected hasCustomActivationCriteria: boolean;
-    protected enabled: boolean;
-    private viewRef;
-    private propsRef;
-    private handlerTag;
-    protected config: Config;
-    protected tracker: PointerTracker;
-    protected activationIndex: number;
-    protected awaiting: boolean;
-    protected active: boolean;
-    protected shouldResetProgress: boolean;
-    protected pointerType: PointerType;
-    protected delegate: GestureHandlerDelegate<unknown>;
-    constructor(delegate: GestureHandlerDelegate<unknown>);
-    protected init(viewRef: number, propsRef: React.RefObject<unknown>): void;
-    attachEventManager(manager: EventManager<unknown>): void;
-    protected onCancel(): void;
-    protected onReset(): void;
-    protected resetProgress(): void;
-    reset(): void;
-    moveToState(newState: State, sendIfDisabled?: boolean): void;
-    protected onStateChange(_newState: State, _oldState: State): void;
-    begin(): void;
-    /**
-     * @param {boolean} sendIfDisabled - Used when handler becomes disabled. With this flag orchestrator will be forced to send fail event
-     */
-    fail(sendIfDisabled?: boolean): void;
-    /**
-     * @param {boolean} sendIfDisabled - Used when handler becomes disabled. With this flag orchestrator will be forced to send cancel event
-     */
-    cancel(sendIfDisabled?: boolean): void;
-    activate(_force?: boolean): void;
-    end(): void;
-    isAwaiting(): boolean;
-    setAwaiting(value: boolean): void;
-    isActive(): boolean;
-    setActive(value: boolean): void;
-    getShouldResetProgress(): boolean;
-    setShouldResetProgress(value: boolean): void;
-    getActivationIndex(): number;
-    setActivationIndex(value: number): void;
-    shouldWaitForHandlerFailure(handler: GestureHandler): boolean;
-    shouldRequireToWaitForFailure(handler: GestureHandler): boolean;
-    shouldRecognizeSimultaneously(handler: GestureHandler): boolean;
-    shouldBeCancelledByOther(handler: GestureHandler): boolean;
-    protected onPointerDown(event: AdaptedEvent): void;
-    protected onPointerAdd(event: AdaptedEvent): void;
-    protected onPointerUp(event: AdaptedEvent): void;
-    protected onPointerRemove(event: AdaptedEvent): void;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerLeave(event: AdaptedEvent): void;
-    protected onPointerEnter(event: AdaptedEvent): void;
-    protected onPointerCancel(event: AdaptedEvent): void;
-    protected onPointerOutOfBounds(event: AdaptedEvent): void;
-    protected onPointerMoveOver(_event: AdaptedEvent): void;
-    protected onPointerMoveOut(_event: AdaptedEvent): void;
-    private tryToSendMoveEvent;
-    sendTouchEvent(event: AdaptedEvent): void;
-    sendEvent: (newState: State, oldState: State) => void;
-    private transformEventData;
-    private transformTouchEvent;
-    private cancelTouches;
-    protected transformNativeEvent(): Record<string, unknown>;
-    updateGestureConfig({ enabled, ...props }: Config): void;
-    protected checkCustomActivationCriteria(criterias: string[]): void;
-    private validateHitSlops;
-    private checkHitSlop;
-    protected resetConfig(): void;
-    getTag(): number;
-    setTag(tag: number): void;
-    getConfig(): Config;
-    getDelegate(): GestureHandlerDelegate<unknown>;
-    getTracker(): PointerTracker;
-    getTrackedPointersID(): number[];
-    getState(): State;
-    isEnabled(): boolean;
-    private isFinished;
-    protected setShouldCancelWhenOutside(shouldCancel: boolean): void;
-    protected getShouldCancelWhenOutside(): boolean;
-    getPointerType(): PointerType;
-}

package/lib/typescript/web/handlers/HoverGestureHandler.d.ts

@@ -1,10 +0,0 @@
-import { AdaptedEvent, Config } from '../interfaces';
-import GestureHandler from './GestureHandler';
-export default class HoverGestureHandler extends GestureHandler {
-    init(ref: number, propsRef: React.RefObject<unknown>): void;
-    updateGestureConfig({ enabled, ...props }: Config): void;
-    protected onPointerMoveOver(event: AdaptedEvent): void;
-    protected onPointerMoveOut(event: AdaptedEvent): void;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerCancel(event: AdaptedEvent): void;
-}

package/lib/typescript/web/handlers/LongPressGestureHandler.d.ts

@@ -1,26 +0,0 @@
-import { State } from '../../State';
-import { AdaptedEvent, Config } from '../interfaces';
-import GestureHandler from './GestureHandler';
-export default class LongPressGestureHandler extends GestureHandler {
-    private minDurationMs;
-    private defaultMaxDistSq;
-    private maxDistSq;
-    private startX;
-    private startY;
-    private startTime;
-    private previousTime;
-    private activationTimeout;
-    init(ref: number, propsRef: React.RefObject<unknown>): void;
-    protected transformNativeEvent(): {
-        duration: number;
-    };
-    updateGestureConfig({ enabled, ...props }: Config): void;
-    protected resetConfig(): void;
-    protected onStateChange(_newState: State, _oldState: State): void;
-    protected onPointerDown(event: AdaptedEvent): void;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerUp(event: AdaptedEvent): void;
-    private tryBegin;
-    private tryActivate;
-    private checkDistanceFail;
-}

package/lib/typescript/web/handlers/ManualGestureHandler.d.ts

@@ -1,12 +0,0 @@
-import { AdaptedEvent, Config } from '../interfaces';
-import GestureHandler from './GestureHandler';
-export default class ManualGestureHandler extends GestureHandler {
-    init(ref: number, propsRef: React.RefObject<unknown>): void;
-    updateGestureConfig({ enabled, ...props }: Config): void;
-    protected onPointerDown(event: AdaptedEvent): void;
-    protected onPointerAdd(event: AdaptedEvent): void;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerOutOfBounds(event: AdaptedEvent): void;
-    protected onPointerUp(event: AdaptedEvent): void;
-    protected onPointerRemove(event: AdaptedEvent): void;
-}

package/lib/typescript/web/handlers/NativeViewGestureHandler.d.ts

@@ -1,24 +0,0 @@
-import { AdaptedEvent, Config } from '../interfaces';
-import GestureHandler from './GestureHandler';
-export default class NativeViewGestureHandler extends GestureHandler {
-    private buttonRole;
-    private shouldActivateOnStart;
-    private disallowInterruption;
-    private startX;
-    private startY;
-    private minDistSq;
-    init(ref: number, propsRef: React.RefObject<unknown>): void;
-    updateGestureConfig({ enabled, ...props }: Config): void;
-    protected resetConfig(): void;
-    protected onPointerDown(event: AdaptedEvent): void;
-    protected onPointerAdd(event: AdaptedEvent): void;
-    private newPointerAction;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerLeave(): void;
-    protected onPointerUp(event: AdaptedEvent): void;
-    protected onPointerRemove(event: AdaptedEvent): void;
-    private onUp;
-    shouldRecognizeSimultaneously(handler: GestureHandler): boolean;
-    shouldBeCancelledByOther(_handler: GestureHandler): boolean;
-    disallowsInterruption(): boolean;
-}

package/lib/typescript/web/handlers/PanGestureHandler.d.ts

@@ -1,55 +0,0 @@
-import { AdaptedEvent, Config } from '../interfaces';
-import GestureHandler from './GestureHandler';
-export default class PanGestureHandler extends GestureHandler {
-    private readonly customActivationProperties;
-    velocityX: number;
-    velocityY: number;
-    private minDistSq;
-    private activeOffsetXStart;
-    private activeOffsetXEnd;
-    private failOffsetXStart;
-    private failOffsetXEnd;
-    private activeOffsetYStart;
-    private activeOffsetYEnd;
-    private failOffsetYStart;
-    private failOffsetYEnd;
-    private minVelocityX;
-    private minVelocityY;
-    private minVelocitySq;
-    private minPointers;
-    private maxPointers;
-    private startX;
-    private startY;
-    private offsetX;
-    private offsetY;
-    private lastX;
-    private lastY;
-    private activateAfterLongPress;
-    private activationTimeout;
-    init(ref: number, propsRef: React.RefObject<unknown>): void;
-    updateGestureConfig({ enabled, ...props }: Config): void;
-    protected resetConfig(): void;
-    protected transformNativeEvent(): {
-        translationX: number;
-        translationY: number;
-        velocityX: number;
-        velocityY: number;
-    };
-    private getTranslationX;
-    private getTranslationY;
-    private clearActivationTimeout;
-    protected onPointerDown(event: AdaptedEvent): void;
-    protected onPointerAdd(event: AdaptedEvent): void;
-    protected onPointerUp(event: AdaptedEvent): void;
-    protected onPointerRemove(event: AdaptedEvent): void;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerOutOfBounds(event: AdaptedEvent): void;
-    private shouldActivate;
-    private shouldFail;
-    private tryBegin;
-    private checkBegan;
-    activate(force?: boolean): void;
-    protected onCancel(): void;
-    protected onReset(): void;
-    protected resetProgress(): void;
-}

package/lib/typescript/web/handlers/PinchGestureHandler.d.ts

@@ -1,28 +0,0 @@
-import { AdaptedEvent, Config } from '../interfaces';
-import GestureHandler from './GestureHandler';
-export default class PinchGestureHandler extends GestureHandler {
-    private scale;
-    private velocity;
-    private startingSpan;
-    private spanSlop;
-    private scaleDetectorListener;
-    private scaleGestureDetector;
-    init(ref: number, propsRef: React.RefObject<unknown>): void;
-    updateGestureConfig({ enabled, ...props }: Config): void;
-    protected transformNativeEvent(): {
-        focalX: number;
-        focalY: number;
-        velocity: number;
-        scale: number;
-    };
-    protected onPointerDown(event: AdaptedEvent): void;
-    protected onPointerAdd(event: AdaptedEvent): void;
-    protected onPointerUp(event: AdaptedEvent): void;
-    protected onPointerRemove(event: AdaptedEvent): void;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerOutOfBounds(event: AdaptedEvent): void;
-    private tryBegin;
-    activate(force?: boolean): void;
-    protected onReset(): void;
-    protected resetProgress(): void;
-}

package/lib/typescript/web/handlers/RotationGestureHandler.d.ts

@@ -1,29 +0,0 @@
-import { AdaptedEvent, Config } from '../interfaces';
-import GestureHandler from './GestureHandler';
-export default class RotationGestureHandler extends GestureHandler {
-    private rotation;
-    private velocity;
-    private cachedAnchorX;
-    private cachedAnchorY;
-    private rotationGestureListener;
-    private rotationGestureDetector;
-    init(ref: number, propsRef: React.RefObject<unknown>): void;
-    updateGestureConfig({ enabled, ...props }: Config): void;
-    protected transformNativeEvent(): {
-        rotation: number;
-        anchorX: number;
-        anchorY: number;
-        velocity: number;
-    };
-    getAnchorX(): number;
-    getAnchorY(): number;
-    protected onPointerDown(event: AdaptedEvent): void;
-    protected onPointerAdd(event: AdaptedEvent): void;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerOutOfBounds(event: AdaptedEvent): void;
-    protected onPointerUp(event: AdaptedEvent): void;
-    protected onPointerRemove(event: AdaptedEvent): void;
-    protected tryBegin(): void;
-    activate(_force?: boolean): void;
-    protected onReset(): void;
-}

package/lib/typescript/web/handlers/TapGestureHandler.d.ts

@@ -1,39 +0,0 @@
-import { AdaptedEvent, Config } from '../interfaces';
-import GestureHandler from './GestureHandler';
-export default class TapGestureHandler extends GestureHandler {
-    private maxDeltaX;
-    private maxDeltaY;
-    private maxDistSq;
-    private maxDurationMs;
-    private maxDelayMs;
-    private numberOfTaps;
-    private minNumberOfPointers;
-    private currentMaxNumberOfPointers;
-    private startX;
-    private startY;
-    private offsetX;
-    private offsetY;
-    private lastX;
-    private lastY;
-    private waitTimeout;
-    private delayTimeout;
-    private tapsSoFar;
-    init(ref: number, propsRef: React.RefObject<unknown>): void;
-    updateGestureConfig({ enabled, ...props }: Config): void;
-    protected resetConfig(): void;
-    private clearTimeouts;
-    private startTap;
-    private endTap;
-    protected onPointerDown(event: AdaptedEvent): void;
-    protected onPointerAdd(event: AdaptedEvent): void;
-    protected onPointerUp(event: AdaptedEvent): void;
-    protected onPointerRemove(event: AdaptedEvent): void;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerOutOfBounds(event: AdaptedEvent): void;
-    private updateState;
-    private trySettingPosition;
-    private shouldFail;
-    activate(): void;
-    protected onCancel(): void;
-    protected resetProgress(): void;
-}

package/lib/typescript/web/interfaces.d.ts

@@ -1,141 +0,0 @@
-import { UserSelect, ActiveCursor } from '../handlers/gestureHandlerCommon';
-import { Directions } from '../Directions';
-import { State } from '../State';
-export interface HitSlop {
-    left?: number;
-    right?: number;
-    top?: number;
-    bottom?: number;
-    horizontal?: number;
-    vertical?: number;
-    width?: number;
-    height?: number;
-}
-export interface Handler {
-    handlerTag: number;
-}
-type ConfigArgs = number | boolean | HitSlop | UserSelect | ActiveCursor | Directions | Handler[] | null | undefined;
-export interface Config extends Record<string, ConfigArgs> {
-    enabled?: boolean;
-    simultaneousHandlers?: Handler[] | null;
-    waitFor?: Handler[] | null;
-    blocksHandlers?: Handler[] | null;
-    hitSlop?: HitSlop;
-    shouldCancelWhenOutside?: boolean;
-    userSelect?: UserSelect;
-    activeCursor?: ActiveCursor;
-    activateAfterLongPress?: number;
-    failOffsetXStart?: number;
-    failOffsetYStart?: number;
-    failOffsetXEnd?: number;
-    failOffsetYEnd?: number;
-    activeOffsetXStart?: number;
-    activeOffsetXEnd?: number;
-    activeOffsetYStart?: number;
-    activeOffsetYEnd?: number;
-    minPointers?: number;
-    maxPointers?: number;
-    minDist?: number;
-    minDistSq?: number;
-    minVelocity?: number;
-    minVelocityX?: number;
-    minVelocityY?: number;
-    minVelocitySq?: number;
-    maxDist?: number;
-    maxDistSq?: number;
-    numberOfPointers?: number;
-    minDurationMs?: number;
-    numberOfTaps?: number;
-    maxDurationMs?: number;
-    maxDelayMs?: number;
-    maxDeltaX?: number;
-    maxDeltaY?: number;
-    shouldActivateOnStart?: boolean;
-    disallowInterruption?: boolean;
-    direction?: Directions;
-}
-type NativeEventArgs = number | State | boolean | undefined;
-interface NativeEvent extends Record<string, NativeEventArgs> {
-    numberOfPointers: number;
-    state: State;
-    pointerInside: boolean | undefined;
-    handlerTag: number;
-    target: number;
-    oldState?: State;
-}
-export interface PointerData {
-    id: number;
-    x: number;
-    y: number;
-    absoluteX: number;
-    absoluteY: number;
-}
-type TouchNativeArgs = number | State | TouchEventType | PointerData[];
-interface NativeTouchEvent extends Record<string, TouchNativeArgs> {
-    handlerTag: number;
-    state: State;
-    eventType: TouchEventType;
-    changedTouches: PointerData[];
-    allTouches: PointerData[];
-    numberOfTouches: number;
-}
-export interface ResultEvent extends Record<string, NativeEvent | number> {
-    nativeEvent: NativeEvent;
-    timeStamp: number;
-}
-export interface ResultTouchEvent extends Record<string, NativeTouchEvent | number> {
-    nativeEvent: NativeTouchEvent;
-    timeStamp: number;
-}
-export interface PropsRef {
-    onGestureHandlerEvent: () => void;
-    onGestureHandlerStateChange: () => void;
-}
-export interface AdaptedEvent {
-    x: number;
-    y: number;
-    offsetX: number;
-    offsetY: number;
-    pointerId: number;
-    eventType: EventTypes;
-    pointerType: PointerType;
-    buttons: number;
-    time: number;
-    allTouches?: TouchList;
-    changedTouches?: TouchList;
-    touchEventType?: TouchEventType;
-}
-export declare enum MouseButtons {
-    NONE = 0,
-    LEFT = 1,
-    RIGHT = 2,
-    LEFT_RIGHT = 3,
-    SCROLL = 4,
-    SCROLL_LEFT = 5,
-    SCROLL_RIGHT = 6,
-    SCROLL_LEFT_RIGHT = 7
-}
-export declare enum EventTypes {
-    DOWN = 0,
-    ADDITIONAL_POINTER_DOWN = 1,
-    UP = 2,
-    ADDITIONAL_POINTER_UP = 3,
-    MOVE = 4,
-    ENTER = 5,
-    LEAVE = 6,
-    CANCEL = 7
-}
-export declare enum TouchEventType {
-    UNDETERMINED = 0,
-    DOWN = 1,
-    MOVE = 2,
-    UP = 3,
-    CANCELLED = 4
-}
-export declare enum PointerType {
-    NONE = "none",
-    MOUSE = "mouse",
-    TOUCH = "touch",
-    PEN = "pen"
-}
-export {};

package/lib/typescript/web/tools/CircularBuffer.d.ts

@@ -1,11 +0,0 @@
-export default class CircularBuffer<T> {
-    private bufferSize;
-    private buffer;
-    private index;
-    private actualSize;
-    constructor(size: number);
-    get size(): number;
-    push(element: T): void;
-    get(at: number): T;
-    clear(): void;
-}

package/lib/typescript/web/tools/EventManager.d.ts

@@ -1,34 +0,0 @@
-import { AdaptedEvent, EventTypes, TouchEventType } from '../interfaces';
-export default abstract class EventManager<T> {
-    protected readonly view: T;
-    protected pointersInBounds: number[];
-    protected activePointersCounter: number;
-    constructor(view: T);
-    abstract setListeners(): void;
-    protected abstract mapEvent(event: Event, eventType: EventTypes, index?: number, touchEventType?: TouchEventType): AdaptedEvent;
-    protected onPointerDown(_event: AdaptedEvent): void;
-    protected onPointerAdd(_event: AdaptedEvent): void;
-    protected onPointerUp(_event: AdaptedEvent): void;
-    protected onPointerRemove(_event: AdaptedEvent): void;
-    protected onPointerMove(_event: AdaptedEvent): void;
-    protected onPointerLeave(_event: AdaptedEvent): void;
-    protected onPointerEnter(_event: AdaptedEvent): void;
-    protected onPointerCancel(_event: AdaptedEvent): void;
-    protected onPointerOutOfBounds(_event: AdaptedEvent): void;
-    protected onPointerMoveOver(_event: AdaptedEvent): void;
-    protected onPointerMoveOut(_event: AdaptedEvent): void;
-    setOnPointerDown(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerAdd(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerUp(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerRemove(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerMove(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerLeave(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerEnter(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerCancel(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerOutOfBounds(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerMoveOver(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerMoveOut(callback: (event: AdaptedEvent) => void): void;
-    protected markAsInBounds(pointerId: number): void;
-    protected markAsOutOfBounds(pointerId: number): void;
-    resetManager(): void;
-}

package/lib/typescript/web/tools/GestureHandlerDelegate.d.ts

@@ -1,22 +0,0 @@
-import type GestureHandler from '../handlers/GestureHandler';
-export interface MeasureResult {
-    pageX: number;
-    pageY: number;
-    width: number;
-    height: number;
-}
-export interface GestureHandlerDelegate<T> {
-    getView(): T;
-    init(viewRef: number, handler: GestureHandler): void;
-    isPointerInBounds({ x, y }: {
-        x: number;
-        y: number;
-    }): boolean;
-    measureView(): MeasureResult;
-    reset(): void;
-    onBegin(): void;
-    onActivate(): void;
-    onEnd(): void;
-    onCancel(): void;
-    onFail(): void;
-}

package/lib/typescript/web/tools/GestureHandlerOrchestrator.d.ts

@@ -1,29 +0,0 @@
-import { State } from '../../State';
-import GestureHandler from '../handlers/GestureHandler';
-export default class GestureHandlerOrchestrator {
-    private static instance;
-    private gestureHandlers;
-    private awaitingHandlers;
-    private handlingChangeSemaphore;
-    private activationIndex;
-    private constructor();
-    private scheduleFinishedHandlersCleanup;
-    private cleanHandler;
-    removeHandlerFromOrchestrator(handler: GestureHandler): void;
-    private cleanupFinishedHandlers;
-    private hasOtherHandlerToWaitFor;
-    private tryActivate;
-    private shouldActivate;
-    private cleanupAwaitingHandlers;
-    onHandlerStateChange(handler: GestureHandler, newState: State, oldState: State, sendIfDisabled?: boolean): void;
-    private makeActive;
-    private addAwaitingHandler;
-    recordHandlerIfNotPresent(handler: GestureHandler): void;
-    private shouldHandlerWaitForOther;
-    private canRunSimultaneously;
-    private shouldHandlerBeCancelledBy;
-    private checkOverlap;
-    private isFinished;
-    cancelMouseAndPenGestures(currentHandler: GestureHandler): void;
-    static getInstance(): GestureHandlerOrchestrator;
-}

package/lib/typescript/web/tools/GestureHandlerWebDelegate.d.ts

@@ -1,21 +0,0 @@
-import type GestureHandler from '../handlers/GestureHandler';
-import { GestureHandlerDelegate, MeasureResult } from './GestureHandlerDelegate';
-export declare class GestureHandlerWebDelegate implements GestureHandlerDelegate<HTMLElement> {
-    private view;
-    private gestureHandler;
-    private eventManagers;
-    getView(): HTMLElement;
-    init(viewRef: number, handler: GestureHandler): void;
-    isPointerInBounds({ x, y }: {
-        x: number;
-        y: number;
-    }): boolean;
-    measureView(): MeasureResult;
-    reset(): void;
-    tryResetCursor(): void;
-    onBegin(): void;
-    onActivate(): void;
-    onEnd(): void;
-    onCancel(): void;
-    onFail(): void;
-}

package/lib/typescript/web/tools/InteractionManager.d.ts

@@ -1,17 +0,0 @@
-import GestureHandler from '../handlers/GestureHandler';
-import { Config } from '../interfaces';
-export default class InteractionManager {
-    private static instance;
-    private readonly waitForRelations;
-    private readonly simultaneousRelations;
-    private readonly blocksHandlersRelations;
-    private constructor();
-    configureInteractions(handler: GestureHandler, config: Config): void;
-    shouldWaitForHandlerFailure(handler: GestureHandler, otherHandler: GestureHandler): boolean;
-    shouldRecognizeSimultaneously(handler: GestureHandler, otherHandler: GestureHandler): boolean;
-    shouldRequireHandlerToWaitForFailure(handler: GestureHandler, otherHandler: GestureHandler): boolean;
-    shouldHandlerBeCancelledBy(_handler: GestureHandler, _otherHandler: GestureHandler): boolean;
-    dropRelationsForHandlerWithTag(handlerTag: number): void;
-    reset(): void;
-    static getInstance(): InteractionManager;
-}

package/lib/typescript/web/tools/LeastSquareSolver.d.ts

@@ -1,12 +0,0 @@
-declare class PolynomialFit {
-    coefficients: number[];
-    constructor(degree: number);
-}
-export default class LeastSquareSolver {
-    private x;
-    private y;
-    private w;
-    constructor(x: number[], y: number[], w: number[]);
-    solve(degree: number): PolynomialFit | null;
-}
-export {};