import Matter from "matter-js";
import { Sprite } from "../sprites/sprite";
import { Color, CreateBodyDefine, EntityInitial, EntityPrepare, MasterBody, Point } from "../../export-types";
import { EntitySuit } from "./entity-suit";
import { LogicComponent } from "../logic-component";
import { Sound } from "../sound";
import { Sensor } from "../sensor";
declare type TimerJobListener = () => void;
declare type TerminateOptions = {
    duration?: number;
    effect?: EntitySuit | LogicComponent<EntitySuit>;
    keepVisible?: boolean;
};
declare type TimerOptions = {
    defaultRun?: boolean;
    once?: boolean;
    startFrom?: number;
    onRegisterDone?: (time: number) => void;
};
declare type AddSensorParams = {
    name?: string;
    relativePosition?: Point;
} & ({
    shape?: "rect";
    width: number;
    height: number;
    radius?: never;
} | {
    shape: "circle";
    radius: number;
    width?: never;
    height?: never;
});
export declare abstract class Entity<P extends Record<string, any> = Record<string, any>> extends EntitySuit<EntityInitial<Entity>> {
    private _body;
    private _sprite;
    private _props;
    private timerJobListeners;
    private _isTerminate;
    private keepVisible;
    debugSensor: boolean;
    readonly sensors: Sensor[];
    enabledGravity: boolean;
    sound?: Sound;
    onTerminate?: () => void;
    abstract get edge(): {
        left: number;
        right: number;
        top: number;
        bottom: number;
    };
    get isTerminate(): boolean;
    set sprite(sprite: Sprite<any>);
    get sprite(): Sprite<any>;
    get position(): Matter.Vector;
    get body(): MasterBody;
    get props(): P;
    get havePhysicBody(): boolean;
    /**
     * @param {TerminateOptions} options
     * #duration: time to disappear from the world in milliseconds, default: 200 milliseconds
     * #effect: effect to showing on duration time
     * @void
     */
    terminate(options?: TerminateOptions): void;
    /**
     * @param {number} interval in milliseconds
     * @param {TimerJobListener} job function that run per #interval
     * @param {TimerOptions} options
     * @void
     */
    onTimer(interval: number, job: TimerJobListener, { defaultRun, once, startFrom, onRegisterDone, }?: TimerOptions): {
        remove: () => void;
        reset: () => void;
    };
    removeSensor(sensor: Sensor): void;
    /**
     * @param {Point} position delta position of sensor base on entity position
     * @param {string} name name of sensor
     * @param {"rect"|"circle"} shape type of shape of physical body, ex: "rect"|"circle"
     * @param {number} width width of sensor, apply when in "rect" shape
     * @param {number} height height of sensor, apply when in "rect" shape
     * @param {number} radius radius of sensor, apply when in "circle" shape
     * @param {boolean} debug allow to show sensor for debug purpose, have to enable entity.debugSensor = true first
     * @param {boolean} debugColor allow to change sensor color
     * @void
     */
    addSensor({ relativePosition, name, shape, width, height, radius, }: AddSensorParams, debug?: boolean, debugColor?: Color): void;
    createBody(enabledPhysicBody: boolean, transform: CreateBodyDefine["transform"], options?: CreateBodyDefine["bodyOptions"]): MasterBody | {
        position: Point;
        entity: Entity<Record<string, any>>;
    };
    protected abstract onCreateBody(enabledPhysicBody: boolean, transform: CreateBodyDefine["transform"], options?: CreateBodyDefine["bodyOptions"]): Matter.Body | {
        position: Point;
    };
    initial({ transform, sprite: spriteComponent, bodyOptions, props, ...params }: EntityInitial<this>): void;
    protected abstract onInitial(): EntityInitial<this>;
    /**
     * invoke before entity setup completed, this is need to provide information of name, sprite, animation, animator, transform,...
     * @void
     */
    protected onPrepare(): EntityPrepare<this>;
    update(): void;
    /**
     * invoke in every frame, this is necessary for logic that need to run in every frame
     * @void
     */
    onUpdate(): void;
    draw(): void;
    /**
     * invoke in every frame, this is necessary for draw that need to run in every frame
     * @void
     */
    onDraw(): void;
    abstract getSpriteWidthHeight(): {
        width: number;
        height: number;
    };
    onCollision(target: Entity | Sensor): void;
    onCollisionEnd(target: Entity | Sensor): void;
    onCollisionActive(target: Entity | Sensor): void;
    onSensorCollision(sensor: Sensor, target: Entity | Sensor): void;
    onSensorCollisionEnd(sensor: Sensor, target: Entity | Sensor): void;
    onSensorCollisionActive(sensor: Sensor, target: Entity | Sensor): void;
}
export {};
//# sourceMappingURL=entity.d.ts.map