declare module 'troika-worker-utils' {
	export type WorkerModuleCallArguments<
		Arguments extends readonly unknown[],
		Implementation,
	> = Implementation extends ( ...args: never[] ) => unknown
		? Arguments
		: [ unavailable: never ];

	export interface WorkerModule<
		Arguments extends readonly unknown[],
		Result,
		Implementation = (
			...args: Arguments
		) => Result | PromiseLike<Result>,
	> {
		( ...args: WorkerModuleCallArguments<Arguments, Implementation> ): Promise<Result>;
		onMainThread(
			...args: WorkerModuleCallArguments<Arguments, Implementation>
		): Promise<Result>;
		readonly workerModuleData: unknown;
	}

	// Worker-module dependencies are initialized before the parent module and its implementation
	// value is passed to `init`; the Promise-returning main-thread wrapper is not passed through.
	export type ResolvedWorkerDependency<Dependency> =
		Dependency extends WorkerModule<
			infer _Arguments,
			infer _Result,
			infer Implementation
		>
			? Implementation
			: Dependency;

	export type ResolvedWorkerDependencies<Dependencies extends readonly unknown[]> = {
		readonly [Index in keyof Dependencies]: ResolvedWorkerDependency<Dependencies[Index]>;
	};

	export interface WorkerModuleOptions<
		Dependencies extends readonly unknown[],
		Arguments extends readonly unknown[],
		Result,
	> {
		readonly name?: string;
		readonly workerId?: string;
		readonly dependencies?: Dependencies;
		readonly init: (
			...dependencies: ResolvedWorkerDependencies<Dependencies>
		) => ( ...args: Arguments ) => Result | PromiseLike<Result>;
		readonly getTransferables?: ( result: Awaited<Result> ) => readonly Transferable[];
	}

	export interface InferredWorkerModuleOptions<
		Dependencies extends readonly unknown[],
		Implementation extends ( ...args: never[] ) => unknown,
	> {
		readonly name?: string;
		readonly workerId?: string;
		readonly dependencies?: Dependencies;
		readonly init: (
			...dependencies: ResolvedWorkerDependencies<Dependencies>
		) => Implementation;
		readonly getTransferables?: (
			result: Awaited<ReturnType<Implementation>>
		) => readonly Transferable[];
	}

	export interface WorkerValueModuleOptions<
		Dependencies extends readonly unknown[],
		Value,
	> {
		readonly name?: string;
		readonly workerId?: string;
		readonly dependencies?: Dependencies;
		readonly init: (
			...dependencies: ResolvedWorkerDependencies<Dependencies>
		) => Value | PromiseLike<Value>;
		readonly getTransferables?: (
			result: Awaited<Value>
		) => readonly Transferable[];
	}

	export function defineWorkerModule<
		Dependencies extends readonly unknown[],
		Implementation extends ( ...args: never[] ) => unknown,
	>(
		options: InferredWorkerModuleOptions<Dependencies, Implementation>
	): WorkerModule<
		Parameters<Implementation>,
		Awaited<ReturnType<Implementation>>,
		Implementation
	>;

	export function defineWorkerModule<
		Dependencies extends readonly unknown[],
		Arguments extends readonly unknown[],
		Result,
	>(
		options: WorkerModuleOptions<Dependencies, Arguments, Result>
	): WorkerModule<Arguments, Awaited<Result>, (
		...args: Arguments
	) => Result | PromiseLike<Result>>;

	export function defineWorkerModule<
		Dependencies extends readonly unknown[],
		Value,
	>(
		options: WorkerValueModuleOptions<Dependencies, Value>
	): WorkerModule<[], Awaited<Value>, Awaited<Value>>;

	export function terminateWorker( workerId: string ): void;
}

declare module 'bidi-js' {
	export type BidiDirection = 'ltr' | 'rtl' | 'auto';

	export interface BidiParagraph {
		readonly start: number;
		readonly end: number;
		readonly level: number;
	}

	export interface BidiEmbeddingLevels {
		readonly levels: Uint8Array;
		readonly paragraphs: readonly BidiParagraph[];
	}

	export interface Bidi {
		getEmbeddingLevels(
			text: string,
			direction?: BidiDirection,
		): BidiEmbeddingLevels;
		getReorderSegments(
			text: string,
			embeddingLevels: BidiEmbeddingLevels,
			start?: number,
			end?: number,
		): Array<[ start: number, end: number ]>;
		getMirroredCharacter( character: string ): string | null;
	}

	export type BidiFactory = () => Bidi;

	const bidiFactory: BidiFactory;
	export default bidiFactory;
}

declare module 'webgl-sdf-generator' {
	export type SDFCanvas = HTMLCanvasElement | OffscreenCanvas;
	export type SDFViewBox = readonly [
		minX: number,
		minY: number,
		maxX: number,
		maxY: number,
	];
	export type SDFChannel = 0 | 1 | 2 | 3;

	export interface SDFGeneratorImplementation {
		generate(
			width: number,
			height: number,
			path: string,
			viewBox: SDFViewBox,
			maxDistance: number,
			exponent: number,
		): Uint8Array<ArrayBuffer>;
		generateIntoCanvas(
			width: number,
			height: number,
			path: string,
			viewBox: SDFViewBox,
			maxDistance: number,
			exponent: number,
			canvas: SDFCanvas,
			x: number,
			y: number,
			channel: SDFChannel,
		): void;
	}

	export interface WebGLSDFGeneratorImplementation extends SDFGeneratorImplementation {
		isSupported( canvas: SDFCanvas ): boolean;
	}

	export interface SDFWebGLUtils {
		renderImageData(
			canvas: SDFCanvas | WebGLRenderingContext | WebGL2RenderingContext,
			imageData: Uint8Array,
			x: number,
			y: number,
			width: number,
			height: number,
			channels?: number,
			framebuffer?: WebGLFramebuffer | null,
		): void;
		resizeWebGLCanvasWithoutClearing(
			canvas: SDFCanvas,
			newWidth: number,
			newHeight: number,
		): void;
	}

	export interface SDFGenerator {
		readonly javascript: SDFGeneratorImplementation;
		readonly webgl: WebGLSDFGeneratorImplementation;
		readonly webglUtils: SDFWebGLUtils;
	}

	export default function createSDFGenerator(): SDFGenerator;
}