declare class Timeline extends Controller {
    private controller;
    private attacheds;
    private labels;
    constructor(options?: ControllerOptions);
    getController(): ControllerOptions;
    totalProgress(): number;
    totalProgress(totalProgress: number, events?: boolean): this;
    _updateDuration(crop?: boolean): void;
    label(name: string, time?: string | number | undefined): this;
    add(object: Controller | string, time?: string | number | undefined): this;
    play(seek?: number | undefined): this;
    reverse(): this;
    seek(elapsed: number): this;
    fromTo(el: CoreGlobalSelect, from: ControllerOptions, to: ControllerOptions, time?: string | number | undefined): Timeline;
    to(el: CoreGlobalSelect, to: ControllerOptions, time?: string | number | undefined): Timeline;
    from(el: CoreGlobalSelect, from: ControllerOptions, time?: string | number | undefined): Timeline;
    set(el: CoreGlobalSelect, options: ControllerOptions, time?: string | number | undefined): this;
    wait(duration: number, options?: ControllerOptions, time?: string | number | undefined): this;
}

type CoreDomElement = HTMLElement | SVGElement;
type CoreDomSelect = CoreDomElement | CoreDomElement[] | NodeList | Document | string | null;
type CoreGlobalElement = CoreDomElement | {
    [key: string]: any;
};
type CoreGlobalSelect = CoreDomSelect | CoreGlobalElement | {
    [key: string]: any;
}[];
type controllerId = string | number;
type ease = Function | string;
interface ControllerCallbacks {
    onUpdate?: Function;
    onChange?: Function;
    onStart?: Function;
    onComplete?: Function;
    onReverseStart?: Function;
    onReverseComplete?: Function;
    onRepeat?: Function;
}
interface ControllerSettings {
    id?: controllerId;
    delay?: number;
    delayRecharge?: boolean;
    duration?: number;
    repeat?: number;
    iterationDelay?: number;
    alternate?: boolean;
    paused?: boolean;
    ease?: ease;
    reverseEase?: ease;
    alternateEase?: ease;
    reverseAlternateEase?: ease;
    playhead?: number;
    iteration?: number;
    reversed?: boolean;
    timeScale?: number;
    at?: number;
    preRender?: boolean;
    stagger?: StaggerOptions | number;
    keyframes?: KeyframeOptions | number;
    backwards?: boolean;
    [key: string]: any;
}
interface ControllerOptions extends ControllerSettings, ControllerCallbacks {
}
interface StaggerOptions extends ControllerCallbacks {
    layout?: [number, number] | 'grid' | 'distance';
    from?: [number, number] | number | 'start' | 'end' | 'left' | 'right' | 'center' | 'top left' | 'top right' | 'bottom left' | 'bottom right' | 'left top' | 'right top' | 'left bottom' | 'right bottom' | 'random';
    invert?: boolean;
    axis?: 'x' | 'y' | 'xy';
    duration?: number;
    each?: number;
    repeat?: number;
    iterationDelay?: number;
    alternate?: boolean;
    ease?: ease;
    reverseEase?: ease;
    alternateEase?: ease;
    reverseAlternateEase?: ease;
}
type KeyframeOptions = any;

declare class Controller {
    options: ControllerOptions;
    private _delayProgress;
    private _iterationDelayProgress;
    private _isPaused;
    private _isReversed;
    private _playhead;
    private _frame;
    private _tick;
    private _initialized;
    private _parent;
    constructor(options: ControllerOptions);
    _render(): void;
    play(seek?: number | undefined): this | undefined;
    pause(): this;
    reverse(): this | undefined;
    continue(): this | undefined;
    restart(): this;
    reset(): this;
    seek(elapsed: number): this;
    complete(): this;
    lastPlay(): this;
    getInitialized(): boolean;
    setInitialized(): void;
    parent(): Controller | undefined;
    parent(parent: Controller): this;
    id(): controllerId;
    id(id: controllerId): this;
    duration(): number;
    duration(duration: number, keepProgress?: boolean): this;
    progress(): number;
    progress(progress: number): this;
    elapsed(): number;
    elapsed(elapsed: number): this;
    totalProgress(): number;
    totalProgress(totalProgress: number, events?: boolean): this;
    totalElapsed(): number;
    totalElapsed(totalElapsed: number): this;
    delay(): number;
    delay(delay: number, restartDelay?: boolean): this;
    delayProgress(): number;
    delayProgress(delayProgress: number): this;
    delayElapsed(): number;
    delayElapsed(delayElapsed: number): this;
    reversed(): boolean;
    reversed(reversed: boolean): this;
    repeat(): number;
    repeat(repeat: number, keepIterations?: boolean): this;
    alternate(): boolean;
    alternate(alternate: boolean, smoothJump?: boolean): this;
    iteration(): number;
    iteration(iteration: number, smoothJump?: boolean): this;
    iterationDelay(): number;
    iterationDelay(iterationDelay: number): this;
    iterationDelayProgress(): number;
    iterationDelayProgress(iterationDelayProgress: number): this;
    timeScale(): number;
    timeScale(timeScale: number): this;
    getTotalDuration(): number;
    getEasedProgress(): number;
    getEasedElapsed(): number;
    isAlternating(): boolean;
    isPlaying(): boolean;
    onChange(callback: Function): this;
    onUpdate(callback: Function): this;
    onStart(callback: Function): this;
    onRepeat(callback: Function): this;
    onComplete(callback: Function): this;
    onReverseStart(callback: Function): this;
    onReverseComplete(callback: Function): this;
    revert(): void;
    static getProgress(instance: Controller, ph: number): number;
    static getEasedProgress(instance: Controller, ph: number): number;
    static iteration(instance: Controller, ph: number): number;
    static isAlternating(instance: Controller, ph: number): boolean;
}

declare class Tween extends Controller {
    elements: CoreGlobalElement[];
    from: ControllerOptions;
    to: ControllerOptions;
    private timeline;
    private properties;
    private fragment;
    constructor(elements: CoreGlobalSelect, from: ControllerOptions, to: ControllerOptions);
    render(): void;
    totalProgress(): number;
    totalProgress(totalProgress: number, events?: boolean): this;
    play(): this;
    reverse(): this;
}

declare class Fragment {
    private element;
    private initialTrans;
    private properties;
    constructor(element: CoreGlobalElement);
    getProperties(): any;
    setProperties(properties: any): void;
    getElement(): CoreGlobalElement;
}

type RelativeOptions = {
    x: number;
    y: number;
    rotateZ: number;
};
declare class Relative {
    elements: CoreDomElement[];
    options: RelativeOptions;
    fragments: Fragment[];
    constructor(elements: CoreDomSelect);
    set(options: Partial<RelativeOptions>, apply?: boolean): void;
    static get(element: CoreDomElement): RelativeOptions;
}

declare class Animatry {
    plugins: any;
    version(): void;
    options(options: ControllerOptions): void;
    fromTo(elements: CoreGlobalSelect, from?: ControllerOptions, to?: ControllerOptions): Tween;
    to(elements: CoreGlobalSelect, to?: ControllerOptions): Tween;
    from(elements: CoreGlobalSelect, from?: ControllerOptions): Tween;
    timeline(options?: ControllerOptions): Timeline;
    set(elements: CoreGlobalSelect, to?: ControllerOptions): Tween;
    relative(elements: CoreDomSelect): Relative;
    use(...plugins: any[]): void;
    pipeline: (...funcs: Function[]) => (...args: Function[]) => Function[];
    filterObjects: <T extends Record<string, any>>(object: T, filter: Partial<T>) => [Partial<T>, Partial<T>];
    random: (...args: any) => () => any;
    shuffle: (array: Array<any>) => any[];
    clamp: (number: number, min?: number, max?: number) => number;
    round: (value: number, decimalPlaces?: number) => number;
    lerp: (start: number, end: number, progress: number) => number;
    isEven: (n: number) => number;
    isOdd: (n: number) => boolean;
    pageReady: (callback: Function) => void;
    select: (input: CoreDomSelect) => CoreDomElement[];
    selectCss: (property: string, value: string, parent: CoreDomElement | NodeList, negate?: boolean) => Element[];
    getParent: (el: CoreDomElement) => CoreDomElement;
    camelToKebab: (s: string) => string;
    encapsulate: (element: HTMLElement, className: string) => {
        element: HTMLElement | null;
        wrapper: HTMLElement | null;
        revert(): void;
    };
    log: (m: string) => void;
    warn: (m: string) => void;
    get context(): {
        contexts: Set<{
            animations: Set<any>;
            scope: HTMLElement | null;
            add: (animation: any) => void;
            revert: () => void;
        }>;
        current: {
            animations: Set<any>;
            scope: HTMLElement | null;
            add: (animation: any) => void;
            revert: () => void;
        } | null;
        create(scope?: HTMLElement | null): {
            animations: Set<any>;
            scope: HTMLElement | null;
            add: (animation: any) => void;
            revert: () => void;
        };
        setCurrent(context: {
            animations: Set<any>;
            scope: HTMLElement | null;
            add: (animation: any) => void;
            revert: () => void;
        } | null): void;
        clear(context: {
            animations: Set<any>;
            scope: HTMLElement | null;
            add: (animation: any) => void;
            revert: () => void;
        }): void;
    };
}
declare const animatry: Animatry;

export { animatry };