import { SpriteOptions, Sprite as Sprite$1, Texture, ContainerEvents, ContainerChild, EventEmitter, TextureSourceLike } from 'pixi.js';
import CanvasEventNamesType from '../../types/CanvasEventNamesType.cjs';
import CanvasBaseItem from './CanvasBaseItem.cjs';
import CanvasEvent from '../CanvasEvent.cjs';
import CanvasBaseItemMemory from '../../interface/canvas/memory/CanvasBaseItemMemory.cjs';
import SpriteMemory, { SpriteBaseMemory } from '../../interface/canvas/memory/SpriteMemory.cjs';
import '../../types/EventIdType.cjs';
import '../../interface/canvas/TextureMemory.cjs';

/**
 * This class is a extension of the [PIXI.Sprite class](https://pixijs.com/8.x/examples/sprite/basic), it has the same properties and methods,
 * but it has the ability to be saved and loaded by the Pixi’VN library.
 * @example
 * ```typescript
 * const texture = await Assets.load('https://pixijs.com/assets/bunny.png');
 * const sprite = Sprite.from(texture);
 *
 * sprite.anchor.set(0.5);
 * sprite.x = canvas.screen.width / 2;
 * sprite.y = canvas.screen.height / 2;
 *
 * sprite.eventMode = 'static';
 * sprite.cursor = 'pointer';
 * sprite.onEvent('pointerdown', EventTest);
 *
 * canvas.add("bunny", sprite);
 * ```
 */
declare class Sprite<Memory extends SpriteOptions & CanvasBaseItemMemory = SpriteMemory> extends Sprite$1 implements CanvasBaseItem<Memory | SpriteMemory> {
    constructor(options?: SpriteOptions | Texture);
    pixivnId: string;
    private _textureAlias?;
    get textureAlias(): string;
    set textureAlias(value: string);
    get memory(): Memory | SpriteMemory;
    set memory(_value: Memory | SpriteMemory);
    setMemory(value: Memory | SpriteMemory): Promise<void>;
    private _onEvents;
    get onEvents(): {
        [name: string]: string;
    };
    /**
     * is same function as on(), but it keeps in memory the children.
     * @param event The event type, e.g., 'click', 'mousedown', 'mouseup', 'pointerdown', etc.
     * @param eventClass The class that extends CanvasEvent.
     * @returns
     * @example
     * ```typescript
     * \@eventDecorator()
     * export class EventTest extends CanvasEvent<Sprite> {
     *     override fn(event: CanvasEventNamesType, sprite: Sprite): void {
     *         if (event === 'pointerdown') {
     *             sprite.scale.x *= 1.25;
     *             sprite.scale.y *= 1.25;
     *         }
     *     }
     * }
     * ```
     *
     * ```typescript
     * let sprite = addImage("alien", 'https://pixijs.com/assets/eggHead.png')
     * await sprite.load()
     *
     * sprite.eventMode = 'static';
     * sprite.cursor = 'pointer';
     * sprite.onEvent('pointerdown', EventTest);
     *
     * canvas.add("bunny", sprite);
     * ```
     */
    onEvent<T extends typeof CanvasEvent<typeof this>>(event: CanvasEventNamesType, eventClass: T): this;
    /**
     * on() does not keep in memory the event class, use onEvent() instead
     * @deprecated
     * @private
     * @param event
     * @param fn
     * @param context
     */
    on<T extends keyof ContainerEvents<ContainerChild> | keyof {
        [K: symbol]: any;
        [K: {} & string]: any;
    }>(event: T, fn: (...args: EventEmitter.ArgumentMap<ContainerEvents<ContainerChild> & {
        [K: symbol]: any;
        [K: {} & string]: any;
    }>[Extract<T, keyof ContainerEvents<ContainerChild> | keyof {
        [K: symbol]: any;
        [K: {} & string]: any;
    }>]) => void, context?: any): this;
    static from(source: Texture | TextureSourceLike, skipCache?: boolean): Sprite<any>;
}
declare function setMemorySprite<Memory extends SpriteBaseMemory>(element: Sprite<any>, memory: Memory | {}, options?: {
    half?: () => Promise<void>;
    ignoreTexture?: boolean;
}): Promise<void>;

export { Sprite as default, setMemorySprite };