// Generated by dts-bundle-generator v9.5.1

import { AABBValue, ActiveKeys, Body as Body$1, ChainShape, CircleShape, EdgeShape, Fixture, Joint, MouseJoint, PolygonShape, TestbedInterface, Vec2Value, World } from 'planck';
import { Memo, Middleware } from 'polymatic';
import * as Stage from 'stage-js';

export interface MagicboardContext {
	stage: Stage.Root;
	magicboard: MagicboardInterface;
}
export interface MagicboardInterface {
	drawPoint(p: Vec2Value, r: number, color: string): void;
	drawCircle(p: Vec2Value, r: number, color: string): void;
	drawEdge(a: Vec2Value, b: Vec2Value, color: string): void;
	drawSegment(a: Vec2Value, b: Vec2Value, color: string): void;
	drawPolygon(points: Array<Vec2Value>, color: string): void;
	drawChain(points: Array<Vec2Value>, color: string): void;
	drawAABB(aabb: AABBValue, color: string): void;
}
/**
 * Memoized drawing surface.
 */
export declare class Magicboard extends Middleware<MagicboardContext> {
	private component;
	private setupMemo;
	private nextBuffer;
	private lastBuffer;
	static lineWidth: number;
	constructor();
	handleActivate: () => void;
	handleContextChange(): void;
	handleDeactivate(): void;
	handleFrameBefore: () => void;
	handleFrameRender: () => void;
	drawPoint: (p: Vec2Value, r: number, color: string) => void;
	drawCircle: (p: Vec2Value, r: number, color: string) => void;
	drawEdge: (a: Vec2Value, b: Vec2Value, color: string) => void;
	drawSegment: (a: Vec2Value, b: Vec2Value, color: string) => void;
	drawPolygon: (points: Array<Vec2Value>, color: string) => void;
	drawChain: (points: Array<Vec2Value>, color: string) => void;
	drawAABB: (aabb: AABBValue, color: string) => void;
}
export interface ToolConfig {
	name: string;
	[prop: string]: unknown;
}
export interface ToolSwitchContext {
	activeTool: ToolConfig;
}
/**
 * Handles tool-switch events, activates the provided tool if the name matches.
 */
export declare class ToolSwitch<T extends ToolSwitchContext> extends Middleware<T> {
	name: string;
	tool: Middleware;
	constructor(name: string, tool: Middleware);
	handleSetActiveTool(tool: ToolConfig): void;
}
export interface ConsoleInterface {
	info(text: string): void;
	status(name: string, value: any): void;
	status(value: object | string): void;
}
export interface ConsoleContext {
	console: ConsoleInterface;
}
export declare class ConsoleProvider extends Middleware<ConsoleContext> implements ConsoleInterface {
	private statusElement;
	private infoElement;
	private lastStatus;
	private lastInfo;
	constructor();
	handleActivate(): void;
	handleDeactivate(): void;
	info(text: string): void;
	private _statusText;
	private _statusMap;
	status(name: string, value: any): void;
	status(value: object | string): void;
	updateInfo(text: string): void;
	updateStatus(text: string): void;
}
export interface Camera {
	x: number;
	y: number;
	width: number;
	height: number;
}
export interface ContextSimulation {
	speed: number;
	hz: number;
}
export interface ContextStyle {
	stroke?: string;
	fill?: string;
	lineWidth?: number;
	background?: string;
}
export interface ContextGamepad {
	activeKeys: ActiveKeys;
}
export interface TestbedContext {
	activeMode: string;
	activeTool: ToolConfig;
	paused: boolean;
	pointerCaptured: boolean;
	world: World;
	gamepad: ContextGamepad;
	style: ContextStyle;
	simulation: ContextSimulation;
	camera: Camera;
	containerElement?: HTMLElement;
	stage: Stage.Root;
	magicboard: MagicboardInterface;
	console: ConsoleInterface;
	testbed?: TestbedInterface;
}
export declare class DefaultTestbedContext implements TestbedContext {
	activeMode: string;
	activeTool: ToolConfig;
	paused: boolean;
	pointerCaptured: boolean;
	world: World;
	gamepad: {
		activeKeys: Record<string, boolean>;
	};
	style: {
		background: string;
	};
	simulation: {
		speed: number;
		hz: number;
	};
	camera: {
		x: number;
		y: number;
		width: number;
		height: number;
	};
	containerElement?: HTMLElement;
	stage: Stage.Root;
	magicboard: MagicboardInterface;
	console: ConsoleInterface;
	testbed?: TestbedInterface;
}
export interface GamepadPluginContext {
	gamepad: ContextGamepad;
	activeMode: string;
	paused: boolean;
}
export declare class GamepadPlugin extends Middleware<GamepadPluginContext> {
	constructor();
	handleActivate(): void;
	handleDeactivate(): void;
	private handleKeydown;
	private handleKeyup;
	private downKeys;
	private updateActiveKeys;
}
export interface WorldViewContext {
	world: World;
	stage: Stage.Root;
	style?: ContextStyle;
}
/**
 * Render the world in the stage.
 */
export declare class WorldView extends Middleware<WorldViewContext> {
	component: Stage.Node | null;
	setupMemo: Memo;
	constructor();
	handleContextChange: () => void;
	handleDeactivate: () => void;
	handleWorldEdited: () => void;
	private world;
	private bodies;
	private shapes;
	private joints;
	handleTick: () => void;
	setWorld: (world: World) => void;
	removeShape: (obj: Fixture) => void;
	removeBody: (obj: Body$1) => void;
	removeJoint: (obj: Joint) => void;
	rerenderWorld: () => void;
	renderWorld: (clearCache?: boolean) => void;
	renderBody(body: Body$1): void;
	renderFixture(bodyComponent: Stage.Node, body: Body$1, fixture: Fixture): void;
	renderJoint(joint: Joint): void;
}
export type WorldEventHandler = <K extends keyof WorldEventMap>(type: K, ev?: WorldEventMap[K]) => void;
export interface WorldPointerDown {
	point: {
		x: number;
		y: number;
	};
	fixture?: Fixture;
	background?: boolean;
}
export interface WorldDragStart {
	point: {
		x: number;
		y: number;
	};
	fixture?: Fixture;
	background?: boolean;
}
export interface WorldPointerMove {
	point: {
		x: number;
		y: number;
	};
}
export interface WorldDragMove {
	point: {
		x: number;
		y: number;
	};
	delta: {
		x: number;
		y: number;
	};
	move: {
		x: number;
		y: number;
	};
}
export interface WorldPointerUp {
	point: {
		x: number;
		y: number;
	};
}
export interface WorldClick {
	point: {
		x: number;
		y: number;
	};
	fixture?: Fixture;
	background?: boolean;
}
export interface WorldDragEnd {
	point: {
		x: number;
		y: number;
	};
}
export interface WorldEventMap {
	"world-pointer-down": WorldPointerDown;
	"world-drag-start": WorldDragStart;
	"world-pointer-move": WorldPointerMove;
	"world-drag-move": WorldDragMove;
	"world-pointer-up": WorldPointerUp;
	"world-click": WorldClick;
	"world-drag-end": WorldDragEnd;
	"world-drag-cancel": void;
	"world-pointer-cancel": void;
}
export interface ComputedStyle {
	stroke: string;
	fill: string;
	lineWidth: number;
}
export interface ProvidedStyle {
	stroke?: string;
	fill?: string;
	lineWidth?: number;
}
export declare class ComputedShapeStyle implements ComputedStyle {
	body: Body$1;
	fixture: Fixture;
	global?: ProvidedStyle;
	constructor(body: Body$1, fixture: Fixture, global?: ProvidedStyle);
	get stroke(): string;
	get fill(): string;
	get lineWidth(): number;
}
export declare class ComputedJointStyle implements ComputedStyle {
	joint: Joint;
	global?: ProvidedStyle;
	constructor(joint: Joint, global?: ProvidedStyle);
	get stroke(): string;
	get fill(): any;
	get lineWidth(): number;
}
export declare class ChainShapeComponent extends Stage.Sprite {
	style: ComputedStyle;
	shape: ChainShape;
	textureOffset: {
		x: number;
		y: number;
		a: number;
	};
	constructor(shape: ChainShape, style: ComputedStyle);
	memo: Memo;
	handleTick: () => boolean;
}
export declare class CircleShapeComponent extends Stage.Sprite {
	style: ComputedStyle;
	shape: CircleShape;
	textureOffset: {
		x: number;
		y: number;
		a: number;
	};
	constructor(shape: CircleShape, style: ComputedStyle);
	memo: Memo;
	handleTick: () => boolean;
}
export declare class EdgeShapeComponent extends Stage.Sprite {
	style: ComputedStyle;
	shape: EdgeShape;
	textureOffset: {
		x: number;
		y: number;
		a: number;
	};
	constructor(shape: EdgeShape, style: ComputedStyle);
	memo: Memo;
	handleTick: () => boolean;
}
export declare class PolygonShapeComponent extends Stage.Sprite {
	style: ComputedStyle;
	shape: PolygonShape;
	textureOffset: {
		x: number;
		y: number;
		a: number;
	};
	constructor(shape: PolygonShape, style: ComputedStyle);
	memo: Memo;
	handleTick: () => boolean;
}
export interface WorldPointerContext {
	world: World;
	stage: Stage.Root;
}
/**
 * Handles stage pointer events, and emits world-related pointer events:
 * - world-pointer-down
 * - world-pointer-move
 * - world-pointer-up
 * - world-pointer-cancel
 * - world-drag-start
 * - world-drag-move
 * - world-drag-end
 * - world-drag-cancel
 * - world-click
 */
export declare class WorldPointer extends Middleware<WorldPointerContext> {
	constructor();
	handleActivate: () => void;
	pointerStart: {
		x: number;
		y: number;
	};
	pointerLast: {
		x: number;
		y: number;
	};
	pointerDragged: boolean;
	pointerDown: boolean;
	handlePointerDown: (point: Vec2Value) => void;
	handlePointerMove: (point: Vec2Value) => void;
	handlePointerUp: (point: Vec2Value) => void;
	handlePointerCancel: () => void;
}
export interface FindFixtureContext {
	world: World;
	stage: Stage.Root;
}
export declare function findFixture(context: FindFixtureContext, point: Vec2Value, filter?: (fixture: Fixture) => boolean): Fixture;
export declare const getHitRadius: (component: Stage.Node) => number;
export interface StageLoaderContext {
	paused: boolean;
	stage: Stage.Root;
	containerElement: HTMLElement;
	pointerCaptured: boolean;
	style: ContextStyle;
	camera: Camera;
}
export declare class StageLoader extends Middleware<StageLoaderContext> {
	viewboxMemo: Memo;
	backgroundMemo: Memo;
	flipMemo: Memo;
	pausedMemo: Memo;
	stage: Stage.Root;
	containerElementMemo: Memo;
	constructor();
	handleContextChange: () => void;
	handleCapturePointer: () => void;
	handleReleasePointer: () => void;
	handleDeactivate: () => void;
	handleUpdateState: () => void;
	focus: () => void;
}
export interface ZoomPanPluginContext {
	pointerCaptured: boolean;
	containerElement: HTMLElement;
	stage: Stage.Root;
}
export interface ZoomEvent {
	zoom: number;
	center: {
		x: number;
		y: number;
	};
}
export interface PanEvent {
	delta: {
		x: number;
		y: number;
	};
}
/**
 * Zoom and pan the root component, using Hammer.js.
 */
export declare class ZoomPanProvider extends Middleware<ZoomPanPluginContext> {
	hammer: Hammer.Manager | null;
	containerElement: HTMLElement | null;
	setupMemo: Memo;
	pinchScale: number;
	pan: {
		x: number;
		y: number;
	};
	constructor();
	handleContextChange: () => void;
	handleDeactivate: () => void;
	getPoint: (ev: WheelEvent) => {
		x: number;
		y: number;
	};
	wheelListener: (ev: WheelEvent) => void;
	handlePinchStart: () => void;
	handlePinch: ({ target, scale, center, rotation }: {
		target: any;
		scale: any;
		center: any;
		rotation: any;
	}) => void;
	handlePanStart: () => void;
	handlePanMove: ({ deltaX, deltaY }: {
		deltaX: any;
		deltaY: any;
	}) => void;
	camera: Stage.Matrix;
	containerElementMemo: Memo;
	sizeMemo: Memo;
	offsetMemo: Memo;
	handleZoom: ({ center, zoom }: ZoomEvent) => void;
	handlePan: ({ delta }: PanEvent) => void;
}
export interface ImpulseToolContext {
	stage: Stage.Root;
	world: World;
	activeTool: ToolConfig;
}
export declare class ImpulseTool extends Middleware<ImpulseToolContext> {
	body: Body$1 | null;
	pointer: {
		x: number;
		y: number;
	};
	component: ImpulseToolComponent;
	setupMemo: Memo;
	constructor();
	handleContextChange: () => void;
	handleDeactivate: () => void;
	handlePointerDown: (ev: WorldPointerDown) => void;
	handlePointerMove: (ev: WorldPointerMove) => void;
	handlePointerUp: (ev: WorldPointerUp) => void;
	handlePointerCancel: () => void;
}
declare class ImpulseToolComponent extends Stage.Node {
	mw: ImpulseTool;
	static lineWidth: number;
	constructor(mw: ImpulseTool);
	renderTexture(ctx: CanvasRenderingContext2D): void;
	drawEdge: (ctx: CanvasRenderingContext2D, a: Vec2Value, b: Vec2Value, color: string) => void;
}
export interface PullToolContext {
	world: World;
	stage: Stage.Root;
	activeTool: ToolConfig;
}
export declare class PullTool extends Middleware<PullToolContext> {
	body: Body$1 | null;
	ground: Body$1 | null;
	joint: MouseJoint | null;
	constructor();
	handleDeactivate: () => void;
	handlePointerDown: (ev: WorldPointerDown) => void;
	handlePointerMove: (ev: WorldPointerMove) => void;
	handlePointerUp: () => void;
	handlePointerCancel: () => void;
	destroyJoint: () => void;
}
export interface FrameLoopEvent {
	dt: number;
	now: number;
}
/**
 * Implements variable length game loop. Sends frame-update and frame-render event to all middlewares.
 */
export declare class FrameLoop extends Middleware {
	lastTime: number;
	event: FrameLoopEvent;
	constructor();
	handleActivate(): void;
	handleFrame: () => void;
	requestFrame: () => void;
}
/**
 * Implements Testbed.mount() and returns a testbed instance connected to this runtime.
 */
export declare class TestbedLoader extends Middleware<TestbedContext> {
	stageMemo: Memo;
	constructor();
	handleActivate: () => void;
	handleContextChange: () => void;
	handleDeactivate(): void;
	handleFrameLoop: (ev: FrameLoopEvent) => void;
	handleGamepadKeydown: (ev: KeyboardEvent) => void;
	handleGamepadKeyup: (ev: KeyboardEvent) => void;
}
export declare class TestbedInstance implements TestbedInterface {
	static instance: TestbedInstance;
	private runtime;
	constructor(runtime: Middleware<TestbedContext>);
	get width(): number;
	set width(value: number);
	get height(): number;
	set height(value: number);
	get x(): number;
	set x(value: number);
	get y(): number;
	set y(value: number);
	get background(): string;
	set background(value: string);
	scaleY: number;
	get hz(): number;
	set hz(value: number);
	get speed(): number;
	set speed(value: number);
	get mouseForce(): number;
	set mouseForce(value: number);
	get activeKeys(): import("planck").ActiveKeys;
	step: (dt: number, t: number) => void;
	keydown: (keyCode: number, label: string) => void;
	keyup: (keyCode: number, label: string) => void;
	color(red: number, green: number, blue: number, alpha?: number): string;
	start(world: World): void;
	get world(): World;
	set world(world: World);
	drawPoint(p: Vec2Value, r: number, color: string): void;
	drawCircle(p: Vec2Value, r: number, color: string): void;
	drawEdge(a: Vec2Value, b: Vec2Value, color: string): void;
	drawSegment(a: Vec2Value, b: Vec2Value, color: string): void;
	drawPolygon(points: Array<Vec2Value>, color: string): void;
	drawChain(points: Array<Vec2Value>, color: string): void;
	drawAABB(aabb: AABBValue, color: string): void;
	findOne(query: string): Body$1 | Joint | Fixture | null;
	findAll(query: string): (Body$1 | Joint | Fixture)[];
	isPaused(): boolean;
	pause(): void;
	resume(): void;
	info(text: string): void;
	status(name: string, value: any): void;
	status(value: object | string): void;
}
export declare class ContainerLoader extends Middleware<{
	containerElement: HTMLElement;
}> {
	constructor();
	handleActivate(): void;
	handleDomReady: () => void;
}
interface WorldViewContext$1 {
	world: World;
	simulation?: ContextSimulation;
	paused?: boolean;
}
/**
 * Calls world.step on each frame update.
 */
export declare class WorldStep extends Middleware<WorldViewContext$1> {
	constructor();
	private timeBuffer;
	private stepErrored;
	handleTick: (ev: FrameLoopEvent) => void;
}
/** Default tool combining pull and impulse tools */
export declare class TestbedTool extends Middleware<TestbedContext> {
	constructor();
}
/**
 * Preset middlewares for planck testbed.
 */
export declare class TestbedMain extends Middleware<TestbedContext> {
	constructor();
}

export {};