import { XY } from '@thegraid/common-lib';
import { Container, DisplayObject, Event, Matrix2D } from '@thegraid/easeljs-module';
import { NamedContainer } from './named-container.js';
export type SC = ScaleableContainer;
/** see scaleInit */
export type ScaleParams = {
    zscale?: number;
    initScale?: number;
    scale0?: number;
    steps?: number;
    unscaleMin?: number;
    scaleMax?: number;
    unscaleMax?: number;
};
export declare class ScaleEvent extends Event {
    scaleNdx: number;
    scale: number;
    oldScale: number;
    constructor(type: string, scaleNdx: number, scale: number, oldScale: number);
}
/** ScalableContainer is a Container, implements transforms to scale the display.
 * Child elements can be scaled with the Container (addChild)
 * or remain a constant size even as the Container scales (addUnscaled)
 */
export declare class ScaleableContainer extends NamedContainer {
    transform?: Matrix2D;
    initIndex: number;
    /**
      * Create a Container
      * then makeZoomable: so can Zoom/unZoom at the mouse-point
      * if there are interposed transforms, it may not work right.
      * @param parent If supplied: parent.addChild(this); [createjs.stage]
      */
    constructor(parent?: Container, params?: ScaleParams);
    /** scale factor of  for each increment of zoom */
    protected scaleAry: Array<number>;
    protected scaleNdx: number;
    protected scaleBase: number;
    protected scaleMaxNdx: number;
    protected unscaleMax: number;
    protected unscaleMin: number;
    protected macro: number;
    private stopEvent;
    /**
     * addEventListener for mousewheel and DOMMouseScroll to zoom to/from XY.
     * @param zscale sensitivity to event.wheelDelta (.3)
     * @return initial {index, scale}
    */
    makeZoomable(params?: ScaleParams): number;
    /** reset the zoom-scaling array:
     *
     * Note: unscaled objects *are* scaled when scaleNdx\<0 (if min\<0)
     *
     * Note: unscaled objests are super-scaled (1.5x) when scaleNdx>(max-2)
     * @param params -
     * - scale0: scale a 0: [1]
     * - scaleMax: scale at max: [1000]
     * - steps: highest index: [32]
     * - initScale: initial scale: [scale0] --> determines initIndex = findIndex(initScale)
     * - unscaleMax: max scale of unscaled zoomed out [1/scaleAry[2]]
     * - unscaleMin: min scale of unscaled zoomed in [1/scaleAry[steps-2]]
     * - zscale: zoom speed scaling
     *
     * @return initIndex [findIndex(initScale)]
     */
    scaleInit(params?: ScaleParams): number;
    /** divide interval from scale0 to scaleMax into nSteps (nSteps+1 values) */
    setupScaleAry(scale0: number, scaleMax: number, nSteps: number): void;
    /** find scaleIndex that gets closest to scale
     * @param scale the scale factor you want to get (or 'base' when setting)
     * @param setAry true to setup the scaleAry, false to simply query [default]
     * @return index that gets closest so given scale
     */
    findIndex(scale: number): number;
    /** lowest scale for unscaled items */
    get scale0(): number;
    /** the current index into the scale array */
    get scaleIndex(): number;
    /** the current scale factor from scaleAry (actual scaleX/scaleY may be different) */
    get scaleXY(): number;
    /** set scaleIndex & return associated scale factor */
    getScale(ndx?: number): number;
    /** add di to find new index into scale array
     * @param di typically: -1, +1 (0 to return currentScale)
     */
    incScale(di: number): number;
    /**
     * Set scale and offsets exactly; set scale index approximately and return it.
     * @param ns new scale
     * @param xy scale around this point (so 'p' does not move on display) = {0,0}
     * @param sxy offset to position (0,0)
     * @returns the nearby scaleNdx
     */
    setScale(ns?: number, xy?: XY, sxy?: XY): number;
    /** Simply rescale around the give pt.
     *
     * Like scaleInternal, but does not unscale or emit an event.
     *
     * @param ns new scale, unrestricted by scale index
     * @param pt fixed point to scale around
     * @returns the nearest scale index
     */
    setScaleOnly(ns?: number, pt?: {
        x: number;
        y: number;
    }): number;
    /**
     * Set scale to arbitrary value; set nearest index; set origin point directly.
     * @param ns new scale, set scale index to closest value
     * @param pt set x,y offset directly
     * @returns
     */
    setScaleXY(ns?: number, pt?: XY): number;
    /** zoom to the scale[si]
     * @param si new scaleNdx
     * @param xy fixed point
     * @return the new scale
     */
    setScaleIndex(si: number, xy?: XY): number;
    /**
     * rescale, set origin, position viewport
     * @deprecated does not use scaleInternal() --> invScale()
     * @param si new scale index; [0 -> scale0 aka initScale]
     * @param xy align xy at parent(0,0) [0,0]
     * @param sxy offset xy to screen position sxy [0,0]
     */
    setScaleXY1(si?: number, xy?: XY, sxy?: XY): number;
    /**
     * legacy setScaleXY: set ScaleIndex and XY origin
     * @param si
     * @param xy set this.{x,y} [0,0]
     * @deprecated does not include scaleInternal (unscale & event)
     */
    setScaleXY0(si: number, xy?: XY): void;
    /** Scale this.cont by the indicated scale factor around the given XY.
     * @param di: +1/-1 to increase/decrease scale; 0 to reset to scale0 @ XY
     * @param xy:  scale around this point (so 'p' does not move on display) = {0,0}
     * @return the new scale
     */
    scaleContainer(di: number, xy?: XY): number;
    /** convert from os to ns; if os=0 then reset to ns
     * unscaleObj all this._unscale objects.
     * @param os oldScale (or 0 to force reset to p:XY)
     * @param ns newScale
     * @param p  fixed point around which to scale; default: (0,0) OR when os==0: reset to (x,y)
     */
    scaleInternal(os: number, ns: number, p?: XY): number;
    invScale0: number;
    /** Scalable.container.addChild() */
    addChildXY(child: DisplayObject, x: number, y: number): DisplayObject;
    private invScale;
    private _unscaled;
    addUnscaled(dobj: DisplayObject, invScMin?: number, invScMax?: number): void;
    removeUnscaled(dobj: DisplayObject): void;
    protected unscaleObj(dobj: DisplayObject, invScale?: number): void;
    protected setInvScale(ns?: number): number;
    protected unscaleAll(invScale?: number): void;
}