@antv/g

cancelLandmarkAnimation: () => void;

createLandmark: (
    name: string,
    params?: Partial<{
        position: vec3 | vec2;
        focalPoint: vec3 | vec2;
        zoom: number;
        roll: number;
    }>
) => Landmark;

dolly: (value: number) => this;

gotoLandmark: (
    name: string | Landmark,
    options?:
        | number
        | Partial<{
              easing: string;
              easingFunction: TypeEasingFunction;
              duration: number;
              onframe: (t: number) => void;
              onfinish: () => void;
          }>
) => void;

pan: (tx: number, ty: number) => this;

rotate: (azimuth: number, elevation: number, roll: number) => this;

constructor(effect: KeyframeEffect, timeline: AnimationTimeline);

currentTime: number;

effect: KeyframeEffect;

readonly finished: Promise<any>;

id: string;

oncancel: (this: Animation, ev: AnimationPlaybackEvent) => any;

onfinish: (this: Animation, ev: AnimationPlaybackEvent) => any;

onframe: (this: Animation, ev: AnimationPlaybackEvent) => any;

onremove: (this: Animation, ev: Event) => any;

readonly pending: boolean;

playbackRate: number;

readonly playState: AnimationPlayState;

readonly ready: Promise<any>;

startTime: number;

timeline: AnimationTimeline;

readonly totalDuration: number;

addEventListener: {
    <K extends keyof AnimationEventMap>(
        type: K,
        listener: (this: Animation, ev: AnimationEventMap[K]) => any,
        options?: boolean | AddEventListenerOptions
    ): void;
    (
        type: string,
        listener: EventListenerOrEventListenerObject,
        options?: boolean | AddEventListenerOptions
    ): void;
};

cancel: () => void;

commitStyles: () => void;

dispatchEvent: (event: Event) => boolean;

finish: () => void;

markTarget: () => void;

pause: () => void;

persist: () => void;

play: () => void;

removeEventListener: {
    <K extends keyof AnimationEventMap>(
        type: K,
        listener: (this: Animation, ev: AnimationEventMap[K]) => any,
        options?: boolean | EventListenerOptions
    ): void;
    (
        type: string,
        listener: EventListenerOrEventListenerObject,
        options?: boolean | EventListenerOptions
    ): void;
};

reverse: () => void;

targetAnimations: () => IAnimation[];

tick: (timelineTime: number, isAnimationFrame: boolean) => void;

unmarkTarget: () => void;

updatePlaybackRate: (playbackRate: number) => void;

updatePromises: () => false | Promise<any>;

constructor(
    manager: any,
    target: Animation,
    currentTime: number,
    timelineTime: number
);

currentTime: number;

timelineTime: number;

constructor(document: IDocument);

animations: Animation[];

animationsWithPromises: Animation[];

currentTime: number;

applyDirtiedAnimation: (animation: Animation) => void;

applyPendingEffects: () => void;

destroy: () => void;

getAnimations: () => Animation[];

isTicking: () => boolean;

play: (
    target: IElement,
    keyframes: Keyframe[] | PropertyIndexedKeyframes | null,
    options?: number | KeyframeAnimationOptions
) => Animation;

restart: () => boolean;

tick: (
    t: number,
    isAnimationFrame: boolean,
    updatingAnimations: IAnimation[]
) => Animation[][];

constructor(config: DisplayObjectConfig<ArrowStyleProps>);

static PARSED_STYLE_LIST: Set<string>;

static tag: string;

attributeChangedCallback: <Key extends keyof ArrowStyleProps>(
    name: Key,
    oldValue: ArrowStyleProps[Key],
    newValue: ArrowStyleProps[Key]
) => void;

getBody: () => Line | Path | Polyline;

getEndHead: () => DisplayObject<any, any>;

getStartHead: () => DisplayObject<any, any>;

constructor(options: ImageExporterOptions);

downloadImage: (options: DownloadImageOptions) => void;

toCanvas: (options?: Partial<CanvasOptions>) => Promise<HTMLCanvasElement>;

toSVGDataURL: () => Promise<string>;

constructor(
    target: any,
    effectInput: Keyframe[] | PropertyIndexedKeyframes,
    timingInput?: number | KeyframeEffectOptions
);

animation: Animation;

composite: CompositeOperation;

iterationComposite: IterationCompositeOperation;

normalizedKeyframes: ComputedKeyframe[];

target: any;

timing: AnimationEffectTiming;

applyInterpolations: () => void;

getComputedTiming: () => ComputedEffectTiming;

getKeyframes: () => ComputedKeyframe[];

getTiming: () => EffectTiming;

setKeyframes: (keyframes: Keyframe[] | PropertyIndexedKeyframes | null) => void;

update: (localTime: number | null) => boolean;

updateTiming: (timing?: OptionalEffectTiming) => void;

constructor(config: any);

static PARSED_STYLE_LIST: Set<string>;

setAttribute: (name: any, value: any, force?: boolean) => void;

afterDrawImage: (context: CanvasRenderingContext2D) => void;

beforeDrawImage: (context: CanvasRenderingContext2D) => void;

clippingRegion: Rectangle;

ignoreElements: (element: Element) => boolean;

dataURL: string;

name?: string;

canvas: Canvas;

defaultFilename?: string;