konva

let angleDeg: boolean;

const Animation: typeof Animation;

const Arc: typeof Arc;

const Arrow: typeof Arrow;

let autoDrawEnabled: boolean;

let capturePointerEventsEnabled: boolean;

const Circle: typeof Circle;

const Container: typeof Container;

const Context: typeof Context;

const DD: {
    readonly isDragging: boolean;
    justDragged: boolean;
    readonly node: Node<NodeConfig>;
    _dragElements: Map<
        number,
        {
            node: Node<NodeConfig>;
            startPointerPos: Vector2d;
            offset: Vector2d;
            pointerId?: number;
            dragStatus: 'ready' | 'dragging' | 'stopped';
        }
    >;
    _drag(evt: any): void;
    _endDragBefore(evt?: any): void;
    _endDragAfter(evt: any): void;
};

let dragButtons: number[];

let dragDistance: number;

const Easings: {
    BackEaseIn(t: any, b: any, c: any, d: any): any;
    BackEaseOut(t: any, b: any, c: any, d: any): any;
    BackEaseInOut(t: any, b: any, c: any, d: any): any;
    ElasticEaseIn(t: any, b: any, c: any, d: any, a: any, p: any): any;
    ElasticEaseOut(t: any, b: any, c: any, d: any, a: any, p: any): any;
    ElasticEaseInOut(t: any, b: any, c: any, d: any, a: any, p: any): any;
    BounceEaseOut(t: any, b: any, c: any, d: any): any;
    BounceEaseIn(t: any, b: any, c: any, d: any): any;
    BounceEaseInOut(t: any, b: any, c: any, d: any): any;
    EaseIn(t: any, b: any, c: any, d: any): any;
    EaseOut(t: any, b: any, c: any, d: any): any;
    EaseInOut(t: any, b: any, c: any, d: any): any;
    StrongEaseIn(t: any, b: any, c: any, d: any): any;
    StrongEaseOut(t: any, b: any, c: any, d: any): any;
    StrongEaseInOut(t: any, b: any, c: any, d: any): any;
    Linear(t: any, b: any, c: any, d: any): any;
};

const Ellipse: typeof Ellipse;

let enableTrace: number;

const FastLayer: typeof FastLayer;

const Filters: {
    Blur: typeof Blur;
    Brighten: typeof Brighten;
    Contrast: typeof Contrast;
    Emboss: typeof Emboss;
    Enhance: typeof Enhance;
    Grayscale: typeof Grayscale;
    HSL: typeof HSL;
    HSV: typeof HSV;
    Invert: typeof Invert;
    Kaleidoscope: typeof Kaleidoscope;
    Mask: typeof Mask;
    Noise: typeof Noise;
    Pixelate: typeof Pixelate;
    Posterize: typeof Posterize;
    RGB: typeof RGB;
    RGBA: typeof RGBA;
    Sepia: typeof Sepia;
    Solarize: typeof Solarize;
    Threshold: typeof Threshold;
};

const Group: typeof Group;

let hitOnDragEnabled: boolean;

const Image: typeof Image;

const Label: typeof Label;

const Layer: typeof Layer;

const Line: typeof Line;

const Node: typeof Node;

const Path: typeof Path;

let pixelRatio: number;

const Rect: typeof Rect;

const RegularPolygon: typeof RegularPolygon;

const Ring: typeof Ring;

const Shape: typeof Shape;

const shapes: { [key: string]: Shape<ShapeConfig> };

let showWarnings: boolean;

const Sprite: typeof Sprite;

const Stage: typeof Stage;

const stages: Stage[];

const Star: typeof Star;

const Tag: typeof Tag;

const Text: typeof Text;

const TextPath: typeof TextPath;

const Transform: typeof Transform;

const Transformer: typeof Transformer;

const Tween: typeof Tween;

const Util: {
    _isElement(obj: any): obj is Element;
    _isFunction(obj: any): boolean;
    _isPlainObject(obj: any): boolean;
    _isArray(obj: any): obj is any[];
    _isNumber(obj: any): obj is number;
    _isString(obj: any): obj is string;
    _isBoolean(obj: any): obj is boolean;
    isObject(val: any): val is object;
    isValidSelector(selector: any): boolean;
    _sign(number: number): 1 | -1;
    requestAnimFrame(callback: Function): void;
    createCanvasElement(): HTMLCanvasElement;
    createImageElement(): HTMLImageElement;
    _isInDocument(el: any): boolean;
    _urlToImage(url: string, callback: Function): void;
    _rgbToHex(r: number, g: number, b: number): string;
    _hexToRgb(hex: string): RGB;
    getRandomColor(): string;
    getRGB(color: string): RGB;
    colorToRGBA(str: string): { r: number; g: number; b: number; a: number };
    _namedColorToRBA(str: string): { r: number; g: number; b: number; a: number };
    _rgbColorToRGBA(str: string): { r: number; g: number; b: number; a: number };
    _rgbaColorToRGBA(str: string): { r: number; g: number; b: number; a: number };
    _hex8ColorToRGBA(str: string): { r: number; g: number; b: number; a: number };
    _hex6ColorToRGBA(str: string): { r: number; g: number; b: number; a: number };
    _hex4ColorToRGBA(str: string): { r: number; g: number; b: number; a: number };
    _hex3ColorToRGBA(str: string): { r: number; g: number; b: number; a: number };
    _hslColorToRGBA(str: string): { r: number; g: number; b: number; a: number };
    haveIntersection(r1: IRect, r2: IRect): boolean;
    cloneObject<Any>(obj: Any): Any;
    cloneArray(arr: any[]): any[];
    degToRad(deg: number): number;
    radToDeg(rad: number): number;
    _degToRad(deg: number): number;
    _radToDeg(rad: number): number;
    _getRotation(radians: number): number;
    _capitalize(str: string): string;
    throw(str: string): never;
    error(str: string): void;
    warn(str: string): void;
    each(obj: object, func: Function): void;
    _inRange(val: number, left: number, right: number): boolean;
    _getProjectionToSegment(
        x1: any,
        y1: any,
        x2: any,
        y2: any,
        x3: any,
        y3: any
    ): any[];
    _getProjectionToLine(
        pt: Vector2d,
        line: Vector2d[],
        isClosed: boolean
    ): Vector2d;
    _prepareArrayForTween(startArray: any, endArray: any, isClosed: any): number[];
    _prepareToStringify<T>(obj: any): T;
    _assign<T, U>(target: T, source: U): T & U;
    _getFirstPointerId(evt: any): any;
    releaseCanvas(...canvases: HTMLCanvasElement[]): void;
    drawRoundedRectPath(
        context: Context,
        width: number,
        height: number,
        cornerRadius: number | number[]
    ): void;
};

const Wedge: typeof Wedge;

getAngle: (angle: number) => number;

isDragging: () => boolean;

isDragReady: () => boolean;

type Animation = import('./Animation.js').Animation;

type Arc = import('./shapes/Arc.js').Arc;

type ArcConfig = import('./shapes/Arc.js').ArcConfig;

type Arrow = import('./shapes/Arrow.js').Arrow;

type ArrowConfig = import('./shapes/Arrow.js').ArrowConfig;

type Circle = import('./shapes/Circle.js').Circle;

type CircleConfig = import('./shapes/Circle.js').CircleConfig;

type Container = import('./Container.js').Container<Node>;

type ContainerConfig = import('./Container.js').ContainerConfig;

type Context = import('./Context.js').Context;

type Ellipse = import('./shapes/Ellipse.js').Ellipse;

type EllipseConfig = import('./shapes/Ellipse.js').EllipseConfig;

type FastLayer = import('./FastLayer.js').FastLayer;

type Group = import('./Group.js').Group;

type GroupConfig = import('./Group.js').GroupConfig;

type Image = import('./shapes/Image.js').Image;

type ImageConfig = import('./shapes/Image.js').ImageConfig;

type KonvaEventListener<This, EventType> = import('./Node.js').KonvaEventListener<
    This,
    EventType
>;

type KonvaEventObject<EventType> = import('./Node.js').KonvaEventObject<EventType>;

type KonvaPointerEvent = import('./PointerEvents.js').KonvaPointerEvent;

type Label = import('./shapes/Label.js').Label;

type LabelConfig = import('./shapes/Label.js').LabelConfig;

type Layer = import('./Layer.js').Layer;

type LayerConfig = import('./Layer.js').LayerConfig;

type Line = import('./shapes/Line.js').Line;

type LineConfig = import('./shapes/Line.js').LineConfig;

type Node = import('./Node.js').Node;

type NodeConfig = import('./Node.js').NodeConfig;

type Path = import('./shapes/Path.js').Path;

type PathConfig = import('./shapes/Path.js').PathConfig;

type Rect = import('./shapes/Rect.js').Rect;

type RectConfig = import('./shapes/Rect.js').RectConfig;

type RegularPolygon = import('./shapes/RegularPolygon.js').RegularPolygon;

type RegularPolygonConfig =
    import('./shapes/RegularPolygon.js').RegularPolygonConfig;

type Ring = import('./shapes/Ring.js').Ring;

type RingConfig = import('./shapes/Ring.js').RingConfig;

type Shape = import('./Shape.js').Shape;

type ShapeConfig = import('./Shape.js').ShapeConfig;

type Sprite = import('./shapes/Sprite.js').Sprite;

type SpriteConfig = import('./shapes/Sprite.js').SpriteConfig;

type Stage = import('./Stage.js').Stage;

type StageConfig = import('./Stage.js').StageConfig;

type Star = import('./shapes/Star.js').Star;

type StarConfig = import('./shapes/Star.js').StarConfig;

type Tag = import('./shapes/Label.js').Tag;

type TagConfig = import('./shapes/Label.js').TagConfig;

type Text = import('./shapes/Text.js').Text;

type TextConfig = import('./shapes/Text.js').TextConfig;

type TextPath = import('./shapes/TextPath.js').TextPath;

type TextPathConfig = import('./shapes/TextPath.js').TextPathConfig;

type Transform = import('./Util.js').Transform;

type Transformer = import('./shapes/Transformer.js').Transformer;

type TransformerConfig = import('./shapes/Transformer.js').TransformerConfig;

type Tween = import('./Tween.js').Tween;

type TweenConfig = import('./Tween.js').TweenConfig;

type Vector2d = import('./types.js').Vector2d;

type Wedge = import('./shapes/Wedge.js').Wedge;

type WedgeConfig = import('./shapes/Wedge.js').WedgeConfig;