Drawing and math API

function line(from: PointLike, to: PointLike, samples = 24): Point[];

function cubic(p0: PointLike, p1: PointLike, p2: PointLike, p3: PointLike, samples = 48): Point[];

function catmullRom(points: PointLike[], samplesPerSegment = 12, tension = 0.5): Point[];

function ellipse(cx: number, cy: number, rx: number, ry: number, options: {
    samples?: number;
    pressure?: number;
    rotation?: number;
} = {}): Point[];

function translate(points: Point[], x: number, y: number): Point[];

function scale(points: Point[], scaleX: number, scaleY = scaleX, origin = { x: 0, y: 0 }): Point[];

function withPressure(points: Point[], pressure: number | ((t: number) => number)): Point[];

function mirrored(points: Point[], axisX: number): Point[];

function hatchPolygon(polygon: PointLike[], options: {
    angle?: number;
    spacing?: number;
    pressure?: number;
    jitter?: number;
    seed?: number;
    maxSamples?: number;
} = {}): Point[][];

/** SVG's absolute M/L/C/Q/Z subset, retained as editable contour commands. */
export function pathCommands(source: string): PathCommand[];

/** Sample separate pen-down paths. The original editable contour commands remain untouched. */
export function samplePath(commands: readonly PathCommand[], options: PathSamplingOptions = {}): Point[][];

/** Insert a knot using de Casteljau subdivision; retain editable curve commands. */
export function splitPathSegment(commands: readonly PathCommand[], index: number, t = 0.5): PathCommand[];

function combinePaths(a: readonly PathCommand[], b: readonly PathCommand[], operation: PathBooleanOperation): PathCommand[];

function pathBounds(commands: readonly PathCommand[]): { left: number; top: number; right: number; bottom: number; width: number; height: number; } | null;

function pathContains(commands: readonly PathCommand[], x: number, y: number): boolean;

function customizeBrush(base: BrushPreset, changes: Partial<Omit<BrushPreset, "dynamics">> & {
    dynamics?: Partial<BrushPreset["dynamics"]>;
}): BrushPreset;

function brushTipFromFunction(width: number, height: number, sample: (x: number, y: number) => number, options: {
    angle?: number;
    rotationMode?: "fixed" | "stroke" | "stylus";
} = {}): BrushTip;

async function importBrushResource(path: string, options: ImportOptions): Promise<BrushImportReport>;

async function importBrushResourceBuffer(data: Buffer, name: string, options: ImportOptions): Promise<BrushImportReport>;

/** Explicitly reauthor a resource for this engine; never promises source-application parity. */
export function brushFromResource(resource: BrushResource, settings: Omit<BrushPreset, "tip">): BrushPreset;

async function renderBrushSwatch(brush: BrushPreset, options: {
    color?: string;
    background?: string;
} = {}): Promise<Buffer>;

function createPixels(width: number, height: number): PixelBuffer;

function readPixelRegion(image: PixelBuffer, region: PixelRegion): PixelBuffer;

function writePixelRegion(image: PixelBuffer, x: number, y: number, patch: PixelBuffer): void;

/** Compare visible premultiplied RGBA, ignoring hidden RGB under zero alpha. */
export function comparePixels(before: PixelBuffer, after: PixelBuffer, options: {
    threshold?: number;
} = {}): PixelComparison;

async function decodePixels(bytes: Uint8Array): Promise<PixelBuffer>;

async function encodePixels(image: PixelBuffer): Promise<Buffer>;

/** Import a bounded RGB8 pixel-layer PSD without mutating a project or using its merged preview. */
export function importPSD(input: Uint8Array, options: PSDImportOptions): PSDImportResult;

function polygonPixelSelection(width: number, height: number, points: Pick<Point, "x" | "y">[], fillRule: "nonzero" | "evenodd" = "nonzero"): PixelSelection;

/** Four-connected flood or all matching pixels, measured in premultiplied RGBA byte units. */
export function colorPixelSelection(image: PixelBuffer, x: number, y: number, options: {
    tolerance?: number;
    contiguous?: boolean;
} = {}): PixelSelection;

function combinePixelSelections(a: PixelSelection, b: PixelSelection, operation: "union" | "intersect" | "subtract"): PixelSelection;

function invertPixelSelection(selection: PixelSelection): PixelSelection;

/** Gaussian coverage feathering in source-pixel units; boundary samples repeat edge coverage. */
export async function featherPixelSelection(selection: PixelSelection, sigma: number): Promise<PixelSelection>;

/** Apply coverage without flattening the source surface or its later paint strokes. */
export function fillPixels(image: PixelBuffer, color: PixelColor, options: {
    selection?: PixelSelection;
    mode?: "source-over" | "copy" | "destination-out" | "source-atop";
} = {}): void;

/** Composition A × B applies B first, then A. */
export function multiplyMatrices(left: readonly number[], right: readonly number[]): AffineMatrix;

function matrixFromTransform(value: Partial<Transform>, pivot: Pivot = { x: 0, y: 0 }): AffineMatrix;

function invertMatrix(value: readonly number[]): AffineMatrix;

function transformPoint(value: readonly number[], point: Pick<Point, "x" | "y">): {
    x: number;
    y: number;
};

function solveTwoBoneIK(origin: {
    x: number;
    y: number;
}, target: {
    x: number;
    y: number;
}, upperLength: number, lowerLength: number, bend: 1 | -1 = 1): TwoBoneSolution;