import { type DataOrError } from "../error";
import { type CanvasRenderingContext2D } from "canvas";
import { z } from "zod/v4";
import { type Theme, ThemeManager } from "./theme";
type ModuleContext<M extends PainterModule> = Parameters<M["draw"]> extends infer Args extends unknown[] ? ("3" extends keyof Args ? NonNullable<Args[3]> : unknown) : never;
type PainterContext<Modules extends Record<string, PainterModule>> = {
    [K in keyof Modules]: (context: ModuleContext<Modules[K]>) => void;
}[keyof Modules] extends (context: infer Context) => void ? Context : never;
export declare abstract class Painter<Adapter, Schema extends typeof ThemeManager.BASE_THEME> {
    static registerFonts(path: string): void;
    protected readonly theme: ThemeManager<Schema>;
    protected static get assetsPath(): string;
    protected wrapPainter<Modules extends Record<string, PainterModule>>({ theme, scale, modules, painterCtx, }: {
        theme?: string;
        scale?: number;
        modules: Modules;
        painterCtx: NoInfer<PainterContext<Modules>>;
    }, 
    /**
     * Drawing steps of the painter. Every element of the theme is drawn in
     * declaration order when the callback is omitted.
     */
    callback?: (ctx: CanvasRenderingContext2D, currentTheme: NonNullable<ReturnType<typeof this.theme.get>>, drawElements: () => Promise<void>) => unknown): Promise<DataOrError<Buffer>>;
    constructor({ theme: { schema, searchPaths, defaultTheme }, }: {
        theme: {
            schema: Schema;
            searchPaths: string[];
            defaultTheme: string;
        };
    });
    abstract draw(variables: Record<string, unknown>, options: {
        scale?: number;
    } | Record<string, unknown>): Promise<DataOrError<Buffer>>;
    abstract drawWithScoreSource(source: Adapter, variables: Record<string, unknown>, options: {
        scale?: number;
    } | Record<string, unknown>): Promise<DataOrError<Buffer>>;
}
export interface Bounds {
    x: number;
    y: number;
    width: number;
    height: number;
}
/**
 * Resolved layout of the painter, available to a module while it draws.
 */
export interface DrawLayout {
    /**
     * Final dimensions of the canvas, including the growth of the layout contributors.
     */
    canvas: {
        width: number;
        height: number;
    };
    /**
     * Position of the anchor of the element on the canvas.
     */
    offset: {
        x: number;
        y: number;
    };
}
export declare abstract class PainterModule {
    static readonly SCHEMA: z.ZodType;
    private static readonly BOUNDS_ELEMENT;
    abstract draw(ctx: CanvasRenderingContext2D, theme: Theme<unknown>, element: z.infer<typeof PainterModule.SCHEMA>, painterCtx: unknown, layout?: DrawLayout): Promise<void>;
    /**
     * Bounding box the module actually occupies, relative to the anchor of the element.
     *
     * A module only grows the theme it is a layout contributor of when this box
     * is larger than the one reported by {@link PainterModule.getMinimumBounds}.
     */
    getBounds(ctx: CanvasRenderingContext2D, theme: Theme<unknown>, element: z.infer<typeof PainterModule.SCHEMA>, painterCtx: unknown): Promise<Bounds>;
    /**
     * Bounding box the module occupies with the dimensions declared in the theme,
     * relative to the anchor of the element.
     */
    getMinimumBounds(_ctx: CanvasRenderingContext2D, _theme: Theme<unknown>, element: z.infer<typeof PainterModule.SCHEMA>, _painterCtx: unknown): Promise<Bounds>;
}
export {};