export default Drawable;
declare class Drawable {
    /**
     * Connects the two drawables in the linked list, while cutting the previous connection and marking
     * @public
     *
     * @param {Drawable} a
     * @param {Drawable} b
     * @param {Display} display
     */
    public static connectDrawables(a: Drawable, b: Drawable, display: Display): void;
    /**
     * Disconnects the previous/before drawable from the provided one (for the linked list).
     * @public
     *
     * @param {Drawable} drawable
     * @param {Display} display
     */
    public static disconnectBefore(drawable: Drawable, display: Display): void;
    /**
     * Disconnects the next/after drawable from the provided one (for the linked list).
     * @public
     *
     * @param {Drawable} drawable
     * @param {Display} display
     */
    public static disconnectAfter(drawable: Drawable, display: Display): void;
    /**
     * Converts a linked list of drawables to an array (useful for debugging/assertion purposes, should not be used in
     * production code).
     * @public
     *
     * @param {Drawable} firstDrawable
     * @param {Drawable} lastDrawable
     * @returns {Array.<Drawable>}
     */
    public static listToArray(firstDrawable: Drawable, lastDrawable: Drawable): Array<Drawable>;
    /**
     * Converts an old linked list of drawables to an array (useful for debugging/assertion purposes, should not be
     * used in production code)
     * @public
     *
     * @param {Drawable} firstDrawable
     * @param {Drawable} lastDrawable
     * @returns {Array.<Drawable>}
     */
    public static oldListToArray(firstDrawable: Drawable, lastDrawable: Drawable): Array<Drawable>;
    /**
     * @public
     *
     * @param {number} renderer
     * @returns {Drawable} - for chaining
     */
    public initialize(renderer: number): Drawable;
    id: any;
    renderer: number | undefined;
    dirty: boolean | undefined;
    isDisposed: boolean | undefined;
    linksDirty: boolean | undefined;
    visibleProperty: TinyProperty<boolean> | undefined;
    fittableProperty: TinyProperty<boolean> | undefined;
    /**
     * Cleans the state of this drawable to the defaults.
     * @protected
     */
    protected clean(): void;
    parentDrawable: any;
    backbone: any;
    pendingParentDrawable: any;
    pendingBackbone: any;
    pendingAddition: boolean | undefined;
    pendingRemoval: boolean | undefined;
    previousDrawable: any;
    nextDrawable: any;
    oldPreviousDrawable: any;
    oldNextDrawable: any;
    /**
     * Updates the DOM appearance of this drawable (whether by preparing/calling draw calls, DOM element updates, etc.)
     * @public
     *
     * Generally meant to be overridden in subtypes (but should still call this to check if they should update).
     *
     * @returns {boolean} - Whether the update should continue (if false, further updates in supertype steps should not
     *                      be done).
     */
    public update(): boolean;
    /**
     * Sets whether the drawable is visible.
     * @public
     *
     * @param {boolean} visible
     */
    public setVisible(visible: boolean): void;
    set visible(value: boolean);
    get visible(): boolean;
    /**
     * Returns whether the drawable is visible.
     * @public
     *
     * @returns {boolean}
     */
    public isVisible(): boolean;
    /**
     * Sets whether this drawable is fittable.
     * @public
     *
     * NOTE: Should be called just after initialization (before being added to blocks) if we aren't fittable.
     *
     * @param {boolean} fittable
     */
    public setFittable(fittable: boolean): void;
    set fittable(value: boolean);
    get fittable(): boolean;
    /**
     * Returns whether the drawable is fittable.
     * @public
     *
     * @returns {boolean}
     */
    public isFittable(): boolean;
    /**
     * Called to add a block (us) as a child of a backbone
     * @public
     *
     * @param {BackboneDrawable} backboneInstance
     */
    public setBlockBackbone(backboneInstance: BackboneDrawable): void;
    /**
     * Notifies the Display of a pending addition.
     * @public
     *
     * @param {Display} display
     * @param {Block} block
     * @param {BackboneDrawable} backbone
     */
    public notePendingAddition(display: Display, block: Block, backbone: BackboneDrawable): void;
    /**
     * Notifies the Display of a pending removal.
     * @public
     *
     * @param {Display} display
     */
    public notePendingRemoval(display: Display): void;
    /**
     * Notifies the Display of a pending move.
     * @public
     *
     * Moving a drawable that isn't changing backbones, just potentially changing its block.
     * It should not have notePendingAddition or notePendingRemoval called on it.
     *
     * @param {Display} display
     * @param {Block} block
     */
    public notePendingMove(display: Display, block: Block): void;
    /**
     * Updates the block.
     * @public
     *
     * @returns {boolean} - Whether we changed our block
     */
    public updateBlock(): boolean;
    /**
     * Moves the old-drawable-linked-list information into the current-linked-list.
     * @public
     */
    public updateLinks(): void;
    /**
     * Marks this as needing an update.
     * @public
     */
    public markDirty(): void;
    /**
     * Marks our linked list as dirty.
     * @public
     *
     * Will ensure that after syncTree phase is done, we will have updateLinks() called on us
     *
     * @param {Display} display
     */
    public markLinksDirty(display: Display): void;
    /**
     * Marks us for disposal in the next phase of updateDisplay(), and disconnects from the linked list
     * @public
     *
     * @param {Display} display
     */
    public markForDisposal(display: Display): void;
    /**
     * Disposes immediately, and makes no guarantees about out linked list's state (disconnects).
     * @public
     *
     * @param {Display} display
     */
    public disposeImmediately(display: Display): void;
    /**
     * Releases references
     * @public
     *
     * NOTE: Generally do not call this directly, use markForDisposal (so Display will dispose us), or disposeImmediately.
     *
     * @param {*} !this.isDisposed
     * @param {*} 'We should not re-dispose drawables'
     */
    public dispose(): void;
    /**
     * Runs checks on the drawable, based on certain flags.
     * @public
     *
     * @param {boolean} allowPendingBlock
     * @param {boolean} allowPendingList
     * @param {boolean} allowDirty
     */
    public audit(allowPendingBlock: boolean, allowPendingList: boolean, allowDirty: boolean): void;
    /**
     * Returns a string form of this object
     * @public
     *
     * @returns {string}
     */
    public toString(): string;
    /**
     * Returns a more-informative string form of this object.
     * @public
     *
     * @returns {string}
     */
    public toDetailedString(): string;
}
import TinyProperty from '../../../axon/js/TinyProperty.js';
import { Block } from '../imports.js';
//# sourceMappingURL=Drawable.d.ts.map