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;

type AnimatryContextType = {
    animations: Set<any>;
    scope: HTMLElement | null;
    add: (animation: any) => void;
    revert: () => void;
};
declare const context: {
    contexts: Set<AnimatryContextType>;
    current: AnimatryContextType | null;
    create(scope?: HTMLElement | null): AnimatryContextType;
    setCurrent(context: AnimatryContextType | null): void;
    clear(context: AnimatryContextType): void;
};

type AnimatryCallback = (ctx: typeof context.current) => void | (() => void);
declare function matchMedia(query: string, callback: AnimatryCallback): () => void;

type ScrollObserverDevOptions = {
    markers: boolean;
    markersColor: string;
    area: boolean;
};
type ScrollObserverOptions = {
    animation: any;
    context: CoreDomSelect;
    trigger?: CoreDomSelect;
    endTrigger?: CoreDomElement;
    start: string | number;
    end: string | number;
    steer: boolean;
    steerDuration: number;
    pin: boolean | CoreDomSelect;
    pinSpacing: boolean;
    pinWrapper?: CoreDomSelect;
    pinContent?: CoreDomSelect;
    resize: boolean;
    dev: boolean | ScrollObserverDevOptions;
    onBottomIn: Function | string;
    onTopIn: Function | string;
    onBottomOut: Function | string;
    onTopOut: Function | string;
    onEnter: Function | string;
    onLeave: Function | string;
    onUpdate: Function;
};
declare class ScrollObserver {
    private static _defaultOptions;
    static get defaultOptions(): ScrollObserverOptions;
    static set defaultOptions(options: Partial<ScrollObserverOptions>);
    static devCss: boolean;
    private frame;
    private destroyed;
    options: ScrollObserverOptions;
    viewportStartPX: number;
    private viewportEndPX;
    triggerStartPX: number;
    private triggerEndPX;
    startTriggerOffset: number;
    private endTriggerOffset;
    private isIntersacting;
    private sy;
    private dy;
    private pinWrapper;
    private pinContent;
    private scrollDistance;
    private markers;
    private windowWidth;
    private boundResize;
    private absolute;
    constructor(options: Partial<ScrollObserverOptions>);
    private render;
    getProgress(delayed?: boolean): number;
    resize(): void;
    private patchStickyOverflow;
    refresh(): void;
    revert(): void;
    private createMarkers;
    private changeMarkerPosition;
    private setMarkerProgress;
}
declare const scrollObserver: {
    (options: Partial<ScrollObserverOptions>): ScrollObserver;
    label: string;
    options(options: Partial<ScrollObserverOptions>): {
        animation: any;
        context: CoreDomSelect;
        trigger?: CoreDomSelect;
        endTrigger?: CoreDomElement;
        start: string | number;
        end: string | number;
        steer: boolean;
        steerDuration: number;
        pin: boolean | CoreDomSelect;
        pinSpacing: boolean;
        pinWrapper?: CoreDomSelect;
        pinContent?: CoreDomSelect;
        resize: boolean;
        dev: boolean | ScrollObserverDevOptions;
        onBottomIn: Function | string;
        onTopIn: Function | string;
        onBottomOut: Function | string;
        onTopOut: Function | string;
        onEnter: Function | string;
        onLeave: Function | string;
        onUpdate: Function;
    };
};

type ScrollSmoothOptions = {
    wrapper?: CoreDomSelect;
    content?: CoreDomSelect;
    generateWrapper?: boolean;
    duration?: number;
    touchDuration?: number;
    speed?: number;
    touchSpeed?: number;
};
declare class ScrollSmooth {
    static _defaultOptions: ScrollSmoothOptions | undefined;
    static get defaultOptions(): ScrollSmoothOptions;
    static set defaultOptions(options: ScrollSmoothOptions);
    static dy: number | undefined;
    private options;
    private sy;
    private dy;
    private distance;
    private duration;
    private speed;
    private frame;
    private handleLoad;
    private handleScroll;
    private constructor();
    private static instance;
    static getInstance(options: ScrollSmoothOptions): ScrollSmooth;
    get content(): CoreDomElement | null;
    get scrollY(): number;
    private updateWrapperHeight;
    setDuration(duration: number): void;
    render(): void;
    revert(): void;
}
declare const scrollSmooth: {
    (options: ScrollSmoothOptions): ScrollSmooth;
    label: string;
    options(options: ScrollSmoothOptions): {
        wrapper?: CoreDomSelect;
        content?: CoreDomSelect;
        generateWrapper?: boolean;
        duration?: number;
        touchDuration?: number;
        speed?: number;
        touchSpeed?: number;
    };
};

interface ScrollToOptions {
    x?: string | number | Element;
    y?: string | number | Element;
    offsetX?: number;
    offsetY?: number;
    duration?: number;
    ease?: string;
    autokill?: boolean;
}
declare class ScrollTo {
    private isKilled;
    private startTime;
    private stopAnimation;
    constructor({ x, y, offsetX, offsetY, duration, ease, autokill, }: ScrollToOptions);
    private warn;
    private cleanup;
}
declare const scrollTo: {
    (options: ScrollToOptions): ScrollTo;
    label: string;
};

type SplitTextOptions = {
    type?: string;
};
declare class SplitText {
    chars: CoreDomElement[];
    words: CoreDomElement[];
    lines: CoreDomElement[];
    private _originalRecords;
    queryBuilder: SplitTextQueryBuilder;
    constructor(elements: any, options: SplitTextOptions);
    revert(): void;
    queryLines(indexes?: number | number[] | ((i: number) => boolean)): SplitTextQueryBuilder;
    queryWords(indexes?: number | number[] | ((i: number) => boolean)): SplitTextQueryBuilder;
    queryChars(indexes?: number | number[] | ((i: number) => boolean)): unknown[];
    private warn;
}
type QueryScope = {
    lines?: CoreDomElement[];
    words?: CoreDomElement[];
};
declare class SplitTextQueryBuilder {
    private splitText;
    private scope;
    constructor(splitText: SplitText, scope?: QueryScope);
    lines(indexes?: number | number[] | ((i: number) => boolean)): SplitTextQueryBuilder;
    words(indexes?: number | number[] | ((i: number) => boolean)): SplitTextQueryBuilder;
    chars(indexes?: number | number[] | ((i: number) => boolean)): unknown[];
    private _resolve;
}
declare const splitText: {
    (selector: any, options: any): SplitText;
    label: string;
};

type ScaleTextOptions = {
    width?: number | 'auto' | string;
    method?: 'font-size' | 'letter-spacing' | 'word-spacing';
    minSize?: number | string;
    maxSize?: number | string;
    resize?: boolean;
    onResize?: (() => void)[];
    onRefresh?: (() => void)[];
    dev?: boolean;
};
declare class ScaleText {
    private uc;
    private element;
    private options;
    private resizeObserver;
    private mutationObserver;
    private width;
    constructor(target: CoreDomSelect, options: ScaleTextOptions);
    private setProperty;
    refresh(): void;
    resize(): void;
    setWidth(width: number): void;
    revert(): void;
    private log;
    private warn;
    addOnResize(callback: () => void): void;
    addOnRefresh(callback: () => void): void;
}
declare const scaleText: {
    (target: CoreDomSelect, options: ScaleTextOptions): ScaleText;
    label: string;
};

type morphMapOptions = 'nearest' | 'evenly';
type MorphPathOptions = {
    shape?: string | CoreDomElement;
    fromShape?: string | CoreDomElement;
    toShape?: string | CoreDomElement;
    map?: morphMapOptions;
    index?: number | 'auto';
    origin?: string | [number, number, number, number];
    align?: string | [number, number, number, number] | 'none';
    compile?: boolean;
    compiled?: boolean;
    render?: Function;
    precision?: number;
};
declare class MorphPath {
    private disabled;
    private fromPath;
    private toPath;
    private element;
    private options;
    private result;
    private originVectorFrom;
    private originVectorTo;
    private static readonly DEFAULT_OPTIONS;
    constructor(element: any, options?: MorphPathOptions);
    private validateOptions;
    private unifyPathStructure;
    private applyOrigin;
    private rotatePaths;
    private applyAlignment;
    private compilePaths;
    private disablePath;
    private log;
    private warn;
    update(progress?: number): void;
    apply(): void;
}
declare const morphPath: {
    (selector: any, from: any, to: any): MorphPath;
    label: string;
    attribute: string;
    objectToPath(selector: any): "" | SVGPathElement;
};

type MagneticOptions = {
    activeClass: string;
    enterRadius: number | string;
    leaveRadius: number | string;
    enterSpeed: number;
    leaveSpeed: number;
    strength: number;
    singleElement: boolean;
    dev: boolean;
    onEnter: Function;
    onLeave: Function;
};
declare class Magnetic {
    private static _defaultOptions;
    static get defaultOptions(): MagneticOptions;
    static set defaultOptions(options: Partial<MagneticOptions>);
    private elements;
    private items;
    private options;
    private cursor;
    private active;
    private animationFrameId;
    constructor(elements: CoreDomSelect, options: MagneticOptions);
    handleMouseMove: (event: any) => void;
    private handleScroll;
    render: () => void;
    revert: () => void;
}
declare const magnetic: {
    (elements: CoreDomSelect, options: Partial<MagneticOptions>): Magnetic;
    label: string;
    attribute: string;
};

export { animatry, magnetic, matchMedia, morphPath, scaleText, scrollObserver, scrollSmooth, scrollTo, splitText };