export declare class TweenError extends Error {
    constructor(msg?: string);
    set message(to: string);
}
export declare class TweenCheckError extends TweenError {
    private msg;
    private steps;
    constructor(msg?: string);
    set message(to: string);
    addStep(...steps: string[]): void;
}
export declare class SimpleTween {
    from: number;
    to: number;
    onUpdate: (res: number) => void;
    constructor(from: number, to: number, onUpdate: (res: number) => void);
    update(at: number): void;
}
declare type Easing = {
    function: (at: number) => number;
};
export interface OptionsA {
    readonly duration: number;
    readonly easing?: (at: number) => number | Easing;
    readonly iterations?: number;
    readonly fill?: boolean;
}
export interface OptionsB {
    readonly start?: number;
    readonly end?: number;
    readonly easing?: (at: number) => number | Easing;
    readonly iterations?: number;
    readonly fill?: boolean;
}
export declare type Options = OptionsA | OptionsB;
interface InternalOptions {
    readonly start: number;
    readonly end: number;
    readonly duration: number;
    readonly easing: (at: number) => number;
    readonly iterations: number;
    readonly fill: boolean;
}
declare type GenericObject = {
    [prop: string]: any;
};
declare type Keyframes<Interior> = ({
    offset?: number;
} & Interior)[];
export declare abstract class Tween<Input = unknown, Interior extends GenericObject = GenericObject, Output = Input> {
    private _keyframes;
    private tweeny;
    private tweenInstancesIndex;
    private updateListeners;
    private startTime;
    private tweenInstancesIndexKeys;
    private lastUpdateAt;
    readonly options: Readonly<InternalOptions>;
    constructor(array: true, keyframes: Keyframes<Input>, duration?: number, easing?: (at: number) => number | Easing);
    constructor(array: true, keyframes: Keyframes<Input>, options: OptionsA | OptionsB);
    constructor(from: Input & {
        offset?: never;
    }, to: Input, options: OptionsA | OptionsB);
    constructor(from: Input & {
        offset?: never;
    }, to: Input, duration?: number, easing?: (at: number) => number | Easing);
    private isWrapped;
    private wrap;
    private unwrap;
    private parseInAndWrap;
    private parseOutAndUnwrap;
    protected abstract parseIn(input: Input): Interior;
    protected abstract parseOut(interior: Interior): Output;
    private lastParsedOutput;
    update(at?: number): Output;
    onUpdate(ls: (res: Output) => void): (res: Output) => void;
    offUpdate(ls: (res: Output) => void): void;
    from(): Output & {
        offset?: never;
    };
    from(to: Input & {
        offset?: never;
    }): void;
    to(): Output & {
        offset?: never;
    };
    to(to: Input & {
        offset?: never;
    }): void;
    keyframes(): Keyframes<Output>;
    keyframes(to: Keyframes<Input>): void;
    private prepInput;
    private prepTweeny;
}
export default class TweenObject<Input = unknown, Interior extends GenericObject = GenericObject, Output = Input> extends Tween<Input, Interior, Output> {
    protected parseIn(face: Input): Interior;
    protected parseOut(interior: Interior): Output;
}
export {};