import { Pixi } from './alias/Pixi';
import { Entity } from './gameEngine/entity/Entity';
import { GameEngineConfig } from './gameEngine/entity/GameEngineConfig';
import { GameEngineObject, GameEngineObjectFactory } from './gameEngine/entity/GameEngineObject';
import { Homothetie } from './gameEngine/entity/Homothetie';
import { Point2D } from './gameEngine/entity/Point2D.entity';
import { Circle, Rectangle, Shape, ShapeType } from './gameEngine/entity/Shape';
import { StateMachine } from './gameEngine/fsm/StateMachine';
import { StateMachineBuilder } from './gameEngine/fsm/StateMachineBuilder';
import { GameContext } from './gameEngine/GameContext';
import { DebugPanel } from './gameEngine/misc/DebugPanel';
import { GameLoader } from './gameEngine/misc/gameLoader';
import { KeyboardListener } from './gameEngine/misc/KeyboardListener';
import { TickHandler } from './gameEngine/misc/TickHandler';
import { HitTester } from './gameEngine/physic/HitTester';
import { MotionHandler } from './gameEngine/physic/MotionHandler';
import { PhysicHandler } from './gameEngine/physic/PhysicHandler';
import { Animations } from './gameEngine/render/Animations';
import { Camera } from './gameEngine/render/Camera';
import { PropAnimator } from './gameEngine/render/PropAnimator';
import { MouseHandler } from './gameEngine/sprite/MouseHandler';
import { GameWishManager } from './lobby/GameWishManager';
import { MetaGameCommand, MetaGameSetPseudo, MetaGameState } from './network/MetaGame';
import { OptimisticNetworkStateHandler } from './network/OptimisticNetworkStateHandler';
import { RegularCalls } from './network/RegularCalls';
import { RoomBus, RoomConnectionStatus } from './network/RoomBus';
import { RoomConnTracker, RoomStatuses } from './network/RoomConnTracker';
import { RouteDef } from './network/RouteDef';
import { RouteDefWithListener, RouteListener, UrlRouter } from './network/UrlRouter';
import { DiffBus } from './state/DiffBus';
import { ErrorOpt } from './state/ErrorOpt';
import { Scalar } from './state/Scalar';
import { PlayerCommand, Reducer, StateHandler } from './state/StateHandler';
import { XComponent } from './ui/XComponent';
import { deepCopy } from './utils/deepCopy';
import { EventBus } from './utils/EventBus';
import { EventListener } from './utils/EventListener';
import { MapCache } from './utils/MapCache';
import { PartialProp } from './utils/PartialProp';
import { randomFactory } from './utils/Random';
export type { Point2D, Shape, Rectangle, Circle, Entity, GameEngineConfig, Homothetie, PartialProp, GameEngineObject, EventListener, Reducer, PlayerCommand, Scalar, ErrorOpt, RouteListener, RouteDefWithListener, MetaGameState, MetaGameSetPseudo, MetaGameCommand, RoomConnectionStatus, RoomStatuses, };
export declare const api: {
    GameContext: typeof GameContext;
    Pixi: typeof Pixi;
    MouseHandler: typeof MouseHandler;
    GameLoader: typeof GameLoader;
    Camera: typeof Camera;
    Point2D: {
        ZERO: {
            x: number;
            y: number;
        };
        norm({ x, y }: Point2D): number;
        normLosange({ x, y }: Point2D): number;
        add({ x, y }: Point2D, other: Point2D): Point2D;
        minus({ x, y }: Point2D, other: Point2D): Point2D;
        factor({ x, y }: Point2D, factor: number): Point2D;
        productVectoriel({ x, y }: Point2D, { x: x2, y: y2 }: Point2D): number;
        productScalar(point1: Point2D, point2: Point2D): number;
        normalize(point: Point2D): Point2D;
        isEqual({ x, y }: Point2D, other: Point2D): boolean;
        getAngleRad({ x, y }: Point2D): number;
        distance(point1: Point2D, point2: Point2D): number;
    };
    TickHandler: typeof TickHandler;
    PropAnimator: typeof PropAnimator;
    PhysicHandler: typeof PhysicHandler;
    EventBus: typeof EventBus;
    MotionHandler: typeof MotionHandler;
    Shape: {
        toRectangle(container: import("./gameEngine/entity/Shape").ShapeBase): Rectangle;
        toCircle(container: import("./gameEngine/entity/Shape").ShapeBase): Circle;
    };
    ShapeType: typeof ShapeType;
    GameEngineObjectFactory: typeof GameEngineObjectFactory;
    Homothetie: {
        forward(homothetie: Homothetie, pos: Point2D): Point2D;
        backward(homothetie: Homothetie, pos: Point2D): Point2D;
    };
    StateMachine: typeof StateMachine;
    StateMachineBuilder: typeof StateMachineBuilder;
    KeyboardListener: typeof KeyboardListener;
    HitTest: {
        pointInShape(point: Point2D, shape: Shape): boolean;
        pointInCircle({ x, y }: Point2D, circle: Circle): boolean;
        pointInRect({ x, y }: Point2D, rect: Rectangle): boolean;
        rectInRect(rect1: Rectangle, rect2: Rectangle): Point2D | undefined;
        circleInCircle(circle1: Circle, circle2: Circle): Point2D | undefined;
        lineInLine(line1: import("./gameEngine/entity/Shape").Line, line2: import("./gameEngine/entity/Shape").Line): boolean;
        lineInRect(line: import("./gameEngine/entity/Shape").Line, rect: Rectangle): boolean;
    };
    HitTester: typeof HitTester;
    Animations: typeof Animations;
    GraphicsHandler: {
        newShape(shape: Shape, color?: number): Pixi.Graphics;
        setPos(graphics: Pixi.Container, pos: Point2D, type: ShapeType): void;
        setColor(graphics: Pixi.Graphics, shape: Shape, color: number): Pixi.Graphics;
        newLine(line: import("./gameEngine/entity/Shape").Line, color?: number): Pixi.Graphics;
    };
    SpriteHelper: {
        remove(sprite: Pixi.Container): void;
        centerAnchor(sprite: Pixi.Sprite): void;
        getGlobalPos(sprite: Pixi.Container, addedTo?: {
            x: number;
            y: number;
        }): Point2D;
    };
    Arrays: {
        seq(count: number): unknown[];
        partition<T>(array: T[], testFct: (input: T) => boolean): {
            filter: T[];
            filterNot: T[];
        };
        findMap<T_1, B>(array: T_1[], mapFct: (input: T_1) => B | undefined): B[];
        deduplicate<T_2>(array: T_2[]): T_2[];
        deduplicateBy<T_3>(array: T_3[], keyFct: (value: T_3) => string): T_3[];
        contains<T_4>(array: T_4[], value: T_4): boolean;
        maxBy<T_5>(array: T_5[], valueFct: (item: T_5) => number): T_5 | undefined;
        min<T_6>(array: T_6[], valueFct: (item: T_6) => number): number | undefined;
        max<T_7>(array: T_7[], valueFct: (item: T_7) => number): number | undefined;
        sortBy<T_8>(array: T_8[], valuesFct: (value: T_8) => number[]): void;
    };
    MapCache: typeof MapCache;
    Promises: {
        delay(duration: number): Promise<void>;
    };
    DebugPanel: typeof DebugPanel;
    deepCopy: typeof deepCopy;
    StateHandler: typeof StateHandler;
    DiffBus: typeof DiffBus;
    RouteDef: typeof RouteDef;
    UrlHelper: {
        buildSearchParams(obj: Record<string, string>): string;
        extractSearchParams(url: URL, paramNames: string[]): Record<string, string>;
    };
    UrlRouter: typeof UrlRouter;
    RegularCalls: typeof RegularCalls;
    RoomConnectionStatus: typeof RoomConnectionStatus;
    RoomBus: typeof RoomBus;
    OptimisticNetworkStateHandler: typeof OptimisticNetworkStateHandler;
    RoomConnTracker: typeof RoomConnTracker;
    GameWishManager: typeof GameWishManager;
    LobbyHelper: {
        startMetaGame: typeof import("./lobby/startMetaGame").startMetaGame;
        createLobbyPage: typeof import("./lobby/createLobbyPage").createLobbyPage;
    };
    XComponent: typeof XComponent;
    Strings: {
        hashcode(str: string): number;
        hash(str: string): string;
    };
    UiStyles: {
        [key: string]: Partial<CSSStyleDeclaration>;
    };
    Random: {
        simple: import("rauricoste-random/dist/RandomReader").RandomReader;
        zero: import("rauricoste-random/dist/RandomReader").RandomReader;
        gaussian: import("rauricoste-random/dist/RandomReader").RandomReader;
        fromGenerator: (generator: () => number) => import("rauricoste-random/dist/RandomReader").RandomReader;
        RandomReader: typeof import("rauricoste-random/dist/RandomReader").RandomReader;
        RandomReaderWithSeed: typeof import("rauricoste-random/dist/RandomReaderWithSeed").RandomReaderWithSeed;
    };
    randomFactory: typeof randomFactory;
};