@pixerate/editor 0.102.0 → 0.104.0

package/dist/export-BLpMyCYg.d.ts

@@ -0,0 +1,3139 @@
+import { e as RasterLayerBase, f as RasterMask$1, b as RasterPixelLayer, G as GroupBlendMode, g as GlobalLight, E as EffectPattern, I as Interpolation, h as LayerLocation$1, L as LayerLocks, i as LayerEffect, j as LayerEffects, d as RasterSources, c as RasterCompositor, k as CompositorOptions, l as LayerEffectKind } from './compositor-B1ZrKR89.js';
+import { P as PixelSurface, B as BlendMode, a as TiledSurface } from './surface-AfHCH7BR.js';
+import { Q as Quad, a as WarpMesh, V as Vec2, A as AffineMatrix, H as Homography } from './types-CwMPoRMU.js';
+import { B as BrushSettings, M as MixerSettings, a as MixerLoad, c as StrokeCoverage, d as MixerTarget, e as MixerStroke, f as StrokeApply, S as StrokePoint } from './mixer-DG_9Yu2W.js';
+import { W as WarpPreset } from './warp-CWHZzE3x.js';
+
+/**
+ * A selection: one 8-bit coverage value per image pixel (0 = not selected, 255 = fully
+ * selected), row-major over the whole source image in natural pixels — the same space as the
+ * crop box and annotations. Soft values are partial selection (feathered or anti-aliased edges).
+ *
+ * Treat a mask as immutable: every operation returns a new one, so history entries can share
+ * them without copying.
+ */
+interface SelectionMask {
+    readonly width: number;
+    readonly height: number;
+    readonly data: Uint8Array;
+    /** Bounding box of the non-zero coverage, or `null` when nothing is selected. */
+    readonly bounds: CropBox | null;
+}
+/** How a new selection combines with the current one. */
+type SelectionMode = 'replace' | 'add' | 'subtract' | 'intersect';
+declare const SELECTION_MODES: readonly SelectionMode[];
+declare function isSelectionMode(value: unknown): value is SelectionMode;
+/** Parses `replace|add|subtract|intersect`; anything else is `replace`. */
+declare function parseSelectionMode(value: unknown): SelectionMode;
+/** RGBA pixels, 8 bits per channel, straight alpha (an `ImageData` qualifies). */
+interface PixelBuffer {
+    width: number;
+    height: number;
+    data: ArrayLike<number>;
+}
+/** Serialized selection: a run-length encoding of the 8-bit coverage. */
+interface SerializedSelection {
+    width: number;
+    height: number;
+    /** `r1:` + base64 of (value byte, LEB128 run length) pairs. */
+    rle: string;
+}
+/** Bounding box of non-zero bytes. */
+declare function computeSelectionBounds(width: number, height: number, data: ArrayLike<number>): CropBox | null;
+/** Wraps coverage bytes (taken over, not copied) as a selection, computing its bounds. */
+declare function createSelectionMask(width: number, height: number, data?: Uint8Array): SelectionMask;
+/** Select › All. */
+declare function fullSelection(width: number, height: number): SelectionMask;
+declare function isSelectionEmpty(mask: SelectionMask | null | undefined): boolean;
+/** Coverage at a pixel, 0..1 (0 outside the image). */
+declare function selectionValueAt(mask: SelectionMask, x: number, y: number): number;
+/** 8-bit value of a coverage (clamped and rounded; NaN → 0). */
+declare function coverageToByte(v: number): number;
+/** A selection from 0..1 coverage. */
+declare function selectionFromCoverage(width: number, height: number, coverage: ArrayLike<number>): SelectionMask;
+/** The selection's coverage as 0..1 floats. */
+declare function selectionToCoverage(mask: SelectionMask): Float32Array;
+/** Number of fully-or-partly selected pixels, weighted by coverage (Σ coverage). */
+declare function selectionArea(mask: SelectionMask | null | undefined): number;
+/**
+ * Combines `next` with `prev` by `mode` (8-bit, exact: combining a mask with itself is a no-op).
+ * Add is the maximum, Subtract `max(prev − next, 0)`, Intersect the minimum. A missing `prev`
+ * reads as nothing selected. Returns `null` when nothing remains selected.
+ */
+declare function combineSelections(prev: SelectionMask | null | undefined, next: SelectionMask, mode: SelectionMode): SelectionMask | null;
+/** Select › Inverse. */
+declare function invertSelection(mask: SelectionMask): SelectionMask;
+/** Bilinear resample to another size (e.g. an AI mask returned at a different resolution). */
+declare function resizeSelection(mask: SelectionMask, width: number, height: number): SelectionMask;
+type SelectionChannel = 'alpha' | 'luminance' | 'red' | 'green' | 'blue';
+/**
+ * A selection from an image: by default its luminance (white = selected, the usual convention
+ * of segmentation masks), or one channel. Partly transparent pixels count as black for
+ * luminance, so a mask PNG with transparency works either way.
+ */
+declare function selectionFromPixels(pixels: PixelBuffer, options?: {
+    channel?: SelectionChannel;
+    invert?: boolean;
+    threshold?: number;
+}): SelectionMask;
+/** The selection as RGBA pixels: grey (white = selected, opaque) or white with coverage as alpha. */
+declare function selectionToPixels(mask: SelectionMask, as?: 'gray' | 'alpha'): {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+};
+/** Run-length encodes coverage bytes: `r1:` + base64 of (value, LEB128 run length) pairs. */
+declare function encodeSelectionRle(data: Uint8Array): string;
+/** Decodes {@link encodeSelectionRle}; throws unless the runs cover exactly `length` bytes. */
+declare function decodeSelectionRle(rle: string, length: number): Uint8Array;
+declare function serializeSelection(mask: SelectionMask): SerializedSelection;
+/** Restores a {@link SerializedSelection}; throws on damaged data. */
+declare function deserializeSelection(value: unknown): SelectionMask;
+/** A short, stable hash of a string or bytes (FNV-1a, 32-bit, hex) for cache keys. */
+declare function hashMaskContent(content: string | Uint8Array): string;
+
+/**
+ * The image editor's layer stack: pixel, adjustment, group and annotation layers in one ordered
+ * tree (bottom to top), all in document space (natural pixels of the document).
+ *
+ * Layer objects are immutable. Every change builds new objects along the path from the root to
+ * the changed layer and shares everything else, so undo history, the compositor's caches and
+ * serialization can compare layers by identity.
+ */
+
+/** Blend modes of a layer; groups also accept `pass-through`. */
+type LayerBlendMode = GroupBlendMode;
+
+/**
+ * A layer mask (see the raster module's `RasterMask`) whose parametric `source` is a depth map:
+ * a depth mask is generated from it instead of painted, and its surface is unused.
+ */
+type RasterMask = RasterMask$1<DepthMaskOptions>;
+interface LayerBase extends RasterLayerBase {
+    mask?: RasterMask;
+}
+/** The base sliders of the old document-level adjustments, as a filter on one layer. */
+interface DevelopSettings {
+    brightness: number;
+    contrast: number;
+    saturation: number;
+    exposure: number;
+    temperature: number;
+    tint?: number;
+    /** Rendering process (see `ImageAdjustments.process`). */
+    process?: 1 | 2;
+}
+type DevelopFilter = {
+    id: string;
+    kind: 'develop';
+    enabled: boolean;
+} & DevelopSettings;
+/** Box blur of `radius` pixels (the old `adjustments.blur`), clamped at the canvas edges. */
+interface BlurFilter {
+    id: string;
+    kind: 'blur';
+    enabled: boolean;
+    radius: number;
+}
+type LayerFilter = DevelopFilter | BlurFilter;
+type LayerFilterKind = LayerFilter['kind'];
+interface PixelLayer extends LayerBase, Omit<RasterPixelLayer, keyof RasterLayerBase> {
+    /** Live filters, applied bottom (first) to top before the mask and blend. */
+    filters?: LayerFilter[];
+    /**
+     * `'document'`: the pixels are the document's source image, unmodified (the Background of an
+     * opened image). Such a layer's `surface` is a placeholder; read its pixels through the
+     * controller. Painting it drops the flag.
+     */
+    source?: 'document';
+}
+type AdjustmentLayerNode<K extends AdjustmentKind = AdjustmentKind> = {
+    [P in K]: LayerBase & {
+        type: 'adjustment';
+        kind: P;
+        params: AdjustmentParamsMap[P];
+    };
+}[K];
+interface GroupLayer extends Omit<LayerBase, 'blend'> {
+    type: 'group';
+    blend: LayerBlendMode;
+    /** Bottom to top. */
+    children: ImageLayer[];
+    /** UI only. */
+    collapsed?: boolean;
+}
+/** One annotation (pen, shape, arrow, text, image) as a layer, drawn by the annotation renderer. */
+interface AnnotationLayer extends LayerBase {
+    type: 'annotation';
+    annotation: Annotation;
+}
+/** A nested layer document: the contents of a smart object made from layers (or an embedded PSD). */
+interface SmartDocument {
+    /** Bottom to top, on a canvas of the contents' `width × height`. */
+    layers: ImageLayer[];
+    globalLight?: GlobalLight;
+    patterns?: EffectPattern[];
+}
+/**
+ * What a smart object places: raster pixels or a nested layer document, at their own pixel size.
+ * Immutable and shared: every instance placed from the same contents (duplicates, linked
+ * instances) holds the same `id`, and replacing or editing the contents updates them all.
+ */
+interface SmartContents {
+    /** Shared by linked instances; independent copies get a fresh one. */
+    id: string;
+    /** File name shown in the UI and written to PSD (`Layer 1.psb`, `photo.png`). */
+    name: string;
+    /** Pixel size of the contents (the placement maps `0..width × 0..height` into the document). */
+    width: number;
+    height: number;
+    /** `raster`: `raster` holds the pixels at (0, 0); `document`: `document` holds the layers. */
+    kind: 'raster' | 'document';
+    raster?: PixelSurface;
+    document?: SmartDocument;
+    /**
+     * The file the contents came from (a PSD's embedded file), written back by Export Contents and
+     * PSD export while the contents are unedited. Without `raster` / `document` the file could not
+     * be decoded here (a JPEG outside a browser): the layer keeps its rendered pixels, and changes
+     * that re-render it are refused until `prepareSmartObjects` decodes it.
+     */
+    file?: {
+        bytes: Uint8Array;
+        type: string;
+    };
+    /** Linked to an external file (Photoshop `liFE`): only the embedded preview is held. */
+    linked?: {
+        path: string;
+    };
+}
+/**
+ * Where a smart object's contents land, non-destructively: a warp in the contents' own pixels
+ * (optional) and then the map of the contents' rectangle onto `corners`. Every change re-renders
+ * from the contents, so repeated transforms never degrade.
+ */
+interface SmartPlacement {
+    /** Where the contents' corners land (top-left, top-right, bottom-right, bottom-left), document pixels. */
+    corners: Quad;
+    /** A Bézier warp over the contents' rectangle, control points in contents pixels (missing = none). */
+    warp?: WarpMesh | null;
+    /** Resampling (default bicubic). */
+    interpolation?: Interpolation;
+}
+/**
+ * A Photoshop smart filter we do not model (Gaussian Blur, Camera Raw, …), kept from a PSD so it
+ * is listed, can be hidden, reordered or deleted, and is written back unchanged. It draws nothing.
+ */
+interface PsdSmartFilter {
+    id: string;
+    kind: 'psd';
+    enabled: boolean;
+    /** Photoshop's menu name (`Gaussian Blur...`). */
+    name: string;
+    /** The filter's `filterFX` item descriptor (versioned descriptor bytes), as read. */
+    data: Uint8Array;
+}
+/** One smart filter: a layer filter (or a kept PSD filter) with its own blending over the result below it. */
+type SmartFilter = (LayerFilter | PsdSmartFilter) & {
+    /** How the filter's result blends with the result below it (Photoshop's Blending Options). */
+    blend: BlendMode;
+    /** 0..1 */
+    opacity: number;
+};
+type SmartFilterKind = SmartFilter['kind'];
+/** The smart filter stack of a smart object. */
+interface SmartFilterStack {
+    /** Layer › Smart Filter › Disable Smart Filters (each filter keeps its own `enabled`). */
+    enabled: boolean;
+    /** Bottom (applied first) to top. */
+    filters: SmartFilter[];
+    /**
+     * The one filter mask (document space): where the filtered result shows over the unfiltered
+     * contents. Missing reveals everywhere.
+     */
+    mask?: RasterMask;
+}
+/** PSD data of a smart object kept for round trips (see the PSD module). */
+interface SmartPsdData {
+    /** The placed-layer block as read (`SoLd`, `SoLE` or `PlLd`) and its key. */
+    key: string;
+    data: Uint8Array;
+    /** The instance id (`placed`), which keys the filter-effects cache. */
+    placed?: string;
+}
+/**
+ * A smart object: `contents` placed through `placement`, then the smart filters. `surface` is the
+ * rendered result in document space (offset 0), rebuilt by every change to the contents,
+ * placement or filters; the compositor draws it like a pixel layer's pixels, and masks, effects,
+ * clipping and blend apply on top. Never paint into it: rasterize the layer first.
+ */
+interface SmartObjectLayer extends LayerBase {
+    type: 'smart';
+    contents: SmartContents;
+    placement: SmartPlacement;
+    smartFilters?: SmartFilterStack;
+    /** The rendered pixels (a cache of contents → placement → filters), document space. */
+    surface: PixelSurface;
+    /** Always (0, 0): a smart object moves through its placement. */
+    offset: {
+        x: number;
+        y: number;
+    };
+    /** 0..1, PSD "Fill" (missing = 1). */
+    fillOpacity?: number;
+    psd?: SmartPsdData;
+}
+type ImageLayer = PixelLayer | AdjustmentLayerNode | GroupLayer | AnnotationLayer | SmartObjectLayer;
+type ImageLayerType = ImageLayer['type'];
+/** Which part of the active layer painting targets (`filter-mask`: a smart object's filter mask). */
+type LayerTarget = 'pixels' | 'mask' | 'filter-mask';
+/** A fresh id with `prefix` (`layer`, `flt`, …). */
+declare function newLayerId(prefix?: string): string;
+type LayerLocation = LayerLocation$1<ImageLayer>;
+
+/** The top-level and nested pixel layers. */
+declare function pixelLayers(layers: readonly ImageLayer[]): PixelLayer[];
+/** The develop filter of a pixel layer, if any. */
+declare function developFilter(layer: PixelLayer): DevelopFilter | undefined;
+declare function blurFilter(layer: PixelLayer): BlurFilter | undefined;
+/** True for filters that change pixels (enabled, non-neutral). */
+declare function isActiveFilter(f: LayerFilter): boolean;
+/** True when a filter needs neighbouring pixels (it can't run tile by tile). */
+declare function isSpatialFilter(f: LayerFilter): boolean;
+/** Document-space bounds of a pixel layer's stored tiles, or `null`. */
+declare function pixelLayerBounds(layer: PixelLayer, surface?: PixelSurface): CropBox | null;
+/** Human label of a layer kind. */
+declare function layerTypeLabel(type: ImageLayerType): string;
+/** Layers whose pixels are a surface the compositor draws (pixel layers and smart objects). */
+declare function hasSurface(layer: ImageLayer): layer is PixelLayer | SmartObjectLayer;
+/** Every smart object in the stack (nested contents not included). */
+declare function smartObjectLayers(layers: readonly ImageLayer[]): SmartObjectLayer[];
+
+/**
+ * Schema version 3 of the image editor document: the layer tree, with pixel layers and painted
+ * masks stored as PNG assets (cropped to their content and placed by position), plus the
+ * document-level crop, transform, output opacity, migrated blur and selection.
+ *
+ * Encoding is synchronous and exact (see `png.ts`). Each surface's encoding is memoised, so
+ * saving an unchanged layer again costs nothing.
+ */
+
+declare const LAYERED_SCHEMA_VERSION: 3;
+/** A stored raster mask. Pixels: `asset` (grey PNG) placed at `x`, `y`; elsewhere `defaultValue`. */
+interface SerializedRasterMask {
+    defaultValue: 0 | 255;
+    asset?: string;
+    x?: number;
+    y?: number;
+    density?: number;
+    feather?: number;
+    enabled?: boolean;
+    /** `false`: unlinked from the layer's pixels. */
+    linked?: boolean;
+    source?: DepthMaskOptions;
+}
+interface SerializedLayerBase {
+    id: string;
+    name: string;
+    visible: boolean;
+    opacity: number;
+    blend: string;
+    clipped?: boolean;
+    mask?: SerializedRasterMask;
+    locks?: LayerLocks;
+    effects?: SerializedLayerEffects;
+}
+/** A layer's effects: the effect list as JSON plus the PSD block they came from (base64). */
+interface SerializedLayerEffects {
+    enabled: boolean;
+    scale?: number;
+    items: LayerEffect[];
+    psd?: {
+        key: string;
+        data: string;
+    };
+}
+interface SerializedPixelLayer extends SerializedLayerBase {
+    type: 'pixel';
+    /** Asset id of the pixels (RGBA PNG) placed at `x`, `y` in layer space; missing when empty. */
+    asset?: string;
+    x?: number;
+    y?: number;
+    offset: {
+        x: number;
+        y: number;
+    };
+    fillOpacity?: number;
+    filters?: LayerFilter[];
+    /** `'document'`: the pixels are the document's source image (no asset is stored). */
+    source?: 'document';
+}
+interface SerializedAdjustmentLayer extends SerializedLayerBase {
+    type: 'adjustment';
+    kind: string;
+    params: unknown;
+}
+interface SerializedGroupLayer extends SerializedLayerBase {
+    type: 'group';
+    children: SerializedLayer[];
+    collapsed?: boolean;
+}
+interface SerializedAnnotationLayer extends SerializedLayerBase {
+    type: 'annotation';
+    annotation: Annotation;
+}
+/** A smart filter as stored (a Photoshop filter keeps its descriptor as base64). */
+type SerializedSmartFilter = (LayerFilter | (Omit<PsdSmartFilter, 'data'> & {
+    data: string;
+})) & {
+    blend: string;
+    opacity: number;
+};
+interface SerializedSmartObjectLayer extends SerializedLayerBase {
+    type: 'smart';
+    /** Id of its entry in the document's `smartContents` (shared by linked instances). */
+    contents: string;
+    placement: {
+        corners: Array<{
+            x: number;
+            y: number;
+        }>;
+        warp?: WarpMesh;
+        interpolation?: string;
+    };
+    smartFilters?: {
+        enabled: boolean;
+        filters: SerializedSmartFilter[];
+        mask?: SerializedRasterMask;
+    };
+    /** The rendered pixels (RGBA PNG) at `x`, `y` in document space, so a load does not re-render. */
+    asset?: string;
+    x?: number;
+    y?: number;
+    fillOpacity?: number;
+    /** The PSD placed-layer block kept for round trips (base64). */
+    psd?: {
+        key: string;
+        data: string;
+        placed?: string;
+    };
+}
+/** Smart object contents as stored once per document, referenced by id from every instance. */
+interface SerializedSmartContents {
+    id: string;
+    name: string;
+    width: number;
+    height: number;
+    kind: 'raster' | 'document';
+    /** Raster contents: RGBA PNG asset at (0, 0). */
+    asset?: string;
+    /** Document contents: the nested layers (their assets are in the document's `assets`). */
+    layers?: SerializedLayer[];
+    globalLight?: GlobalLight;
+    patterns?: SerializedPattern[];
+    /** The file the contents came from (base64), written back while unedited. */
+    file?: {
+        type: string;
+        data: string;
+    };
+    linked?: {
+        path: string;
+    };
+}
+type SerializedLayer = SerializedPixelLayer | SerializedAdjustmentLayer | SerializedGroupLayer | SerializedAnnotationLayer | SerializedSmartObjectLayer;
+/** A version 3 document (layers). */
+interface SerializedLayeredImageEditorState {
+    version: 3;
+    /** Canvas size in pixels. */
+    width: number;
+    height: number;
+    /** Bottom to top. */
+    layers: SerializedLayer[];
+    /** Asset id → PNG data URL (or an external reference, see `ImageEditorAssetStore`). */
+    assets: Record<string, string>;
+    activeLayerId: string | null;
+    crop: CropBox | null;
+    transform: ImageTransform;
+    /** Export alpha, 0..1. */
+    opacity: number;
+    /** Blur migrated from a v1 / v2 document with adjustment layers (runs after the layers). */
+    legacyOutputBlur?: number;
+    selection?: SerializedSelection;
+    /** Global light for layer effects (missing = 120°, 30°). */
+    globalLight?: GlobalLight;
+    /** The document's patterns for pattern effects, each an RGBA PNG data URL. */
+    patterns?: SerializedPattern[];
+    /** Contents of the smart objects (nested ones included), each stored once. */
+    smartContents?: SerializedSmartContents[];
+}
+interface SerializedPattern {
+    id: string;
+    name: string;
+    png: string;
+}
+declare function serializePatterns(patterns: readonly EffectPattern[]): SerializedPattern[];
+/** Reads stored patterns, skipping (and reporting in `problems`) any that cannot be decoded. */
+declare function deserializePatterns(raw: unknown, problems?: string[]): EffectPattern[];
+interface EncodedSurface {
+    url: string;
+    x: number;
+    y: number;
+}
+/** The surface's content (non-default pixels) as a PNG data URL and its position, or `null`. */
+declare function encodeSurface(surface: TiledSurface): EncodedSurface | null;
+interface SerializeContext {
+    /** Adds an asset and returns its id. */
+    addAsset(url: string, hint: string): string;
+    /** Stores a smart object's contents (once per id). Without it, smart objects cannot be written. */
+    addContents?(contents: SmartContents): void;
+}
+declare function serializeEffects(effects: LayerEffects): SerializedLayerEffects;
+/** Reads stored effects (leniently: broken effects are dropped), or `undefined`. */
+declare function deserializeEffects(raw: unknown): LayerEffects | undefined;
+declare function serializeLayer(layer: ImageLayer, ctx: SerializeContext): SerializedLayer;
+/** Writes one contents entry (nested layers add their own assets and contents to `ctx`). */
+declare function serializeContents(c: SmartContents, ctx: SerializeContext): SerializedSmartContents;
+/**
+ * Serializes a layer tree with inline assets (asset ids are derived from layer ids). Smart object
+ * contents go to `smartContents`, once each (present only when there are smart objects).
+ */
+declare function serializeLayers(layers: readonly ImageLayer[]): {
+    layers: SerializedLayer[];
+    assets: Record<string, string>;
+    smartContents?: SerializedSmartContents[];
+};
+/**
+ * Where a host keeps layer pixels outside the JSON (`toJSON({ assets: 'external', store })`):
+ * `put` stores a PNG and returns a reference (a URL, a key) that `get` resolves later.
+ */
+interface ImageEditorAssetStore {
+    put(blob: Blob, info: {
+        id: string;
+        width: number;
+        height: number;
+    }): Promise<string>;
+    get(ref: string): Promise<Blob>;
+}
+/**
+ * Serializes a layer tree with its assets in `store`: each PNG is uploaded once per store (by
+ * content), and `assets` maps asset ids to the store's references.
+ */
+declare function serializeLayersExternal(layers: readonly ImageLayer[], store: ImageEditorAssetStore): Promise<{
+    layers: SerializedLayer[];
+    assets: Record<string, string>;
+    smartContents?: SerializedSmartContents[];
+}>;
+/**
+ * Turns external asset references back into data URLs through `store.get` (data URLs pass through),
+ * so the document loads like an inline one. References that fail are reported and left out.
+ */
+declare function resolveExternalAssets(assets: Record<string, string>, store: ImageEditorAssetStore | undefined, problems: string[]): Promise<Record<string, string>>;
+interface DeserializeContext {
+    assets: Record<string, string>;
+    /** The stored `smartContents` table (smart objects reference it by id). */
+    smartContents?: unknown[];
+    /** Canvas size, for re-rendering a smart object stored without its pixels (default 1 × 1). */
+    canvas?: {
+        width: number;
+        height: number;
+    };
+    /** @internal Contents read so far by id (`null` while being read). */
+    contentsMemo?: Map<string, SmartContents | null>;
+    /** Decodes an asset (PNG data URL by default). Throw for an unusable asset. */
+    decodeAsset?(ref: string, channels: 1 | 4): {
+        width: number;
+        height: number;
+        data: ArrayLike<number>;
+    };
+    /** Problems found while reading (unknown kinds, broken assets); the rest still loads. */
+    problems: string[];
+}
+/** Decodes a PNG data URL into pixels of `channels` bytes each. */
+declare function decodePngDataUrl(url: string, channels: 1 | 4): {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+};
+declare function deserializeLayer(raw: unknown, ctx: DeserializeContext): ImageLayer | null;
+/** Reads a stored layer tree (layers that cannot be read are dropped and reported). */
+declare function deserializeLayers(raw: unknown, ctx: DeserializeContext): ImageLayer[];
+
+/** Display bins of a histogram. */
+declare const HISTOGRAM_BINS = 256;
+interface ImageHistogram {
+    /** 256-bin counts per channel. */
+    red: Uint32Array;
+    green: Uint32Array;
+    blue: Uint32Array;
+    /** 256-bin counts of Rec.709 luma `round(0.2126 R + 0.7152 G + 0.0722 B)` of the encoded values. */
+    luminance: Uint32Array;
+    /** Visible pixels counted (alpha > 0). Each counts once, partially transparent ones included. */
+    samples: number;
+    /** Fully transparent pixels, excluded from every bin. */
+    transparent: number;
+    /** Per channel (R, G, B): visible pixels at exactly 0. */
+    shadows: [number, number, number];
+    /** Per channel (R, G, B): visible pixels at exactly 255. */
+    highlights: [number, number, number];
+    /** Largest bin count over R, G, B and luminance (for scaling a plot). */
+    max: number;
+}
+interface PixelSource {
+    data: ArrayLike<number>;
+    width?: number;
+    height?: number;
+}
+/**
+ * Per-channel and luminance histograms of straight 8-bit RGBA pixels (an `ImageData` or anything
+ * with `data`), with clipping counts at the exact endpoints. Transparent pixels cannot add
+ * phantom peaks: they are counted separately and excluded.
+ */
+declare function computeHistogram(imageData: PixelSource): ImageHistogram;
+type HistogramChannel = 'red' | 'green' | 'blue' | 'luminance';
+/**
+ * An SVG path (`M … Z`) of one channel scaled into a `width` × `height` box, bins left to right,
+ * counts up from the bottom. `scale: 'sqrt'` (default) keeps small populations visible.
+ */
+declare function histogramPath(histogram: ImageHistogram, channel: HistogramChannel, width: number, height: number, options?: {
+    scale?: 'linear' | 'sqrt';
+    max?: number;
+}): string;
+
+/**
+ * The image editor's compositor: the raster engine (`@pixerate/editor/raster`) with the photo
+ * layer kinds plugged in. Adjustment layers filter what is below them (a run of adjacent ones is
+ * one float pass with one rounding at the end, exactly as `applyAdjustmentLayers` does, so a
+ * document migrated from adjustment layers renders identically); annotation layers are drawn by
+ * the host; pixel layers can carry develop and blur filters; masks can be depth masks.
+ */
+
+/** What the compositor needs from its host besides the layers. */
+interface CompositorSources extends RasterSources {
+    /** The pixels of a pixel layer or smart object (resolves layers whose pixels are the document source). */
+    surfaceOf?(layer: PixelLayer | SmartObjectLayer): PixelSurface;
+    /**
+     * A parametric mask's depth map as RGBA at canvas size (the red channel is the depth), or
+     * `null` while it is unavailable (the mask then reveals everything).
+     */
+    depthMap?(source: DepthMaskOptions): {
+        width: number;
+        height: number;
+        data: ArrayLike<number>;
+    } | null;
+    /** Draws one annotation into RGBA for `rect` (canvas hosts only); `null` when unavailable. */
+    rasterizeAnnotation?(annotation: Annotation, rect: CropBox): Uint8ClampedArray | null;
+}
+/** The `AdjustmentLayer` shape `applyAdjustmentLayers` evaluates, for a node (memoised). */
+declare function adjustmentNodeAsLayer(node: AdjustmentLayerNode): AdjustmentLayer;
+/** Evaluates a depth mask (see `applyDepthMask`) into one coverage byte per depth sample. */
+declare function depthMaskAlpha(depth: number, options: DepthMaskOptions): number;
+/** Runs layer filters (develop, blur) over RGBA `data` (`width × height`) in place, bottom first. */
+declare function runLayerFilters(data: Uint8ClampedArray, width: number, height: number, filters: readonly LayerFilter[]): void;
+/** The per-tile compositor for image editor layer stacks (see the raster module for the caches). */
+declare class LayerCompositor extends RasterCompositor<ImageLayer, CompositorSources> {
+    constructor(options?: CompositorOptions);
+}
+
+interface RenderOptions {
+    viewportWidth?: number;
+    viewportHeight?: number;
+    showCropOverlay?: boolean;
+    showSelectionOverlay?: boolean;
+    interactive?: boolean;
+    draftAnnotation?: Annotation | null;
+    draftCrop?: CropBox | null;
+    /** Viewport fit mode: 'contain' scales to full viewport bounds; 'margin' scales to 85% with 1.0 cap (default). */
+    fit?: ImageEditorFit;
+    /**
+     * How the active selection is shown: marching ants (default when there is a selection),
+     * a Quick Mask tint over the unselected area (default when `state.quickMask`), or not at all.
+     */
+    selectionDisplay?: 'ants' | 'quickMask' | 'none';
+    /** Dash offset of the marching ants in screen pixels (animate it to make them march). */
+    antsOffset?: number;
+    /** A selection being drawn (e.g. a lasso), shown as a dashed outline in natural pixels. */
+    draftSelectionPath?: ImagePoint[] | null;
+    /** Document rectangles that are the only change since the last render (strokes); recomposites only there. */
+    dirty?: CropBox[];
+    /** The layer being edited: tiles keep a checkpoint below it so strokes and drags on it start there. */
+    checkpointLayerId?: string | null;
+    /** The paint tools' cursor: a circle of `diameter` px at (`x`, `y`) in natural pixels. */
+    brushCursor?: {
+        x: number;
+        y: number;
+        diameter: number;
+    } | null;
+    /** Free Transform's frame, handles and reference point in natural pixels (`FreeTransformTool.overlay()`). */
+    freeTransform?: {
+        outline: ImagePoint[];
+        handles: ImagePoint[];
+        reference: ImagePoint;
+        /** Warp mode: the mesh's grid lines as cubics, its anchors, and handles with their anchors. */
+        warp?: {
+            curves: ImagePoint[][];
+            anchors: ImagePoint[];
+            handles: Array<{
+                point: ImagePoint;
+                anchor: ImagePoint;
+            }>;
+        };
+    } | null;
+}
+/**
+ * Image Cache to avoid refetching HTMLImageElement objects repeatedly during re-renders.
+ */
+declare class ImageCache {
+    private cache;
+    get(src: string): Promise<HTMLImageElement>;
+    set(src: string, img: HTMLImageElement): void;
+    /** The loaded image for `src`, or `undefined` while it is not loaded yet. */
+    peek(src: string): HTMLImageElement | undefined;
+    clear(): void;
+}
+declare const globalImageCache: ImageCache;
+/**
+ * Renders an image with all its transformations, filters, depth masks, and annotations
+ * to a target HTMLCanvasElement.
+ */
+declare class ImageEditorRenderer {
+    imageCache: ImageCache;
+    private cachedBaseCanvas;
+    private cachedBaseKey;
+    /**
+     * Histogram of the last viewport base render (after adjustments and layers, before
+     * annotations); `null` until a render with pixel access has happened.
+     */
+    previewHistogram: ImageHistogram | null;
+    /** Called whenever the viewport base image is re-rendered with the new histogram. */
+    onPreviewHistogram?: (histogram: ImageHistogram | null) => void;
+    private sourceIds;
+    private nextSourceId;
+    /**
+     * The viewport's compositor. It only ever composites the viewport's stack, so its tile cache can
+     * trust dirty rectangles; exports use `exportCompositor`.
+     */
+    compositor: LayerCompositor;
+    private exportCompositor;
+    /** How the host resolves layer pixels (set by the controller). */
+    layerSources?: LayerSourcesHost;
+    /**
+     * Debug / test switch: `'legacy'` forces the old base path for documents that still have the
+     * v1 / v2 shape, `'layers'` forces the compositor. Default: chosen per document.
+     */
+    baseRoute: 'auto' | 'legacy' | 'layers';
+    /** Which path the last base render took. */
+    lastBaseRoute: 'legacy' | 'layers' | null;
+    private comp;
+    private depthMaps;
+    private assetVersion;
+    private scratch;
+    private cachedPostCanvas;
+    private cachedPostKey;
+    private cachedPostHistogram;
+    /**
+     * Helper to create a canvas element safely in browser/JSDOM.
+     */
+    createCanvas(width: number, height: number): HTMLCanvasElement;
+    /**
+     * Renders the editor state onto a canvas (viewport or preview).
+     */
+    renderToCanvas(targetCanvas: HTMLCanvasElement, imageSource: CanvasImageSource | string, state: ImageEditorState, options?: RenderOptions): Promise<void>;
+    /**
+     * Draws `region` of the source image with rotation/flip applied, then pixel adjustments
+     * and the depth mask (which receives the identical transform so it stays aligned).
+     */
+    private renderBaseImage;
+    /** Which base path renders `state` (see `needsLegacyBase`). */
+    private chooseRoute;
+    /** Compositor sources for a `width × height` canvas: layer pixels, depth maps and annotation rasterizing. */
+    compositorSources(width: number, height: number): CompositorSources;
+    /** Loads what the compositor reads synchronously: depth maps (at canvas size) and annotation images. */
+    /** Loads depth maps and annotation images the compositor reads synchronously. */
+    prepareLayerAssets(layers: readonly ImageLayer[], width: number, height: number): Promise<void>;
+    /** Whether annotation layers can be rasterized here (a 2D canvas with pixel access). */
+    canRasterize(): boolean;
+    /** One annotation drawn into a tile-sized RGBA buffer at `rect` (document space), or `null` without a canvas. */
+    private rasterizeAnnotation;
+    private putTile;
+    /**
+     * Brings the viewport's composite canvas (document space, covering `region`) up to date,
+     * uploading only the tiles that changed since the last render.
+     */
+    private updateComposite;
+    /**
+     * The base canvas of a layered document: the composite drawn through the base projection (crop,
+     * rotation, flips at scale 1), then output opacity and the migrated blur, which run in the output
+     * frame. Cached until the composite or those settings change.
+     */
+    private layeredBase;
+    /** Output opacity then the migrated blur, in place on a base canvas; returns its histogram. */
+    private applyPost;
+    private publishHistogram;
+    private quickMaskCache;
+    private outlineCache;
+    /** Rubylith over the unselected area, drawn in natural image space. */
+    private drawQuickMask;
+    /** Marching ants: a white line under a black dashed one, one screen pixel wide. */
+    private drawAnts;
+    private drawDraftPath;
+    private getSourceId;
+    /**
+     * Draws an individual annotation onto the canvas.
+     */
+    drawAnnotation(ctx: CanvasRenderingContext2D, ann: Annotation): Promise<void>;
+    /**
+     * Scalar fallback for blend modes the canvas cannot composite (Photoshop soft light, linear /
+     * vivid / pin light, hard mix, subtract, divide, darker / lighter colour, linear burn / dodge):
+     * draws the annotation on a same-size layer with the same transform, blends it into a copy of
+     * the target's pixels with `blendImageData`, and copies the result back inside the current clip.
+     */
+    private drawAnnotationBlended;
+    private drawAnnotationContent;
+    /** Draws an annotation synchronously; an image annotation draws `img` (skipped when `null`). */
+    drawAnnotationShape(ctx: CanvasRenderingContext2D, ann: Annotation, img: CanvasImageSource | null): void;
+    /**
+     * Draws selection box around active annotation.
+     */
+    private drawAnnotationSelection;
+    /** @deprecated Use the standalone `getAnnotationBounds` from the geometry module. */
+    getAnnotationBounds(ann: Annotation): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /**
+     * Draws a rule-of-thirds crop grid overlay. All rectangles come from
+     * `getViewportMetrics`, i.e. the crop box projected through rotation/flip.
+     */
+    private drawCropOverlay;
+    private drawFittedImage;
+    /**
+     * Performs an export render at exact pixel dimensions without zoom/pan viewport offsets.
+     */
+    renderExport(imageSource: CanvasImageSource | string, state: ImageEditorState, options?: ExportOptions): Promise<HTMLCanvasElement>;
+    /**
+     * Generates a strictly binary mask canvas (white = area to regenerate, black = keep) in
+     * natural image pixel space of the current source image — the same space the crop box
+     * and annotations are stored in. Pair it with `toSourceDataURL()` for AI inpainting.
+     */
+    renderMask(state: ImageEditorState, options?: {
+        useAnnotations?: boolean;
+        useCrop?: boolean;
+        useSelection?: boolean;
+    }): Promise<HTMLCanvasElement>;
+    private drawAnnotationMask;
+}
+/** What the renderer asks its host (the controller) about layer pixels. */
+interface LayerSourcesHost {
+    surfaceOf(layer: PixelLayer): PixelSurface;
+    sourceIsOpaque(): boolean;
+    version(): string;
+    /** The document's global light for layer effects. */
+    globalLight?(): GlobalLight | undefined;
+    /** A document pattern for pattern effects (built-in patterns are found without it). */
+    pattern?(id: string): EffectPattern | null;
+}
+
+interface ShapeSelectionOptions {
+    /** Partial coverage along the edge (default true). */
+    antiAlias?: boolean;
+}
+/**
+ * Even-odd polygon coverage over a `width × height` image: exact horizontal coverage on 4
+ * sub-rows per pixel row (1 without anti-aliasing, where a pixel is in when its centre is).
+ * Each sub-row only tests the edges that cross it (an active edge list over edges sorted by
+ * their top), so the cost is about pixels + edges × rows they span.
+ */
+declare function polygonCoverage(points: readonly ImagePoint[], width: number, height: number, antiAlias?: boolean): Float32Array;
+/** Lasso / polygonal lasso: an even-odd polygon in natural image pixels. */
+declare function polygonSelection(width: number, height: number, points: readonly ImagePoint[], options?: ShapeSelectionOptions): SelectionMask;
+/** Normalises a rectangle with a negative width or height. */
+declare function normalizeRect(rect: CropBox): CropBox;
+/** Rectangular marquee. Fractional edges get partial coverage when anti-aliased. */
+declare function rectSelection(width: number, height: number, rect: CropBox, options?: ShapeSelectionOptions): SelectionMask;
+/** The ellipse inscribed in `rect` as a polygon fine enough that its chords stay within 0.05 px. */
+declare function ellipsePoints(rect: CropBox): ImagePoint[];
+/** Elliptical marquee inscribed in `rect`. */
+declare function ellipseSelection(width: number, height: number, rect: CropBox, options?: ShapeSelectionOptions): SelectionMask;
+
+/** How the magic wand measures colour difference. */
+type ColorDistance = 'rgb' | 'perceptual';
+interface MagicWandOptions {
+    /**
+     * 0..255. `rgb`: the largest per-channel difference in levels (alpha included), as
+     * Photoshop's wand. `perceptual`: CIE76 ΔE*ab, with 255 ≙ ΔE 100. Default 32.
+     */
+    tolerance?: number;
+    /** Only the 4-connected region around the seed (default true); otherwise every similar pixel. */
+    contiguous?: boolean;
+    /** Soft one-pixel fringe on the edge (default true). */
+    antiAlias?: boolean;
+    /** Default `rgb`. */
+    distance?: ColorDistance;
+}
+/** CIE Lab (D65) of an 8-bit sRGB colour. */
+declare function srgb8ToLab(r: number, g: number, b: number): [number, number, number];
+/**
+ * Magic wand: pixels similar to the seed pixel. Contiguous mode is a scanline span fill with an
+ * explicit stack (fill a run, then scan the rows above and below it for new runs), so it is
+ * linear in the pixels visited and never recurses. An empty selection when the seed is outside.
+ */
+declare function magicWand(pixels: PixelBuffer, seed: ImagePoint, options?: MagicWandOptions): SelectionMask;
+/** One Color Range sample: a colour (0..255 levels or `#rrggbb`) and, optionally, where it was picked. */
+interface ColorRangeSample {
+    color: readonly [number, number, number] | string;
+    at?: ImagePoint;
+}
+interface ColorRangeOptions {
+    /** 0..200 levels (default 40): coverage falls off linearly to 0 at `fuzziness + 1` levels. */
+    fuzziness?: number;
+    /**
+     * Localized Color Clusters: a sample with a position also fades with distance from it,
+     * reaching 0 at this many pixels.
+     */
+    localized?: number;
+}
+/**
+ * Select › Color Range › Sampled Colors: each pixel takes its best match over the samples; a
+ * match falls off linearly with the largest per-channel difference, `1 − d / (fuzziness + 1)`.
+ * Transparent pixels are never selected.
+ */
+declare function colorRange(pixels: PixelBuffer, samples: readonly ColorRangeSample[], options?: ColorRangeOptions): SelectionMask;
+type ToneRangePreset = 'shadows' | 'midtones' | 'highlights';
+/** Luma bounds (0..255, Rec. 601) of the tonal presets. */
+declare const TONE_RANGE_PRESETS: Record<ToneRangePreset, [number, number]>;
+/**
+ * Select › Color Range › Shadows / Midtones / Highlights: pixels whose luma lies in `lo..hi` are
+ * selected; outside, selection falls off linearly to 0 over `falloff` levels.
+ */
+declare function toneRange(pixels: PixelBuffer, range: ToneRangePreset | readonly [number, number], falloff?: number): SelectionMask;
+/**
+ * Select › Color Range › Reds … Magentas (`center` 0, 60, …, 300°): closeness of hue (full at
+ * the centre, none 60° away) × chroma × (2 − max), so neutrals are never selected.
+ */
+declare function hueRange(pixels: PixelBuffer, center: number): SelectionMask;
+
+/** Distance reported for every pixel when there is no seed at all. */
+declare const EMPTY_DISTANCE = 10000000000;
+/**
+ * Exact Euclidean distance from every pixel centre to the nearest seed pixel centre (row-major
+ * `inside`, non-zero = seed): nearest seeds along columns, then the lower envelope of parabolas
+ * along rows (Felzenszwalb & Huttenlocher). Linear in the pixel count.
+ */
+declare function distanceTransform(inside: ArrayLike<number | boolean>, width: number, height: number): Float32Array;
+/** Grows coverage (0..1) by `r` pixels: covered when the nearest selected centre is ≤ r away (fractional r → partial). */
+declare function expandCoverage(m: ArrayLike<number>, w: number, h: number, r: number): Float32Array;
+/** Shrinks coverage by `r` pixels (expands the inverse). */
+declare function contractCoverage(m: ArrayLike<number>, w: number, h: number, r: number): Float32Array;
+/**
+ * Select › Modify › Border: a soft band `2r` wide centred on the edge. A pixel `D` away (centre
+ * to centre) from the nearest pixel on the other side of the edge is selected `1 − (D − 1) / r`.
+ */
+declare function borderCoverage(m: ArrayLike<number>, w: number, h: number, r: number): Float32Array;
+/**
+ * Select › Modify › Smooth: box average of radius `round(r)` with replicated edges, then
+ * re-thresholded at ½ — specks drop, corners round, straight edges stay hard.
+ */
+declare function smoothCoverage(m: ArrayLike<number>, w: number, h: number, r: number): Float32Array;
+/** Select › Modify › Feather: Gaussian blur with σ = radius (as Photoshop), zero beyond the image. */
+declare function featherCoverage(m: ArrayLike<number>, w: number, h: number, radius: number): Float32Array;
+/** Grey dilation (`grow`) or erosion with a square of radius `r`, separable, O(1) per pixel. */
+declare function greyMorphology(src: ArrayLike<number>, w: number, h: number, r: number, grow: boolean): Float32Array;
+/**
+ * Grows (positive) or shrinks (negative) soft coverage by a fractional distance: whole pixels
+ * use one morphology, the remainder blends with the next pixel, so 0.3 px differs from 1 px.
+ */
+declare function shiftCoverage(src: ArrayLike<number>, w: number, h: number, amount: number): Float32Array;
+type SelectionModifyOp = 'grow' | 'shrink' | 'feather' | 'border' | 'smooth';
+declare const SELECTION_MODIFY_OPS: readonly SelectionModifyOp[];
+/** Select › Modify (grow = Expand, shrink = Contract, feather, border, smooth) by `radius` pixels. */
+declare function modifySelection(mask: SelectionMask, op: SelectionModifyOp, radius: number): SelectionMask;
+
+/**
+ * Refine Edge / Select and Mask parameters (Photoshop's units). Refinement is edge-aware: within
+ * `radius` pixels of the mask's edge the coverage is re-estimated from the image with a colour
+ * guided filter (He et al.), so a coarse or misaligned mask (e.g. an AI segmentation) follows
+ * the real edges of the image.
+ */
+interface RefineEdgeParams {
+    /** Edge-detection band radius in pixels (0 = no edge detection). */
+    radius?: number;
+    /** Narrow the band where the image edge is sharp (hair stays soft, hard edges stay hard). */
+    smartRadius?: boolean;
+    /** 0..100: rounds jagged edges. */
+    smooth?: number;
+    /** Pixels of Gaussian softening. */
+    feather?: number;
+    /** 0..100: hardens soft edges. */
+    contrast?: number;
+    /** −100..100: moves the edge out (positive) or in; 100 % is `max(radius, 4)` pixels. */
+    shiftEdge?: number;
+}
+declare const DEFAULT_REFINE_EDGE_PARAMS: Required<RefineEdgeParams>;
+/** Guided-filter regulariser (colour guide, samples in 0..1). */
+declare const GUIDED_FILTER_EPS = 0.0001;
+/** Clamped, complete parameters. */
+declare function normalizeRefineEdgeParams(p?: RefineEdgeParams): Required<RefineEdgeParams>;
+/** Pixels around the mask's content that refinement can read or write. */
+declare function refineEdgeHalo(params?: RefineEdgeParams): number;
+/** Box mean of radius `r` (window clipped to the image, divided by its pixel count). O(1) per pixel. */
+declare function boxMean(src: ArrayLike<number>, w: number, h: number, r: number): Float32Array;
+/**
+ * Guided filter with a colour guide (He et al., Eq. 19–21: `a_k = (Σ_k + εU)⁻¹ cov_k(I, p)`):
+ * filters `p` so that it is locally a linear function of the guide's colour, which makes the
+ * output's edges follow the guide's edges. `guide` is three planes of 0..1 values.
+ */
+declare function guidedFilterColor(guide: readonly [Float32Array, Float32Array, Float32Array], p: Float32Array, w: number, h: number, r: number, eps?: number): Float32Array;
+/**
+ * Per-pixel transition width (pixels) of the guide's luminance: local range over local maximum
+ * gradient in a window of radius `r` (a sharp step gives about 2, a ramp of width L about L).
+ */
+declare function edgeWidth(guide: readonly [Float32Array, Float32Array, Float32Array], w: number, h: number, r: number): Float32Array;
+/**
+ * Refines soft coverage `m` (`w × h`, 0..1) with `guide` (three 0..1 planes, required when
+ * `radius > 0`): edge-aware re-estimation in a band around the edge, then smooth, feather,
+ * contrast and shift edge, in that order.
+ */
+declare function refineCoverage(guide: readonly [Float32Array, Float32Array, Float32Array] | null, m: Float32Array, w: number, h: number, params?: RefineEdgeParams): Float32Array;
+/** Three 0..1 planes of a window of an RGBA buffer. */
+declare function guidePlanes(pixels: PixelBuffer, win?: CropBox): [Float32Array, Float32Array, Float32Array];
+/**
+ * Refine Edge on a selection (or a coarse AI mask loaded as one) against `pixels` (the image,
+ * same size). Work is confined to the mask's bounds grown by {@link refineEdgeHalo}, so a small
+ * selection on a large image stays cheap.
+ */
+declare function refineSelection(pixels: PixelBuffer | null, mask: SelectionMask, params?: RefineEdgeParams): SelectionMask;
+
+type CropHandle = 'nw' | 'ne' | 'se' | 'sw' | 'n' | 's' | 'e' | 'w' | 'inside' | null;
+interface ViewportMetrics {
+    vpWidth: number;
+    vpHeight: number;
+    centerX: number;
+    centerY: number;
+    baseW: number;
+    baseH: number;
+    fitScale: number;
+    renderW: number;
+    renderH: number;
+    totalScale: number;
+    imageRect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    cropRect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+}
+/**
+ * A complete description of the natural-image -> target mapping (see module comment).
+ */
+interface ImageProjection {
+    /** Visible region in natural image pixels (crop box or full image). */
+    region: CropBox;
+    /** Rotation in degrees, normalised to [0, 360). */
+    angle: number;
+    flipH: boolean;
+    flipV: boolean;
+    /** Uniform scale from image pixels to target pixels. */
+    scale: number;
+    /** Target-space point that the centre of `region` maps to. */
+    originX: number;
+    originY: number;
+}
+/** Normalises any rotation in degrees to [0, 360). */
+declare function normalizeAngle(degrees: number): number;
+/** Whether the rotation swaps the displayed width and height. */
+declare function isQuarterTurnSwapped(transform: Pick<ImageTransform, 'rotate'>): boolean;
+/** Size of a region once rotated (bounding box for arbitrary angles). */
+declare function getRotatedSize(width: number, height: number, transform: Pick<ImageTransform, 'rotate'>): {
+    width: number;
+    height: number;
+};
+/** Maps a natural-image point to target space. */
+declare function projectImagePoint(pt: ImagePoint, p: ImageProjection): ImagePoint;
+/** Exact inverse of {@link projectImagePoint}. */
+declare function unprojectCanvasPoint(pt: ImagePoint, p: ImageProjection): ImagePoint;
+/**
+ * Applies the projection to a 2D context so that subsequent drawing in natural image
+ * pixels lands exactly where {@link projectImagePoint} says it does.
+ */
+declare function applyImageProjectionToContext(ctx: Pick<CanvasRenderingContext2D, 'translate' | 'scale' | 'rotate'>, p: ImageProjection): void;
+/** Projects an image-space rectangle and returns its target-space bounding box. */
+declare function projectImageRect(rect: CropBox, p: ImageProjection): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/** Clamps a crop box to the image bounds. */
+declare function clampCropToImage(crop: CropBox, width: number, height: number): CropBox;
+/**
+ * Returns the natural-image -> canvas projection used by the interactive viewport.
+ */
+declare function getViewportProjection(state: ImageEditorState, vpWidth: number, vpHeight: number, isActivelyCropping?: boolean, cropOverride?: CropBox | null): ImageProjection;
+/**
+ * Calculates current viewport projection metrics for canvas <-> image coordinate mapping.
+ * `cropRect` is the on-screen (rotated/flipped) rectangle of the crop box.
+ */
+declare function getViewportMetrics(state: ImageEditorState, vpWidth: number, vpHeight: number, isActivelyCropping?: boolean, cropOverride?: CropBox | null): ViewportMetrics;
+/**
+ * Converts a point on the canvas (in internal canvas pixel space) to natural image pixel
+ * space, accounting for zoom, pan, fit scale, crop offset, rotation and flips.
+ */
+declare function canvasToImagePoint(canvasPt: ImagePoint, state: ImageEditorState, vpWidth: number, vpHeight: number, isActivelyCropping?: boolean): ImagePoint;
+/**
+ * Converts a point in natural image pixel space to internal canvas pixel space.
+ * Exact inverse of {@link canvasToImagePoint}.
+ */
+declare function imageToCanvasPoint(imgPt: ImagePoint, state: ImageEditorState, vpWidth: number, vpHeight: number, isActivelyCropping?: boolean): ImagePoint;
+/**
+ * Converts a crop handle in screen orientation to the equivalent edge/corner of the crop
+ * box in natural image space, or the reverse with `toScreen = true`.
+ */
+declare function mapCropHandle(handle: CropHandle, transform: ImageTransform, toScreen?: boolean): CropHandle;
+/**
+ * Hit-tests the crop box and its corner/edge handles given a canvas point.
+ * The returned handle names the edge/corner of the crop box in natural image space
+ * (what {@link calculateCropDrag} expects); use `getCropCursor(handle, state.transform)`
+ * to obtain the matching on-screen cursor.
+ */
+declare function hitTestCrop(canvasPt: ImagePoint, state: ImageEditorState, vpWidth: number, vpHeight: number, handleThreshold?: number, cropOverride?: CropBox | null): CropHandle;
+/**
+ * Returns CSS cursor style corresponding to a crop handle. Pass the current transform when
+ * the handle comes from {@link hitTestCrop} (image space) so the cursor matches the
+ * on-screen orientation under rotation/flip.
+ */
+declare function getCropCursor(handle: CropHandle, transform?: ImageTransform): string;
+/**
+ * Calculates updated crop rectangle given a drag interaction.
+ */
+declare function calculateCropDrag(startCrop: CropBox, handle: CropHandle, startImgPt: ImagePoint, currentImgPt: ImagePoint, imgWidth: number, imgHeight: number, aspectRatio?: number | null, transform?: ImageTransform): CropBox;
+/**
+ * Calculates bounding box of an annotation.
+ */
+declare function getAnnotationBounds(ann: Annotation): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * Hit tests if a point in image space is within an annotation's bounds.
+ */
+declare function hitTestAnnotation(imgPt: ImagePoint, ann: Annotation, padding?: number): boolean;
+
+/** Properties of a layer mask that leave its pixels intact (Photoshop's Properties › Masks). */
+interface LayerMaskProps {
+    /** 0..1 (default 1): at 0.5 the masked-out areas still get half of the adjustment. */
+    density?: number;
+    /** Gaussian feather σ in pixels, 0..1000 (default 0). */
+    feather?: number;
+    /** Disabled masks are kept but ignored (the layer applies everywhere). Default true. */
+    enabled?: boolean;
+    /**
+     * Layer masks only: `false` unlinks the mask, so moving or transforming the layer's pixels leaves
+     * it in place. Default true. Adjustment-layer masks in canvas space ignore it.
+     */
+    linked?: boolean;
+}
+/**
+ * A clean layer mask from stored data, or `null` when it is unusable. Defaults are left out
+ * (density 1, feather 0, enabled), so a plain mask serializes as `{width, height, rle}`. The
+ * RLE is only decoded when rendering.
+ */
+declare function normalizeLayerMask(raw: unknown): AdjustmentLayerMask | null;
+/** A layer mask holding the selection's pixels (Add Layer Mask › Reveal Selection). */
+declare function layerMaskFromSelection(selection: SelectionMask, props?: LayerMaskProps): AdjustmentLayerMask;
+/** Applies property changes; `undefined` fields keep their value. */
+declare function updateLayerMaskProps(mask: AdjustmentLayerMask, props: LayerMaskProps): AdjustmentLayerMask;
+/** The mask's pixels as a selection (Load Selection from mask), or `null` when the data is damaged. */
+declare function decodeLayerMask(mask: AdjustmentLayerMask): SelectionMask | null;
+/** Cache key of everything about a mask that changes pixels. */
+declare function layerMaskKey(mask: AdjustmentLayerMask | undefined): string;
+/**
+ * The mask's effective coverage (0..1, mask resolution): feathered (σ = feather, borders
+ * replicated), then density applied as `1 − density·(1 − v)`. `null` for a disabled or damaged
+ * mask, meaning "no mask".
+ */
+declare function layerMaskCoverage(mask: AdjustmentLayerMask): Float32Array | null;
+/**
+ * Resamples mask coverage (natural-image aligned, any resolution) into a target raster drawn
+ * through `projection` (the base canvas of the renderer: crop, rotation, flips): each target
+ * pixel centre is unprojected to natural pixels and sampled bilinearly.
+ */
+declare function projectMaskCoverage(coverage: Float32Array, maskWidth: number, maskHeight: number, naturalWidth: number, naturalHeight: number, projection: ImageProjection, targetWidth: number, targetHeight: number): Float32Array;
+/**
+ * Per-layer mask coverage for a render target, keyed by layer id; `undefined` when no layer has
+ * an enabled, valid mask (so mask-free stacks take the exact same path as before).
+ */
+declare function buildLayerMaskPlanes(layers: readonly AdjustmentLayer[] | undefined, naturalWidth: number, naturalHeight: number, projection: ImageProjection, targetWidth: number, targetHeight: number): Map<string, Float32Array> | undefined;
+
+/** A refused layer operation; the message says why and how to fix it. */
+declare class LayerOperationError extends Error {
+    constructor(message: string);
+}
+/** Where a layer goes: above or below a layer (in its group), or at a position in a group. */
+interface LayerPlacement {
+    /** Directly above this layer, in the same group. */
+    aboveId?: string;
+    /** Directly below this layer, in the same group. */
+    belowId?: string;
+    /** Inside this group (at `index`, default the top). */
+    parentId?: string;
+    /** Index in the parent's children (or the top level), 0 = bottom. */
+    index?: number;
+}
+/** The layer with `id`, or a `LayerOperationError` listing the ids that exist. */
+declare function requireLayer(layers: readonly ImageLayer[], id: string): LayerLocation$1<ImageLayer>;
+/** Refuses when the layer is locked for `what` (and always for `all`). */
+declare function requireUnlocked(layer: ImageLayer, what: keyof LayerLocks, action: string): void;
+/** Inserts `layer` at `placement` (default: the top level at `defaultIndex`, or the top). */
+declare function placeLayer(layers: readonly ImageLayer[], layer: ImageLayer, placement?: LayerPlacement, defaultIndex?: number): ImageLayer[];
+/** Removes a layer (refused when it is locked). */
+declare function removeLayer(layers: readonly ImageLayer[], id: string): ImageLayer[];
+/** Moves a layer to `placement`. A group cannot go inside itself. Returns the new stack. */
+declare function moveLayer(layers: readonly ImageLayer[], id: string, placement: LayerPlacement): ImageLayer[];
+/** Every id in a subtree gets a fresh one (for duplicates). */
+declare function withNewIds<T extends ImageLayer>(layer: T): T;
+/** Duplicates a layer (and its children) directly above it. Returns the stack and the copy's id. */
+declare function duplicateLayer(layers: readonly ImageLayer[], id: string, name?: string): {
+    layers: ImageLayer[];
+    id: string;
+};
+/** Properties `setLayerProperties` changes. */
+interface LayerProperties {
+    name?: string;
+    visible?: boolean;
+    /** 0..1 */
+    opacity?: number;
+    /** 0..1, pixel layers only. */
+    fillOpacity?: number;
+    blend?: LayerBlendMode;
+    clipped?: boolean;
+    locks?: LayerLocks;
+    /** Groups only (UI state). */
+    collapsed?: boolean;
+}
+/** Validates and applies property changes to one layer. */
+declare function setLayerProperties(layers: readonly ImageLayer[], id: string, props: LayerProperties): ImageLayer[];
+/**
+ * Puts layers (siblings in one group or the top level) into a new group at the position of the
+ * topmost one, keeping their order. Returns the stack and the group id.
+ */
+declare function groupLayers(layers: readonly ImageLayer[], ids: string[], name?: string): {
+    layers: ImageLayer[];
+    id: string;
+};
+/** Replaces a group by its children (the group's own opacity, blend and mask are dropped). */
+declare function ungroupLayer(layers: readonly ImageLayer[], id: string): {
+    layers: ImageLayer[];
+    ids: string[];
+};
+/** Sets a pixel layer's offset (refused when its position is locked). An unlinked mask stays in place. */
+declare function offsetLayer(layers: readonly ImageLayer[], id: string, offset: {
+    x: number;
+    y: number;
+}): ImageLayer[];
+/** Sets or removes (`null`) a layer's mask. */
+declare function setLayerMask(layers: readonly ImageLayer[], id: string, mask: RasterMask | null): ImageLayer[];
+/** A clean filter from loose input (for tools and the UI). */
+declare function normalizeFilter(raw: Partial<LayerFilter> & {
+    kind: LayerFilter['kind'];
+}, id?: string): LayerFilter;
+/** Adds a filter on top of a pixel layer's filters. A layer has at most one filter of each kind. */
+declare function addLayerFilter(layers: readonly ImageLayer[], id: string, filter: LayerFilter): ImageLayer[];
+/** Changes one filter of a pixel layer (`changes` merged and validated). */
+declare function updateLayerFilter(layers: readonly ImageLayer[], id: string, filterId: string, changes: Record<string, unknown>): ImageLayer[];
+declare function removeLayerFilter(layers: readonly ImageLayer[], id: string, filterId: string): ImageLayer[];
+/** A layer's effects, or an empty, enabled list when it has none. */
+declare function layerEffectsOf(layer: ImageLayer): LayerEffects;
+/** Replaces a layer's effects (validated); `null` or an empty list without a PSD block removes them. */
+declare function setLayerEffects(layers: readonly ImageLayer[], id: string, effects: LayerEffects | null): ImageLayer[];
+/**
+ * Adds an effect of `kind` (Photoshop's defaults with `params` applied) to a layer's effects, at
+ * `index` in the list (default: the end; the first listed of a kind is on top). Returns the stack
+ * and the new effect.
+ */
+declare function addLayerEffect(layers: readonly ImageLayer[], id: string, kind: LayerEffectKind, params?: Record<string, unknown>, index?: number): {
+    layers: ImageLayer[];
+    effect: LayerEffect;
+};
+/** Changes one effect (only the given fields; nested objects replace whole, `null` removes an optional one). */
+declare function updateLayerEffect(layers: readonly ImageLayer[], id: string, effectId: string, changes: Record<string, unknown>): ImageLayer[];
+declare function removeLayerEffect(layers: readonly ImageLayer[], id: string, effectId: string): ImageLayer[];
+/** Sets the master switch and, when given, Scale Effects (0.01..10, 1 = 100 %). */
+declare function setLayerEffectsEnabled(layers: readonly ImageLayer[], id: string, enabled: boolean, scale?: number): ImageLayer[];
+/** A blend mode check for tools. */
+declare function parseBlend(value: unknown, allowPassThrough?: boolean): BlendMode | 'pass-through' | undefined;
+/** The union of two rectangles (either may be null). */
+declare function unionRect(a: CropBox | null, b: CropBox | null): CropBox | null;
+
+interface PsdHeader {
+    psb: boolean;
+    channels: number;
+    height: number;
+    width: number;
+    depth: number;
+    colorMode: number;
+}
+interface PsdRect {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+}
+interface PsdChannel {
+    id: number;
+    /** `null` for a zero-length channel. */
+    compression: number | null;
+    /** Encoded bytes, without the compression field. */
+    data: Uint8Array;
+}
+interface PsdLayerMask {
+    rect: PsdRect;
+    defaultColor: number;
+    flags: number;
+    userDensity?: number;
+    userFeather?: number;
+    vectorDensity?: number;
+    vectorFeather?: number;
+    /** The real (vector-combined) user mask, when present. */
+    real?: {
+        flags: number;
+        background: number;
+        rect: PsdRect;
+    };
+}
+interface PsdTaggedBlock {
+    key: string;
+    data: Uint8Array;
+}
+interface PsdLayerRecord {
+    rect: PsdRect;
+    channels: PsdChannel[];
+    blendKey: string;
+    opacity: number;
+    clipping: number;
+    flags: number;
+    mask?: PsdLayerMask;
+    /** The legacy (Pascal) name; `layerName` prefers `luni`. */
+    legacyName: string;
+    blocks: PsdTaggedBlock[];
+}
+interface PsdResource {
+    id: number;
+    name: string;
+    data: Uint8Array;
+}
+interface PsdFile {
+    header: PsdHeader;
+    colorModeData: Uint8Array;
+    resources: PsdResource[];
+    /** Bottom-most first, as stored. */
+    layers: PsdLayerRecord[];
+    /** The layer count was negative: the merged image's first extra channel is its alpha. */
+    mergedAlpha: boolean;
+    globalBlocks: PsdTaggedBlock[];
+    imageCompression: number;
+    imageData: Uint8Array;
+}
+/** Parses a PSD or PSB. Throws `PsdError` with what was wrong. */
+declare function readPsd(bytes: Uint8Array): PsdFile;
+declare function layerName(rec: PsdLayerRecord): string;
+interface PsdTreeNode {
+    /** Index into `PsdFile.layers` (the folder record for a group). */
+    index: number;
+    children?: PsdTreeNode[];
+}
+/** The layer tree, bottom-most first (the stored order, as in our model), from the `lsct` dividers. */
+declare function layerTree(file: PsdFile): PsdTreeNode[];
+/** One layer channel decoded to `depth`-bit planar bytes, or `undefined` if the layer has none. */
+declare function decodeLayerChannel(file: PsdFile, rec: PsdLayerRecord, id: number): Uint8Array | undefined;
+/** The merged image's channels decoded, planar. */
+declare function decodeMergedImage(file: PsdFile): Uint8Array;
+/** Serializes a file. Channel data must already be encoded; `encodeName` writes legacy (Pascal) names. */
+declare function writePsd(file: PsdFile, encodeName: (s: string) => Uint8Array): Uint8Array;
+
+/** PSD blend keys → our blend modes (`diss` is the one we lack). */
+declare const PSD_BLEND_KEYS: Record<string, LayerBlendMode>;
+/** What happened to one PSD layer on import. */
+interface PsdLayerSummary {
+    name: string;
+    /** Our layer type, or `null` when the layer was dropped. */
+    type: 'pixel' | 'adjustment' | 'group' | null;
+    /** `mapped`: held exactly; `approximated`: imported with losses; `dropped`: left out. */
+    status: 'mapped' | 'approximated' | 'dropped';
+    /** What Photoshop calls it (`pixel`, `type`, `smart-object`, `fill`, `shape`, `Levels` …). */
+    psdKind: string;
+    /** Why it is not `mapped`. */
+    notes: string[];
+    /** Our layer id (when imported). */
+    id?: string;
+    depth: number;
+}
+interface PsdImportResult {
+    width: number;
+    height: number;
+    /** Bottom to top, as in our model. */
+    layers: ImageLayer[];
+    /** One sentence per problem, naming the affected layers. */
+    warnings: string[];
+    /** Every PSD layer, bottom first, a group before its children. */
+    summary: PsdLayerSummary[];
+    /** Pixels per inch, when the file says. */
+    resolution?: number;
+    /** The patterns embedded in the file (`Patt` / `Pat2` / `Pat3`), which pattern effects use. */
+    patterns: EffectPattern[];
+    /** The global light (image resources 1037 and 1049), when the file has one. */
+    globalLight?: GlobalLight;
+    info: {
+        psb: boolean;
+        depth: number;
+        colorMode: string;
+        channels: number;
+    };
+}
+interface PsdImportOptions {
+    /** Makes layer ids (defaults to `psd-<n>`). */
+    newId?: (hint: string) => string;
+    /** Skip decoding pixels (inspection only). */
+    skipPixels?: boolean;
+}
+/** Maps a parsed PSD to our layers. */
+declare function psdToLayers(file: PsdFile, options?: PsdImportOptions): PsdImportResult;
+/** Parses and maps PSD / PSB bytes. Throws `PsdError` for files that cannot be read at all. */
+declare function importPsd(bytes: Uint8Array, options?: PsdImportOptions): PsdImportResult;
+
+/**
+ * Free Transform geometry for the image editor, as pure functions both the UI bindings and the
+ * agent tools use: a transform is the frame being transformed (`box`, document pixels), where its
+ * four corners land (`corners`, TL, TR, BR, BL) and an optional warp mesh over the box. Scale,
+ * rotate, skew and flips keep the corners a parallelogram (an affine map); Distort and Perspective
+ * move them freely (a projective map); Warp bends the box through a Bézier mesh before the corner
+ * map.
+ *
+ * The maths (homographies, meshes, presets) is shared with the vector editor in `src/geom`.
+ */
+
+/** Free Transform modes (Edit › Transform). Scale, rotate and skew stay affine. */
+type FreeTransformMode = 'scale' | 'rotate' | 'skew' | 'distort' | 'perspective' | 'warp';
+declare const FREE_TRANSFORM_MODES: readonly FreeTransformMode[];
+/** The nine reference-point positions of the options bar's locator, over the transformed box. */
+type TransformAnchor = 'top-left' | 'top' | 'top-right' | 'left' | 'center' | 'right' | 'bottom-left' | 'bottom' | 'bottom-right';
+declare const TRANSFORM_ANCHORS: readonly TransformAnchor[];
+declare function isTransformAnchor(value: unknown): value is TransformAnchor;
+/** A transform in progress: the frame, where its corners go and an optional warp over the frame. */
+interface FreeTransformGeometry {
+    /** The frame being transformed, in document pixels (the content bounds when it began). */
+    box: CropBox;
+    /** Where the frame's corners land: top-left, top-right, bottom-right, bottom-left (document pixels). */
+    corners: Quad;
+    /**
+     * A warp applied in the frame's own space before the corner map: its control points are in
+     * document pixels of the untransformed frame (`identityWarpMesh(box)` is no warp).
+     */
+    warp?: WarpMesh | null;
+}
+/** The untransformed geometry of a box. */
+declare function identityTransform(box: CropBox): FreeTransformGeometry;
+/** Where `box`'s corners go under the affine `m`. */
+declare function cornersFromMatrix(box: CropBox, m: AffineMatrix): Quad;
+/** The affine matrix taking `box` onto `corners` when they form a parallelogram, else `null`. */
+declare function matrixFromCorners(box: CropBox, corners: Quad, eps?: number): AffineMatrix | null;
+/** The projective map of the corner move (box → corners), or `null` when the corners are degenerate. */
+declare function transformHomography(geometry: FreeTransformGeometry): Homography | null;
+/** Whether a warp mesh changes anything (not the identity over the box). */
+declare function hasWarp(geometry: FreeTransformGeometry): boolean;
+/** Whether the geometry changes nothing. */
+declare function isIdentityTransform(geometry: FreeTransformGeometry): boolean;
+/**
+ * The forward map of the whole transform (document pixels of the source → document pixels of the
+ * result): the warp over the box, then the corner map. `null` where it is undefined.
+ */
+declare function transformMap(geometry: FreeTransformGeometry): ((p: Vec2) => Vec2 | null) | null;
+/** A point of the transformed box at box fractions (`fx`, `fy`), warp included. */
+declare function transformedPoint(geometry: FreeTransformGeometry, fx: number, fy: number): Vec2 | null;
+/** Where an anchor of the box is after the corner map (the warp ignored). */
+declare function anchorPoint(geometry: FreeTransformGeometry, anchor: TransformAnchor): Vec2;
+/** Bounds of the transformed result's outline (document pixels, not rounded). */
+declare function transformedBox(geometry: FreeTransformGeometry): CropBox | null;
+/** Free Transform as numbers, as Photoshop's options bar shows it. */
+interface TransformParams {
+    /** Width in percent of the frame (default 100; negative flips). */
+    scaleX?: number;
+    /** Height in percent of the frame (default 100; negative flips). */
+    scaleY?: number;
+    /** Rotation in degrees, clockwise (default 0). */
+    rotate?: number;
+    /** Horizontal skew in degrees: vertical edges lean right for positive angles (default 0). */
+    skewX?: number;
+    /** Vertical skew in degrees: horizontal edges lean down for positive angles (default 0). */
+    skewY?: number;
+    /** Move after scaling and rotating, in document pixels (default 0). */
+    dx?: number;
+    dy?: number;
+    /** The fixed point of scale, skew and rotation: an anchor of the frame or a document point (default the centre). */
+    reference?: TransformAnchor | Vec2;
+}
+/** The reference point of params over a box (default its centre). */
+declare function referencePoint(box: CropBox, reference: TransformParams['reference']): Vec2;
+/**
+ * The affine matrix of `params` over `box`: about the reference point, skew, then scale, then
+ * rotate; then the move.
+ */
+declare function matrixFromParams(box: CropBox, params: TransformParams): AffineMatrix;
+/** What the options bar shows for a transform. */
+interface TransformReadout {
+    /** False for Distort, Perspective and Warp: only `bounds` and `corners` then mean anything. */
+    affine: boolean;
+    /** Width and height in percent of the frame. */
+    scaleX: number;
+    scaleY: number;
+    /** Rotation in degrees, clockwise, in (−180, 180]. */
+    rotate: number;
+    /** Horizontal skew in degrees (vertical skew is folded into rotation and scale). */
+    skewX: number;
+    /** Where the reference point is now (document pixels). */
+    x: number;
+    y: number;
+    /** Bounds of the transformed outline. */
+    bounds: CropBox | null;
+    corners: Quad;
+}
+/**
+ * Decomposes a transform for the options bar: the linear part as rotate · scale · skew (QR) with
+ * the given reference point. Non-affine geometry reports its bounds and corners only.
+ */
+declare function describeTransform(geometry: FreeTransformGeometry, reference?: TransformParams['reference']): TransformReadout;
+/**
+ * Corners for a transform given as numbers relative to the current corners: `params` are applied
+ * after the current affine part (when the corners are a parallelogram) about the reference point
+ * of the current geometry, so typing "rotate 15" rotates the box as it is now.
+ */
+declare function applyParams(geometry: FreeTransformGeometry, params: TransformParams): Quad;
+/** Flip of the corners about the box's centre line (horizontal: left ↔ right). */
+declare function flipCorners(geometry: FreeTransformGeometry, axis: 'horizontal' | 'vertical'): Quad;
+/** Inverse of `matrixFromCorners` (box space → document) for mapping a document point back into the box. */
+declare function boxPointOf(geometry: FreeTransformGeometry, p: Vec2): Vec2 | null;
+/** A warp mesh from a preset over the box (null when it changes nothing). */
+declare function presetWarp(box: CropBox, preset: WarpPreset): WarpMesh | null;
+/** Validates a warp mesh for a box: well formed, finite, the right number of points. */
+declare function isValidWarp(mesh: unknown): mesh is WarpMesh;
+/** The geometry's affine map when it is one (no warp, a parallelogram), as a homography; else the projective map. */
+declare function geometryHomography(geometry: FreeTransformGeometry): Homography | null;
+
+/**
+ * Free Transform sessions: what a transform moves (a layer's pixels with its linked mask, a lone
+ * unlinked mask, the selected pixels as a floating piece, a copy of them on a new layer, or just
+ * the selection outline), a live preview while the geometry changes, and one undo step when it is
+ * committed with full-quality resampling.
+ */
+
+/**
+ * What a Free Transform moves:
+ * - `layer`: the layer's pixels with its linked mask (or, with `channel: 'mask'` on an unlinked
+ *   mask, the mask alone);
+ * - `selection`: the selected pixels (and the same part of a linked mask), lifted and committed
+ *   back into the layer; the selection outline moves with them;
+ * - `selection-copy`: Layer via Copy, then the copy is transformed on a new layer above;
+ * - `selection-outline`: Transform Selection, only the outline;
+ * - `auto` (default): `selection` when something is selected, else `layer`.
+ */
+type FreeTransformContent = 'auto' | 'layer' | 'selection' | 'selection-copy' | 'selection-outline';
+declare const FREE_TRANSFORM_CONTENTS: readonly FreeTransformContent[];
+interface FreeTransformInit {
+    /** The layer (default the active one); not needed for `selection-outline`. */
+    layerId?: string;
+    content?: FreeTransformContent;
+    /**
+     * `pixels` (default) moves the pixels with a linked mask; `mask` moves an unlinked mask alone (a
+     * linked one moves with its pixels). Defaults to the active target on the active layer.
+     */
+    channel?: LayerTarget;
+    /** Resampling of the committed result (default bicubic). */
+    interpolation?: Interpolation;
+}
+/** How a live preview is drawn (the UI knows these, the controller doesn't). */
+interface FreeTransformPreview {
+    /** Screen pixels per document pixel: below 1 the preview samples a reduced copy in blocks. */
+    scale?: number;
+    /** Only this part of the document (the visible area) is resampled. */
+    clip?: CropBox;
+}
+/** What a committed transform changed. */
+interface FreeTransformResult {
+    /** The layer that holds the result (the new layer for `selection-copy`; `null` for `selection-outline`). */
+    layerId: string | null;
+    content: Exclude<FreeTransformContent, 'auto'>;
+    /** What moved. */
+    moved: Array<'pixels' | 'mask' | 'selection'>;
+    /** The frame the transform started from (document pixels). */
+    box: CropBox;
+    /** Where the frame's corners went. */
+    corners: FreeTransformGeometry['corners'];
+    /** Document bounds of the moved content after the transform (pixels, or the mask or the outline). */
+    bounds: CropBox | null;
+    /** False when the geometry was the identity and nothing was recorded. */
+    changed: boolean;
+}
+/** @internal What the session needs from the controller. */
+interface FreeTransformHost {
+    layers(): ImageLayer[];
+    activeLayerId(): string | null;
+    activeTarget(): LayerTarget;
+    selection(): SelectionMask | null;
+    canvas(): {
+        width: number;
+        height: number;
+    };
+    /** The pixels a pixel layer or smart object composites (the decoded source for the Background). */
+    pixelsOf(layer: PixelLayer | SmartObjectLayer): TiledSurface;
+    /** Opaque pre-transform snapshot. */
+    capture(): unknown;
+    /** Shows a live state (no history). */
+    show(layers: ImageLayer[], selection: SelectionMask | null, activeLayerId: string | null): void;
+    /** Records `before` as the undo step of the state now shown. */
+    record(before: unknown): void;
+    /** Puts `before` back (no history). */
+    restore(before: unknown): void;
+}
+/** Preview block size for a screen scale: 1 at 100 % and above, then powers of two up to 8. */
+declare function previewStep(scale: number | undefined): number;
+/**
+ * A Free Transform in progress (see `ImageEditorController.beginFreeTransform`). Change the
+ * geometry with `update` (each change shows a live preview without history), then `commit()`
+ * (one undo step, resampled at full quality) or `cancel()` (everything back as it was).
+ */
+declare class FreeTransformSession {
+    private readonly host;
+    readonly content: Exclude<FreeTransformContent, 'auto'>;
+    /** The layer being transformed (`null` for `selection-outline`). */
+    readonly layerId: string | null;
+    /** The new layer of a `selection-copy`. */
+    readonly copyId: string | null;
+    /** The frame (document pixels). */
+    readonly box: CropBox;
+    /** What moves. */
+    readonly moves: ReadonlyArray<'pixels' | 'mask' | 'selection'>;
+    /**
+     * The geometry the transform starts from: the identity over `box`, or for a smart object its
+     * placement (`box` is then the contents' rectangle in contents pixels, and the transform edits
+     * the placement without resampling anything twice).
+     */
+    readonly startGeometry: FreeTransformGeometry;
+    /** True when the layer is a smart object (the transform sets its placement). */
+    readonly smartObject: boolean;
+    private geometryValue;
+    private readonly smart;
+    private readonly smartReduced;
+    private readonly startInterp;
+    private smartMasksMoved;
+    private interp;
+    private readonly parts;
+    private readonly before;
+    private readonly startLayers;
+    private readonly startSelection;
+    private readonly startActive;
+    /** The stack this session last showed: anything else means the document changed under it. */
+    private shown;
+    private closed;
+    constructor(host: FreeTransformHost, init?: FreeTransformInit);
+    /** The current geometry. */
+    get geometry(): FreeTransformGeometry;
+    get interpolation(): Interpolation;
+    get isOpen(): boolean;
+    private check;
+    /**
+     * Changes the geometry (`corners`, `warp`) or the interpolation and, unless `preview` is `false`,
+     * shows the result live (no history). Returns the geometry.
+     */
+    update(changes: {
+        corners?: FreeTransformGeometry['corners'];
+        warp?: FreeTransformGeometry['warp'];
+        interpolation?: Interpolation;
+    }, preview?: FreeTransformPreview | false): FreeTransformGeometry;
+    /** Resamples every part for the current geometry and shows it (or returns it, for commit). */
+    private resample;
+    /** A smart object re-rendered from its contents for the current geometry (previews leave the smart filters out). */
+    private resampleSmart;
+    /** Whether the geometry (or the interpolation of a smart object) differs from where it started. */
+    private isChanged;
+    private render;
+    /** Finishes the transform with full-quality resampling, as one undo step. */
+    commit(): FreeTransformResult;
+    /** Abandons the transform and puts everything back (no history). */
+    cancel(): void;
+    private result;
+}
+
+/** What `getSmartObject` reports. */
+interface SmartObjectInfo {
+    layerId: string;
+    contents: {
+        /** Shared by linked instances. */
+        id: string;
+        name: string;
+        kind: 'raster' | 'document';
+        /** Pixel size of the contents. */
+        width: number;
+        height: number;
+        /** False for a file that could not be decoded here (the layer shows its stored pixels). */
+        decoded: boolean;
+        /** The type of the file the contents came from (`psb`, `png`, `jpg`, …), or `null`. */
+        fileType: string | null;
+        /** The external file of linked contents, or `null` for embedded ones. */
+        linkedPath: string | null;
+        /** Every smart object placed from these contents (this one included), bottom first. */
+        instances: string[];
+        /** Layers in a nested document (0 for raster contents). */
+        layerCount: number;
+    };
+    placement: {
+        /** Where the contents' corners land: top-left, top-right, bottom-right, bottom-left (document pixels). */
+        corners: Quad;
+        /** The warp mesh in contents pixels, or `null`. */
+        warp: WarpMesh | null;
+        interpolation: Interpolation;
+        /** False for distort, perspective and warp (then only corners and bounds describe it). */
+        affine: boolean;
+        /** Percent of the contents' own size. */
+        scaleX: number;
+        scaleY: number;
+        rotate: number;
+        skewX: number;
+        /** Where the contents' centre is (document pixels). */
+        center: {
+            x: number;
+            y: number;
+        };
+        /** Bounds of the placed outline. */
+        bounds: CropBox | null;
+    };
+    smartFilters: {
+        enabled: boolean;
+        /** Bottom (applied first) to top. Photoshop filters we keep but do not draw have kind `psd`. */
+        filters: Array<Record<string, unknown>>;
+        mask: {
+            enabled: boolean;
+            linked: boolean;
+            density: number;
+            feather: number;
+            bounds: CropBox | null;
+            defaultValue: number;
+        } | null;
+    };
+    /** Document bounds of the rendered pixels. */
+    bounds: CropBox | null;
+}
+/** Latest serialized schema version (`3`: layers). Documents with the old shape still write 1 or 2. */
+declare const IMAGE_EDITOR_SCHEMA_VERSION: 3;
+/** Changes to an adjustment layer; `params` is merged into the current parameters. */
+interface AdjustmentLayerUpdate<K extends AdjustmentKind = AdjustmentKind> {
+    params?: Partial<AdjustmentParamsMap[K]>;
+    enabled?: boolean;
+    opacity?: number;
+    blend?: BlendMode;
+    name?: string;
+    /** A layer mask, or `null` to remove it. */
+    mask?: AdjustmentLayerMask | null;
+}
+/** Options shared by the selection commands. */
+interface SelectionCommandOptions {
+    /** How the result combines with the current selection (default `replace`). */
+    mode?: SelectionMode;
+    /** Feather the new shape by this many pixels before combining (default 0). */
+    feather?: number;
+}
+/** Where an AI result goes (see `applyInpaintedImage`, `applyBackgroundRemovedImage`). */
+interface AIResultOptions {
+    /** `new-layer`: a new layer (inpainting) or a mask (background removal); `replace`: the Background's pixels. Default: by `isMultiLayer`. */
+    target?: 'new-layer' | 'replace';
+}
+/** Where the selection tools read colours from. */
+interface SampleOptions {
+    /**
+     * `composite` (default): the image, as before (with several layers: the composite of the pixel
+     * layers, or with `sampleMerged` of every layer); `active-layer`: only the active pixel layer.
+     */
+    sample?: 'composite' | 'active-layer';
+    /** Sample the adjusted image (base adjustments and layers) instead of the source pixels. */
+    sampleMerged?: boolean;
+    /** Pixels to use instead of reading the source image (natural size, RGBA). */
+    pixels?: PixelBuffer;
+}
+/** A new adjustment layer: its kind plus optional initial values and position. */
+interface AdjustmentLayerInit<K extends AdjustmentKind = AdjustmentKind> extends AdjustmentLayerUpdate<K> {
+    kind: K;
+    id?: string;
+    /** Put the new layer directly above this layer (in its group). */
+    aboveId?: string;
+    /** Put the new layer at the top of this group. */
+    parentId?: string;
+}
+/** A new pixel layer: empty, a solid colour over the canvas, or given pixels, plus its properties and position. */
+interface PixelLayerInit extends LayerPlacement {
+    id?: string;
+    name?: string;
+    /** Fill the canvas with this colour (`#rgb`, `#rrggbb`, `#rrggbbaa` or `[r, g, b, a?]` 0..255). */
+    color?: string | number[];
+    /** RGBA pixels placed at `x`, `y` (document pixels). */
+    pixels?: PixelBuffer;
+    x?: number;
+    y?: number;
+    visible?: boolean;
+    /** 0..1 (default 1). */
+    opacity?: number;
+    fillOpacity?: number;
+    blend?: BlendMode;
+}
+/** The paint tools' options (view state). */
+interface PaintOptions {
+    brush: BrushSettings;
+    /** `#rrggbb`: what the brush and Fill paint. */
+    foreground: string;
+    /** `#rrggbb`: what the eraser paints on transparency-locked layers and masks. */
+    background: string;
+    /** Mixer Brush options (wet, load, mix, load / clean each stroke, RGB or pigment mixing). */
+    mixer: MixerSettings;
+    /** What the Mixer Brush carries now: its reservoir, how much is left and the picked-up colour. */
+    mixerLoad: MixerLoad;
+}
+/** Paint tools a stroke can use. */
+type StrokeTool = 'brush' | 'eraser' | 'mixer';
+/** A stroke: tool, target (default the active layer and target) and brush / colour overrides. */
+interface StrokeInit {
+    tool?: StrokeTool;
+    layerId?: string;
+    channel?: LayerTarget;
+    /** Overrides of the paint options' brush. */
+    brush?: Partial<BrushSettings>;
+    /**
+     * Paint colour (default the foreground). Masks take its grey value. For the mixer, the colour
+     * the reservoir is loaded with: given, it loads the brush whatever `loadEachStroke` says.
+     */
+    color?: string | number[];
+    /** Overrides of the paint options' Mixer Brush settings (tool `mixer`). */
+    mixer?: Partial<MixerSettings>;
+    /** Eraser colour on locked transparency / masks (default the background). */
+    background?: string | number[];
+    /** Kept with the stroke for replays (v1 brushes have no jitter). */
+    seed?: number;
+}
+interface FillOptions {
+    layerId?: string;
+    channel?: LayerTarget;
+    /** Default the foreground colour. */
+    color?: string | number[];
+    /** 0..1 (default 1). */
+    opacity?: number;
+    blend?: BlendMode;
+    /** Limit to the selection when there is one (default true). */
+    useSelection?: boolean;
+}
+/** What a stroke, fill or clear changed. */
+interface PaintStrokeResult {
+    layerId: string;
+    channel: LayerTarget;
+    /** Document rectangle that changed (null when nothing did). */
+    bounds: CropBox | null;
+    dabs: number;
+    /** The Mixer Brush's load after the stroke (tool `mixer` only). */
+    mixerLoad?: MixerLoad;
+}
+/** An opaque pre-stroke history snapshot. */
+type HistoryEntryHandle = {
+    readonly __historyEntry: unique symbol;
+};
+/** How a Mixer Brush stroke starts (see `PaintStrokeSession`). */
+interface MixerStrokeInit {
+    /** Makes the stroke over the session's live pixels. */
+    create(pixels: MixerTarget): MixerStroke;
+    /** Stores the brush load when the stroke ends and returns it (after any clean). */
+    end(load: MixerLoad): MixerLoad;
+}
+/**
+ * A stroke in progress (see `beginStroke`): `push` input points as they arrive, then `end` (one
+ * undo step) or `cancel`. Brush and eraser strokes build up a coverage map composited over the
+ * pre-stroke pixels; Mixer Brush strokes paint dab by dab into the live pixels, so each dab picks
+ * up what the dabs before it laid down.
+ */
+declare class PaintStrokeSession {
+    private readonly controller;
+    readonly target: {
+        id: string;
+        channel: LayerTarget;
+        surface: TiledSurface;
+    };
+    private readonly apply;
+    private readonly before;
+    private readonly base;
+    private readonly live;
+    private readonly touched;
+    private readonly stroke;
+    private readonly mixer;
+    private readonly mixerInit;
+    /** Mixer tiles written since the last update: they get new tile objects so the compositor sees them change. */
+    private readonly fresh;
+    private last;
+    private closed;
+    constructor(controller: ImageEditorController, target: {
+        id: string;
+        channel: LayerTarget;
+        surface: TiledSurface;
+    }, stroke: StrokeCoverage | MixerStrokeInit, apply: StrokeApply);
+    /** The live pixels a mixer stroke reads and writes; base tiles are copied on first write. */
+    private mixerPixels;
+    get layerId(): string;
+    /** Adds input points (document pixels); the stack shows the stroke so far. */
+    push(points: readonly StrokePoint[]): void;
+    private update;
+    /** Finishes the stroke (one undo step) and returns what changed. */
+    end(): PaintStrokeResult;
+    /** Abandons the stroke and restores the layer. */
+    cancel(): void;
+}
+/** Where a new annotation goes. */
+interface AnnotationPlacement {
+    /** Put the annotation layer directly above this layer (default: the top of the stack). */
+    aboveId?: string;
+}
+declare const DEFAULT_ADJUSTMENTS: ImageAdjustments;
+/**
+ * Fills in defaults for stored adjustments. A stored object without `process` was saved before
+ * process versions existed and keeps the legacy rendering.
+ */
+declare function normalizeStoredAdjustments(stored: Partial<ImageAdjustments> | undefined | null): ImageAdjustments;
+/**
+ * Brings a stored editor state of any schema version to a clean state of the same family:
+ * version 1 (and a missing version) has no adjustment layers, version 2 has them, and both stay
+ * in the document-level schema so old states load and render exactly as before. Version 3
+ * (layers) is returned with its document fields cleaned. To lift a v1 / v2 state into layers,
+ * use {@link migrateToLayeredState}.
+ */
+declare function migrateSerializedImageEditorState(data: Partial<SerializedImageEditorState> & {
+    version?: number;
+}): SerializedImageEditorState;
+/**
+ * Lifts a stored state of any version into the layered schema (v3) for a canvas of
+ * `width × height`: the source becomes the Background layer with the base sliders as its
+ * `develop` filter and the depth mask as its parametric mask, adjustment layers go above it and
+ * annotations on top (see `layersFromLegacy`).
+ */
+declare function migrateToLayeredState(data: Partial<SerializedImageEditorState> & {
+    version?: number;
+}, size: ImageDimensions): SerializedLayeredImageEditorState;
+declare const DEFAULT_TRANSFORM: ImageTransform;
+declare const DEFAULT_DEPTH_MASK: DepthMaskOptions;
+/**
+ * ImageEditorController manages the complete lifecycle, canvas rendering pipeline,
+ * tool interaction states, undo/redo history, serialization, and image export.
+ */
+declare class ImageEditorController {
+    private state;
+    private renderer;
+    private imageElement;
+    private listeners;
+    private histogramListeners;
+    private onStateChange?;
+    private undoStack;
+    private redoStack;
+    private maxHistoryDepth;
+    private maxHistoryBytes;
+    private isApplyingHistory;
+    private initialSnapshot;
+    /** Pixels the selection tools sample (host-provided or read back from the source). */
+    private samplePixels;
+    private samplePixelsOverride;
+    /** Decoded source pixels (the Background's surface), by the buffer or element they came from. */
+    private sourceSurfaces;
+    private viewKey;
+    /** For `compositePixels` and mask evaluation (the renderer keeps its own for the viewport). */
+    private compositor;
+    constructor(options?: ImageEditorOptions);
+    /**
+     * Loads a new source image and makes it the baseline that `reset()` returns to.
+     * Does not record history; use `applyInpaintedImage` / `applyBackgroundRemovedImage`
+     * for undoable source replacement.
+     */
+    loadImage(src: string | HTMLImageElement): Promise<void>;
+    private resolveSource;
+    getImageElement(): CanvasImageSource | null;
+    getState(): ImageEditorState;
+    subscribe(listener: (state: ImageEditorState) => void): () => void;
+    /**
+     * Where layer pixels changed since the last viewport render, when only strokes changed them
+     * (the renderer then recomposites just those rectangles); `'all'` after any other change.
+     */
+    private pendingDirty;
+    private notify;
+    /** Recomputes the compatibility views (`adjustments`, `depthMask`, `annotations`) when the stack changed. */
+    private syncViews;
+    private stack;
+    private captureHistoryEntry;
+    private restoreHistoryEntry;
+    private recordHistory;
+    /**
+     * Bytes of pixel tiles held only by undo / redo steps (not by the current state). The oldest
+     * undo steps are dropped while it exceeds `maxHistoryBytes`.
+     */
+    get historyBytes(): number;
+    private trimHistoryBytes;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    reset(): void;
+    setTool(tool: ImageEditorTool): void;
+    setCrop(crop: CropBox | null, addToHistory?: boolean): void;
+    applyCropPreset(ratio: AspectRatio): void;
+    resetCrop(): void;
+    rotate(degrees: number): void;
+    setRotation(degrees: number): void;
+    flipHorizontal(): void;
+    flipVertical(): void;
+    /** The layer stack, bottom to top (immutable objects). */
+    getLayers(): ImageLayer[];
+    getLayer(id: string): ImageLayer | undefined;
+    /** The active layer, or `undefined`. */
+    getActiveLayer(): ImageLayer | undefined;
+    /**
+     * Makes a layer the active one (or none) and chooses whether painting targets its pixels or
+     * its mask. View state: no undo step. Returns false for an unknown id.
+     */
+    setActiveLayer(id: string | null, target?: LayerTarget): boolean;
+    /**
+     * The pixels of a pixel layer, in document space (`x`, `y` is the top-left of the returned
+     * buffer), or `null` for an unknown or empty layer. Resolves the Background's source pixels.
+     */
+    getLayerPixels(id: string): (PixelBuffer & {
+        x: number;
+        y: number;
+    }) | null;
+    private boundsCache;
+    /**
+     * Document bounds of a layer's non-transparent pixels (pixel layers; the Background's source
+     * included), or `null` for an empty or non-pixel layer.
+     */
+    getLayerBounds(id: string): CropBox | null;
+    /**
+     * Composites the layer stack in document space without a canvas (annotation layers need one
+     * and are left out): `rect` (default: the canvas) as RGBA, straight alpha. Crop, rotation and
+     * output opacity are not applied. With `layerIds`, only those layers are composited.
+     */
+    compositePixels(rect?: CropBox, options?: {
+        layerIds?: string[];
+    }): PixelBuffer;
+    private compositorSources;
+    private sourceIds;
+    private nextSourceId;
+    /** Changes whenever the Background's source pixels can have changed. */
+    private sourceVersion;
+    /** The pixels a pixel layer or smart object composites (the decoded source for the Background). */
+    private surfaceOf;
+    /**
+     * The source image as a surface (cached): host-supplied sample pixels first, then the decoded
+     * element, then pixels read back for the selection tools.
+     */
+    private sourceSurface;
+    private opaqueCache;
+    /** Whether every source pixel is opaque (some legacy renders depend on it). */
+    private sourceIsOpaque;
+    /** Synchronously reads the source element's pixels through a canvas, or `null`. */
+    private decodeSource;
+    /** Records one undo step and applies a new stack (and any other state change in `extra`). */
+    private commitLayers;
+    /** The default position of a new layer: above the active layer, else the top of the stack. */
+    private newLayerPlacement;
+    /**
+     * Adds a pixel layer (one undo step) and makes it active: empty, filled with `color` over the
+     * canvas, or holding `pixels` placed at `x`, `y`. Goes above the active layer unless placed.
+     * Returns its id.
+     */
+    addPixelLayer(init?: PixelLayerInit): string;
+    /**
+     * `addPixelLayer` from an image: a PNG data URL or base64 PNG is decoded without a canvas;
+     * other formats and URLs need a browser. Returns the new layer id.
+     */
+    addPixelLayerFromImage(image: string, init?: Omit<PixelLayerInit, 'pixels' | 'color'>): Promise<string>;
+    /** RGBA pixels of an image given as a data URL, base64 PNG or URL. */
+    decodeImage(image: string): Promise<PixelBuffer>;
+    private nextLayerName;
+    /** Duplicates a layer (with its children) directly above it, as one undo step. Returns the copy's id. */
+    duplicateLayer(id: string, name?: string): string;
+    /** Deletes a layer (refused when locked), as one undo step. */
+    removeLayer(id: string): void;
+    /** Moves a layer above / below another, or into a group, as one undo step. Returns its new parent and index. */
+    moveLayer(id: string, placement: LayerPlacement): {
+        parentId: string | null;
+        index: number;
+    };
+    /**
+     * Changes name, visibility, opacity, fill, blend, clipping, locks or (groups) collapsed state, as
+     * one undo step (`commitToHistory = false` for the moves of a slider drag). Returns the layer.
+     */
+    setLayerProperties(id: string, props: LayerProperties, commitToHistory?: boolean): ImageLayer;
+    /** Adds an empty pass-through group above the active layer (or at `placement`) and makes it active. Returns its id. */
+    addGroup(init?: LayerPlacement & {
+        name?: string;
+        blend?: LayerBlendMode;
+    }): string;
+    /** Puts sibling layers into a new group (one undo step). Returns the group id. */
+    groupLayers(ids: string[], name?: string): string;
+    /** Replaces a group by its children (one undo step). Returns the child ids, bottom to top. */
+    ungroupLayer(id: string): string[];
+    /**
+     * Moves a pixel layer to an absolute offset (`x`, `y`) or by `dx`, `dy`, as one undo step
+     * (`commitToHistory = false` for the moves of a drag). Returns the offset and document bounds.
+     */
+    offsetLayer(id: string, move: {
+        x?: number;
+        y?: number;
+        dx?: number;
+        dy?: number;
+    }, commitToHistory?: boolean): {
+        offset: {
+            x: number;
+            y: number;
+        };
+        bounds: CropBox | null;
+    };
+    /**
+     * Adds a mask to a layer (one undo step): `reveal-all` (white), `hide-all` (black) or
+     * `selection` (the selection's coverage). Replaces an existing mask. Makes the mask the paint
+     * target when the layer is active.
+     */
+    addLayerMask(id: string, from?: 'reveal-all' | 'hide-all' | 'selection', props?: LayerMaskProps): RasterMask;
+    /** Removes a layer's mask (one undo step). */
+    removeLayerMask(id: string): void;
+    /** Changes any layer mask's density, feather, enabled or linked flag (pixels kept). Returns the mask. */
+    setLayerMaskProps(id: string, props: LayerMaskProps, commitToHistory?: boolean): RasterMask;
+    /**
+     * Bakes a pixel layer's mask into its pixels (alpha × coverage, including density, feather or
+     * the depth map) and removes the mask, as one undo step.
+     */
+    applyLayerMask(id: string): Promise<void>;
+    /**
+     * Layer via Copy (or via Cut): a new pixel layer with the selected pixels of a pixel layer (the
+     * active one by default), directly above it, as one undo step. Returns the new id.
+     */
+    layerViaCopy(options?: {
+        layerId?: string;
+        cut?: boolean;
+        name?: string;
+    }): string;
+    private openTransform;
+    /** The Free Transform in progress (see `beginFreeTransform`), or `null`. */
+    getFreeTransform(): FreeTransformSession | null;
+    private transformHost;
+    /**
+     * Starts a Free Transform (Edit › Free Transform, Transform Selection, or a transform of a Layer
+     * via Copy): of the layer's pixels with its linked mask, an unlinked mask alone, the selected
+     * pixels or just the selection outline (see `FreeTransformInit`). Change the geometry with
+     * `session.update` (live preview, no history), then `commit()` (one undo step) or `cancel()`.
+     * Refused while another transform is open.
+     */
+    beginFreeTransform(init?: FreeTransformInit): FreeTransformSession;
+    /**
+     * Transforms in one step (agents, scripts): begins a Free Transform for `spec`, sets its corners
+     * from exactly one of `matrix` (document-space affine), `corners` (where the frame's corners go:
+     * distort / perspective) or `params` (scale, rotate, skew and move about a reference point), and
+     * commits it as one undo step. Returns what changed and the new bounds.
+     */
+    transformLayer(spec: FreeTransformInit & {
+        matrix?: AffineMatrix;
+        corners?: Quad;
+        params?: TransformParams;
+        warp?: WarpMesh | WarpPreset | null;
+    }): FreeTransformResult;
+    /** Flips the layer (or its selected pixels, or the outline) about the frame's centre, exactly (one undo step). */
+    flipLayer(axis: 'horizontal' | 'vertical', init?: FreeTransformInit): FreeTransformResult;
+    /**
+     * Rotates by a quarter turn (90 clockwise, −90 counter-clockwise) or 180 about the frame's
+     * centre, snapped so pixels land on whole pixels: exact, no resampling (one undo step).
+     */
+    rotateLayer90(turn: 90 | -90 | 180, init?: FreeTransformInit): FreeTransformResult;
+    /** Adds a `develop` or `blur` filter to a pixel layer (one undo step). Returns the layer's filters. */
+    addLayerFilter(id: string, filter: Partial<LayerFilter> & {
+        kind: LayerFilter['kind'];
+    }): LayerFilter[];
+    /** Changes one filter (one undo step, or none with `commitToHistory = false` during a drag). Returns the filters. */
+    updateLayerFilter(id: string, filterId: string, changes: Record<string, unknown>, commitToHistory?: boolean): LayerFilter[];
+    /** Removes one filter (one undo step). Returns the remaining filters. */
+    removeLayerFilter(id: string, filterId: string): LayerFilter[];
+    private get canvasSize();
+    /**
+     * Layer › Smart Objects › Convert to Smart Object (one undo step): sibling layers (default the
+     * active one) become one smart object at the topmost one's position. A single pixel layer keeps
+     * its id and properties and its filters become smart filters (it renders exactly as before);
+     * anything else nests as a layer document. Returns the smart object's id.
+     */
+    convertToSmartObject(ids?: string[], options?: {
+        name?: string;
+    }): string;
+    /** Layer › Smart Objects › Rasterize (one undo step): the smart object becomes a pixel layer holding what it renders. */
+    rasterizeSmartObject(id: string): string;
+    /** A smart object's contents, placement and smart filters as plain data (see `SmartObjectInfo`). */
+    getSmartObject(id: string): SmartObjectInfo;
+    /**
+     * Sets a smart object's placement (one undo step, or none with `commitToHistory = false` during a
+     * drag): where the contents' corners land, an optional warp in contents pixels and the
+     * interpolation. The contents render again from the source; a linked mask follows a warp-free
+     * change. Returns the new placement summary.
+     */
+    setSmartObjectPlacement(id: string, placement: SmartPlacement, commitToHistory?: boolean): SmartObjectInfo['placement'] & {
+        masksMoved: boolean;
+    };
+    /**
+     * Sets a smart object's transform absolutely (one undo step): exactly one of `corners` (where the
+     * contents' corners land), `matrix` (contents pixels → document) or the numbers (`scaleX`,
+     * `scaleY` in percent of the contents' own size, `rotate`, `skewX`, `skewY`, and `x`, `y` where
+     * the contents' centre goes, default where it is now); plus, optionally, a warp (a preset, a mesh
+     * in contents pixels, or `null` to remove it) and the interpolation. Unlike `transformLayer`,
+     * nothing is relative to the current transform.
+     */
+    setSmartObjectTransform(id: string, spec: {
+        corners?: Quad;
+        matrix?: AffineMatrix;
+        scaleX?: number;
+        scaleY?: number;
+        rotate?: number;
+        skewX?: number;
+        skewY?: number;
+        x?: number;
+        y?: number;
+        warp?: WarpMesh | WarpPreset | null;
+        interpolation?: Interpolation;
+    }): SmartObjectInfo['placement'] & {
+        masksMoved: boolean;
+    };
+    /**
+     * Layer › Smart Objects › Replace Contents (one undo step): new contents for the smart object and
+     * every instance linked to it, from RGBA pixels, PSD bytes (a layer document) or contents. Each
+     * instance keeps its scale and rotation about the contents' centre. Returns the contents id and
+     * the layers that changed.
+     */
+    replaceSmartObjectContents(id: string, source: {
+        pixels: PixelBuffer;
+        name?: string;
+    } | {
+        psd: Uint8Array;
+        name?: string;
+    } | {
+        contents: SmartContents;
+    }): {
+        contentsId: string;
+        width: number;
+        height: number;
+        layerIds: string[];
+    };
+    /** `replaceSmartObjectContents` from an image (PNG data URL or base64 decodes anywhere; other formats need a browser). */
+    replaceSmartObjectContentsFromImage(id: string, image: string, name?: string): Promise<{
+        contentsId: string;
+        width: number;
+        height: number;
+        layerIds: string[];
+    }>;
+    /**
+     * Layer › Smart Objects › Export Contents: the file the contents came from while unedited, else a
+     * PNG (raster contents) or a PSD / PSB of the nested document. Returns the file name, MIME type
+     * and bytes.
+     */
+    exportSmartObjectContents(id: string): {
+        name: string;
+        mimeType: string;
+        bytes: Uint8Array;
+    };
+    /**
+     * Layer › Smart Objects › New Smart Object via Copy (`linked: false`: independent contents) or a
+     * linked duplicate (`linked: true`: edits to the contents show in both), directly above, as one
+     * undo step. Returns the copy's id.
+     */
+    copySmartObject(id: string, linked?: boolean, name?: string): string;
+    /** Adds a smart filter (`develop` or `blur`, with `blend` and `opacity`) at `index` (default the top), as one undo step. */
+    addSmartFilter(id: string, filter: Record<string, unknown> & {
+        kind: string;
+    }, index?: number): SmartFilter;
+    /** Changes one smart filter (one undo step, or none with `commitToHistory = false` during a drag). */
+    updateSmartFilter(id: string, filterId: string, changes: Record<string, unknown>, commitToHistory?: boolean): SmartFilter;
+    /** Removes one smart filter (one undo step). Returns the remaining filters. */
+    removeSmartFilter(id: string, filterId: string): SmartFilter[];
+    /** Moves one smart filter to `index` (0 = bottom, applied first), as one undo step. Returns the filters. */
+    moveSmartFilter(id: string, filterId: string, index: number): SmartFilter[];
+    /** Turns a smart object's whole filter stack on or off (one undo step). */
+    setSmartFiltersEnabled(id: string, enabled: boolean): boolean;
+    /**
+     * Sets the smart filter mask (one undo step): `reveal-all`, `hide-all`, `selection` (the
+     * selection's coverage), or `none` to remove it; `props` sets density, feather, enabled and linked.
+     * Painting it targets channel `filter-mask`. Returns the mask, or `null` when removed.
+     */
+    setSmartFilterMask(id: string, from: 'reveal-all' | 'hide-all' | 'selection' | 'none' | 'keep', props?: LayerMaskProps, commitToHistory?: boolean): RasterMask | null;
+    /**
+     * Decodes smart object contents that came as files the synchronous decoders cannot read (a JPEG
+     * or TIFF embedded in a PSD), through the browser's image decoder. No undo step: the pixels on
+     * screen do not change. Returns the contents ids still undecoded.
+     */
+    prepareSmartObjects(): Promise<string[]>;
+    private contentsStack;
+    /** The smart objects whose contents are open (outermost first); empty when the document itself is shown. */
+    getEditingContents(): Array<{
+        layerId: string;
+        name: string;
+    }>;
+    /**
+     * Layer › Smart Objects › Edit Contents: shows the smart object's contents as a document of their
+     * own (a layer document, or raster contents as one pixel layer), with their own undo history.
+     * Every editor operation and tool then works on the contents until `closeSmartObjectContents`.
+     * Contents can nest. Returns the contents' size and layer ids.
+     */
+    editSmartObjectContents(id: string): {
+        layerId: string;
+        depth: number;
+        width: number;
+        height: number;
+        layerIds: string[];
+    };
+    /**
+     * Closes the innermost open contents: with `save` (default) the edited layers become the smart
+     * object's contents, and it and every linked instance render again (one undo step in the
+     * document); without, the edits are dropped. Returns the smart object and the layers that changed.
+     */
+    closeSmartObjectContents(save?: boolean): {
+        layerId: string;
+        changed: boolean;
+        layerIds: string[];
+    };
+    /** The document's own layers (not the contents open for editing). */
+    private rootLayers;
+    /** Drops every open contents edit (loading another document). */
+    private abandonContents;
+    /** A layer's effects (an empty, enabled list when it has none). */
+    getLayerEffects(id: string): LayerEffects;
+    /**
+     * Adds an effect of `kind` with Photoshop's defaults and `params` applied (one undo step), at
+     * `index` in the layer's effect list (default the end). Returns the new effect and the effects.
+     */
+    addLayerEffect(id: string, kind: LayerEffectKind, params?: Record<string, unknown>, index?: number): {
+        effect: LayerEffect;
+        effects: LayerEffects;
+    };
+    /** Changes one effect (one undo step, or none with `commitToHistory = false` during a drag). Returns the effects. */
+    updateLayerEffect(id: string, effectId: string, changes: Record<string, unknown>, commitToHistory?: boolean): LayerEffects;
+    /** Removes one effect (one undo step). Returns the remaining effects. */
+    removeLayerEffect(id: string, effectId: string): LayerEffects;
+    /** Turns a layer's effects on or off as a whole and, when given, sets Scale Effects (one undo step). */
+    setLayerEffectsEnabled(id: string, enabled: boolean, scale?: number, commitToHistory?: boolean): LayerEffects;
+    /** Replaces a layer's effects (one undo step; `null` removes them). Returns the effects. */
+    setLayerEffects(id: string, effects: LayerEffects | null, commitToHistory?: boolean): LayerEffects;
+    private patternIds;
+    /** Changes whenever the document's pattern list is replaced (the compositor then drops its caches). */
+    private patternsVersion;
+    /** The document's patterns (from an opened PSD), besides the built-in ones. */
+    getDocumentPatterns(): EffectPattern[];
+    /** The light effects with "use global light" follow. */
+    getGlobalLight(): GlobalLight;
+    /** Sets the global light (one undo step). `angle` -360..360°, `altitude` 0..90°. Returns it. */
+    setGlobalLight(light: Partial<GlobalLight>, commitToHistory?: boolean): GlobalLight;
+    /** Composites `layers` (in isolation) over `rect` into a surface, loading depth maps first. */
+    private compositeToSurface;
+    /** Document bounds a layer can paint into (pixel content, annotations, or the canvas for the rest). */
+    private paintBounds;
+    /**
+     * Merge Down: composites a layer onto the pixel layer directly below it (which keeps its name,
+     * opacity and blend; masks, fill, filters and both layers' effects are baked), as one undo step.
+     * Returns the merged id.
+     */
+    mergeDown(id: string): Promise<string>;
+    /**
+     * Merge Visible: the visible top-level layers become one normal pixel layer (at the position of
+     * the lowest of them); hidden layers stay. One undo step. Returns the merged id.
+     */
+    mergeVisible(): Promise<string>;
+    /** Flatten Image: every visible layer composited into one Background layer; hidden layers are discarded. One undo step. */
+    flattenImage(): Promise<string>;
+    private thumbCache;
+    /**
+     * A small RGBA preview of a pixel layer over the canvas (or of its mask with `mask: true`),
+     * longest side `maxSide` px, point-sampled; `null` for layers without pixels.
+     */
+    getLayerThumbnail(id: string, options?: {
+        maxSide?: number;
+        mask?: boolean;
+    }): PixelBuffer | null;
+    /** Brush settings, colours and tool options of the paint tools (view state, no undo). */
+    setPaintOptions(options: Partial<Omit<PaintOptions, 'brush' | 'mixer' | 'mixerLoad'>> & {
+        brush?: Partial<BrushSettings>;
+        mixer?: Partial<MixerSettings>;
+    }): PaintOptions;
+    /**
+     * Loads the Mixer Brush's reservoir full with `color` (default the foreground); the picked-up
+     * colour is kept. View state, no undo. Returns the brush load.
+     */
+    loadMixerBrush(color?: string | number[]): MixerLoad;
+    /** Cleans the Mixer Brush: empties the pickup well (the reservoir is kept). Returns the brush load. */
+    cleanMixerBrush(): MixerLoad;
+    /** Empties the Mixer Brush entirely (no reservoir, nothing picked up). Returns the brush load. */
+    emptyMixerBrush(): MixerLoad;
+    /** D: black foreground, white background. */
+    resetPaintColors(): void;
+    /** X: swaps the foreground and background colours. */
+    swapPaintColors(): void;
+    /** Resolves and validates what a stroke, fill or clear paints into. */
+    private paintTarget;
+    /** The layer with its pixels (or mask) replaced by `surface`. */
+    private withSurface;
+    /**
+     * Starts a brush or eraser stroke on a layer's pixels or mask (default: the active layer and
+     * target, the paint options' brush and colours). Feed points with `push`, finish with `end()`
+     * (one undo step for the whole stroke) or `cancel()`. While it runs, the stack shows the stroke
+     * without recording history.
+     */
+    beginStroke(init?: StrokeInit): PaintStrokeSession;
+    /** A Mixer Brush stroke's start: the settings, and the load (refilled when asked or set to). */
+    private mixerStroke;
+    /** @internal Shows a stroke's live surface (no history). */
+    _strokeUpdate(layerId: string, channel: LayerTarget, surface: TiledSurface, rects: CropBox[]): void;
+    /** @internal Commits a finished stroke as one undo step (`before` is the pre-stroke state). */
+    _strokeCommit(before: HistoryEntryHandle, layerId: string, channel: LayerTarget, surface: TiledSurface | null): void;
+    /** @internal The pre-stroke snapshot. */
+    _captureForStroke(): HistoryEntryHandle;
+    /**
+     * Paints a whole stroke in one call (agents, replays): `points` in document pixels with optional
+     * pressure, through the brush, eraser or Mixer Brush. One undo step. Returns the layer, channel, the changed
+     * document bounds and the number of dabs.
+     */
+    paintStroke(init: StrokeInit & {
+        points: StrokePoint[];
+    }): PaintStrokeResult;
+    /**
+     * Edit › Fill: fills the selection (or, without one or with `useSelection: false`, the whole
+     * canvas) on a layer's pixels or mask with a colour (default the foreground), at `opacity` with
+     * `blend`. One undo step. Returns the changed bounds.
+     */
+    fillPixels(options?: FillOptions): PaintStrokeResult;
+    /**
+     * Edit › Clear: removes the selected pixels (alpha to 0; on a transparency-locked layer or a mask
+     * it fills with the background colour). Without a selection (or with `useSelection: false`) the
+     * whole canvas. One undo step. Returns the changed bounds.
+     */
+    clearPixels(options?: Omit<FillOptions, 'color' | 'blend'>): PaintStrokeResult;
+    private fillOrClear;
+    /** The pixel layer the base sliders edit: the active pixel layer, else the Background. */
+    private developLayer;
+    /**
+     * Sets base adjustment values as one undo step (unless `commitToHistory` is false). The base
+     * sliders edit the `develop` filter of the active pixel layer (or the Background), `blur` its
+     * blur filter (or `legacyOutputBlur` in migrated documents), `opacity` the output opacity, and
+     * `layers` replaces the adjustment layers.
+     */
+    setAdjustments(partial: Partial<ImageAdjustments>, commitToHistory?: boolean): void;
+    /** True when the adjustments use an older rendering process than {@link LATEST_PROCESS_VERSION}. */
+    get isProcessOutdated(): boolean;
+    /**
+     * Update to Current Process: re-interprets the current adjustment values with the latest
+     * rendering process (one undo step). Returns false when already current.
+     */
+    upgradeProcess(): boolean;
+    /** Resets the base sliders (latest process). Adjustment layers are kept; see `clearAdjustmentLayers`. */
+    resetAdjustments(): void;
+    /** The adjustment layers in stack order, bottom (first) to top (last). */
+    getAdjustmentLayers(): AdjustmentLayer[];
+    getAdjustmentLayer(id: string): AdjustmentLayer | undefined;
+    private adjustmentNodes;
+    /**
+     * Where a new layer goes when no position is given: directly above the topmost layer that is
+     * not an annotation, so it adjusts what adjustment layers always adjusted (annotations stay on top).
+     */
+    private defaultInsertIndex;
+    /** Inserts `node` by `aboveId` / `parentId` / adjustment index / default position. */
+    private placeLayer;
+    /** `setAdjustments({ layers })`: updates nodes by id in place, removes missing ones, adds new ones. */
+    private replaceAdjustmentNodes;
+    /**
+     * Adds an adjustment layer and returns its id, as one undo step. With no position it goes
+     * above the other adjustment layers (or, without any, above the topmost non-annotation layer,
+     * so annotations stay on top); `index` counts adjustment layers (0 = below the others);
+     * `aboveId` / `parentId` place it anywhere in the stack. `kind` alone gives neutral parameters.
+     */
+    addAdjustmentLayer<K extends AdjustmentKind>(init: K | AdjustmentLayerInit<K>, index?: number): string;
+    /**
+     * Updates a layer (`params` merged into the current ones, then normalised). Pass
+     * `commitToHistory = false` for the moves of a drag after recording its start once.
+     * Returns false for an unknown id.
+     */
+    updateAdjustmentLayer(id: string, update: AdjustmentLayerUpdate, commitToHistory?: boolean): boolean;
+    /** Removes a layer as one undo step. Returns false for an unknown id. */
+    removeAdjustmentLayer(id: string): boolean;
+    private moveAdjustmentNode;
+    /** Moves a layer to `toIndex` among the adjustment layers (0 = bottom) as one undo step. Returns false if nothing moved. */
+    moveAdjustmentLayer(id: string, toIndex: number): boolean;
+    /** Shows or hides a layer (flips it without `enabled`) as one undo step. */
+    toggleAdjustmentLayer(id: string, enabled?: boolean): boolean;
+    /** Removes every adjustment layer as one undo step. */
+    clearAdjustmentLayers(): void;
+    /** The active selection, or `null`. */
+    getSelection(): SelectionMask | null;
+    get hasSelection(): boolean;
+    private get naturalSize();
+    private dropMismatchedSelection;
+    /**
+     * Replaces the selection, or combines `mask` with it by `mode`, as one undo step. A mask of a
+     * different size (e.g. an AI segmentation at another resolution) is resampled to the image.
+     * Returns false when nothing changed.
+     */
+    setSelection(mask: SelectionMask | null, mode?: SelectionMode): boolean;
+    /** Select › All. */
+    selectAll(): boolean;
+    /** Select › Deselect. */
+    deselect(): boolean;
+    /** Select › Inverse (with nothing selected, selects everything). */
+    invertSelection(): boolean;
+    private shapeCommand;
+    /** Rectangular marquee in natural image pixels. */
+    selectRect(rect: CropBox, options?: SelectionCommandOptions & ShapeSelectionOptions): boolean;
+    /** Elliptical marquee inscribed in `rect`. */
+    selectEllipse(rect: CropBox, options?: SelectionCommandOptions & ShapeSelectionOptions): boolean;
+    /** Lasso / polygonal lasso. */
+    selectPolygon(points: ImagePoint[], options?: SelectionCommandOptions & ShapeSelectionOptions): boolean;
+    /**
+     * Supplies the pixels the selection tools sample (natural size RGBA), e.g. decoded in a worker
+     * or in a test; `null` goes back to reading the source image. Without a canvas (Node, workers)
+     * these are also the Background layer's pixels.
+     */
+    setSamplePixels(pixels: PixelBuffer | null): void;
+    /**
+     * The pixels the selection tools sample: the source image at natural size, or with
+     * `sampleMerged` the composite of the layers (no crop, rotation or annotations). `null`
+     * without pixel access (no DOM, tainted canvas).
+     */
+    getSamplePixels(options?: SampleOptions): Promise<PixelBuffer | null>;
+    private requirePixels;
+    /**
+     * Magic wand at `point` (natural image pixels). Resolves to the resulting selection (null when
+     * nothing is selected).
+     */
+    magicWand(point: ImagePoint, options?: MagicWandOptions & SelectionCommandOptions & SampleOptions): Promise<SelectionMask | null>;
+    /** Select › Color Range with colour samples (`#rrggbb` or `[r, g, b]`, optionally where they were picked). */
+    selectColorRange(samples: ColorRangeSample[], options?: ColorRangeOptions & SelectionCommandOptions & SampleOptions): Promise<SelectionMask | null>;
+    /** Select › Modify: grow, shrink, feather, border or smooth by `radius` pixels (one undo step). */
+    modifySelection(op: SelectionModifyOp, radius: number): boolean;
+    /**
+     * Refine Edge: snaps the selection (e.g. a coarse AI mask loaded with `loadSelectionFromImage`)
+     * to the image's edges with a guided filter, then smooth / feather / contrast / shift edge.
+     */
+    refineSelection(params: RefineEdgeParams, options?: SampleOptions): Promise<boolean>;
+    /**
+     * Loads a selection from a mask image (an AI segmentation, a saved mask): a data URL / URL or
+     * RGBA pixels, by luminance (white = selected) or a channel. Any size; it is resampled.
+     */
+    loadSelectionFromImage(source: string | PixelBuffer, options?: {
+        channel?: SelectionChannel;
+        invert?: boolean;
+        threshold?: number;
+        mode?: SelectionMode;
+    }): Promise<SelectionMask | null>;
+    /** Quick Mask view (tints the unselected area). View state: no undo step. */
+    setQuickMask(on: boolean): void;
+    private maskFromSelection;
+    /**
+     * Adds the selection as the layer's mask (Reveal Selection), replacing any mask, as one undo
+     * step. Without a selection, returns false.
+     */
+    applySelectionAsLayerMask(layerId: string, props?: LayerMaskProps): boolean;
+    private setLayerMask;
+    /** Sets (from a selection-shaped mask) or removes (`null`) a layer's mask as one undo step. */
+    setAdjustmentLayerMask(layerId: string, mask: SelectionMask | null, props?: LayerMaskProps): boolean;
+    /** Changes a layer mask's density (0..1), feather (px) or enabled flag; the mask pixels are kept. */
+    setAdjustmentLayerMaskProps(layerId: string, props: LayerMaskProps, commitToHistory?: boolean): boolean;
+    /** Load Selection from a layer mask (its pixels; density and feather are not applied). */
+    selectionFromLayerMask(layerId: string, mode?: SelectionMode): boolean;
+    /**
+     * Histogram of the last rendered preview (after adjustments and layers, before annotations),
+     * or `null` before the first render or without canvas pixel access.
+     */
+    getHistogram(): ImageHistogram | null;
+    /** Calls `listener` now and whenever a render produces a new preview histogram. */
+    subscribeHistogram(listener: (histogram: ImageHistogram | null) => void): () => void;
+    /** Sets the depth mask (a parametric mask on the active pixel layer, or the Background) as one undo step. */
+    setDepthMask(partial: Partial<DepthMaskOptions>): void;
+    resetDepthMask(): void;
+    private annotationLayer;
+    /** Adds an annotation as its own layer (top of the stack unless `aboveId` is given). */
+    addAnnotation(annotation: CreateAnnotationPayload, placement?: AnnotationPlacement): string;
+    updateAnnotation(id: string, partial: Partial<Annotation>, commitToHistory?: boolean): void;
+    removeAnnotation(id: string): void;
+    clearAnnotations(): void;
+    selectAnnotation(id: string | null): void;
+    setZoom(zoom: number): void;
+    zoomIn(factor?: number): void;
+    zoomOut(factor?: number): void;
+    resetZoom(): void;
+    setPan(pan: ImagePoint): void;
+    setComparing(comparing: boolean): void;
+    setFit(fit: ImageEditorFit): void;
+    private blankSource;
+    /**
+     * What the renderer draws from: the source image, or, for a document without one (an opened
+     * PSD, a v3 document loaded on its own), a transparent canvas of the document size, since every
+     * pixel then comes from the layers. `null` when there is nothing to draw.
+     */
+    private drawSource;
+    render(targetCanvas: HTMLCanvasElement, options?: RenderOptions): Promise<void>;
+    renderExport(options?: ExportOptions): Promise<HTMLCanvasElement>;
+    /**
+     * Renders the edited image (adjustments, layers and, by default, annotations) in the
+     * source image's own orientation and frame, ignoring crop, rotation and flips, so it lines
+     * up with natural-pixel coordinates (selections, `select_region`). `scale` ≤ 1 shrinks it.
+     * Returns `null` when no image is loaded.
+     */
+    renderSourceView(options?: {
+        scale?: number;
+        includeAnnotations?: boolean;
+    }): Promise<HTMLCanvasElement | null>;
+    toDataURL(options?: ExportOptions): Promise<string>;
+    toBlob(options?: ExportOptions): Promise<Blob>;
+    renderMask(options?: {
+        useAnnotations?: boolean;
+        useCrop?: boolean;
+        useSelection?: boolean;
+    }): Promise<HTMLCanvasElement>;
+    toMaskDataURL(options?: {
+        useAnnotations?: boolean;
+        useCrop?: boolean;
+        useSelection?: boolean;
+    }): Promise<string>;
+    /**
+     * Renders the current source image at natural size with no crop, rotation, flip,
+     * adjustments or annotations. This is the image that `toMaskDataURL()` is aligned with
+     * and the space that `applyInpaintedImage` / `applyBackgroundRemovedImage` expect back.
+     */
+    renderSource(): Promise<HTMLCanvasElement>;
+    /**
+     * The image an AI hook should edit: the source (`toSourceDataURL`) when results replace the
+     * Background, or the composite of the layers without annotations, in the source frame, when
+     * they go to a new layer or mask (see `applyInpaintedImage`).
+     */
+    toAIInputDataURL(options?: AIResultOptions): Promise<string>;
+    toSourceDataURL(options?: Pick<ExportOptions, 'format' | 'quality'>): Promise<string>;
+    /**
+     * Whether AI results go to layers: the document has more than one pixel layer or group (adjustment
+     * and annotation layers are edits of the image, not images of their own).
+     */
+    /** `new-layer` in multi-layer documents and documents without a source image, else `replace`. */
+    private defaultAITarget;
+    /** No source image, and no layer reading one (an opened PSD): the layers are the whole document. */
+    private isSourceless;
+    get isMultiLayer(): boolean;
+    /**
+     * Applies an inpainted result (natural image space, see `toSourceDataURL`) as ONE undoable step.
+     * In a document with several layers (see `isMultiLayer`), or with `target: 'new-layer'`, the
+     * result goes to a new pixel layer above the active layer, limited to the selection. Otherwise
+     * (`target: 'replace'`, the single-layer default) it replaces the Background's pixels and clears
+     * the mask annotations, as before. Resolves to the new layer's id in new-layer mode.
+     */
+    applyInpaintedImage(newDataUrl: string, options?: AIResultOptions): Promise<string | void>;
+    /**
+     * Applies a background-removed result as ONE undoable step. In a document with several layers
+     * (or with `target: 'new-layer'`) the result's alpha becomes the mask of the active pixel layer
+     * (or the Background), replacing its mask. Otherwise (`target: 'replace'`, the single-layer
+     * default) it replaces the Background's pixels; crop and annotations are kept (rescaled if the
+     * new image has different dimensions). Resolves to the masked layer's id in mask mode.
+     */
+    applyBackgroundRemovedImage(newDataUrl: string, options?: AIResultOptions): Promise<string | void>;
+    /**
+     * Rasterize Layer: an annotation layer becomes a pixel layer with the same id, name and
+     * properties (needs a canvas), and a pixel layer's filters are baked into its pixels. One undo
+     * step. Returns the layer id.
+     */
+    rasterizeLayer(id: string): Promise<string>;
+    /** Pixels per inch of the last opened PSD (written back by `toPsd`). */
+    private psdResolution;
+    /**
+     * Opens PSD / PSB bytes as the document (one undo step): the layers replace the stack and the
+     * document has no source image afterwards (every pixel comes from the layers). What the model
+     * cannot hold is approximated or left out; `warnings` says what, naming the layers.
+     * Throws `PsdError` for files that cannot be read at all.
+     */
+    loadPsd(bytes: Uint8Array): {
+        layerIds: string[];
+        warnings: string[];
+        width: number;
+        height: number;
+        summary: PsdImportResult['summary'];
+    };
+    /**
+     * The document as an 8-bit RGB PSD (PSB above 30 000 px) with real layers, groups, adjustment
+     * layers and masks, in the source frame. Layer filters and parametric (depth) masks are baked
+     * into pixels and masks, annotation layers are rasterized (in a browser; elsewhere they are left
+     * out), and the merged image is our composite. `warnings` lists every such change.
+     */
+    toPsd(): Promise<{
+        bytes: Uint8Array;
+        warnings: string[];
+        psb: boolean;
+        width: number;
+        height: number;
+    }>;
+    private replaceSource;
+    /**
+     * The serializable state. A document whose layers still have the v1 / v2 shape (the
+     * Background with its sliders and depth mask, adjustment layers, annotations) is written as
+     * v1 / v2 exactly as before; anything else is written as v3 with the layer pixels as PNG
+     * assets. `selection` is included (run-length encoded) only when something is selected.
+     */
+    toJSON(): SerializedImageEditorState;
+    /**
+     * With `assets: 'external'`, layer pixels go to `store` (each PNG uploaded once per store) and
+     * the v3 document holds the store's references. Old-shape documents have no assets either way.
+     */
+    toJSON(options: {
+        assets: 'external';
+        store: ImageEditorAssetStore;
+    }): Promise<SerializedImageEditorState>;
+    /**
+     * Loads a stored state whose v3 assets may live in an asset store (references other than data
+     * URLs are fetched with `store.get`), as one undo step. Assets that cannot be fetched are left
+     * out and listed in `lastLoadProblems`.
+     */
+    loadJSONAsync(data: SerializedImageEditorState, options?: {
+        store?: ImageEditorAssetStore;
+    }): Promise<void>;
+    /** Loads a stored state of any version (one undo step). */
+    loadJSON(data: SerializedImageEditorState): void;
+    /** Problems found by the last `loadJSON` / `initialState` of a v3 document (unreadable layers or assets). */
+    lastLoadProblems: string[];
+    private applyStored;
+    private serializeState;
+}
+/** Bilinear resample of RGBA pixels to `width × height`. */
+declare function resizePixels(px: PixelBuffer, width: number, height: number): PixelBuffer;
+/** A colour as RGBA bytes: `#rgb`, `#rrggbb`, `#rrggbbaa` or `[r, g, b, a?]` (0..255). */
+declare function parseColor(value: string | number[]): [number, number, number, number];
+/** `#rrggbb` of RGBA bytes (alpha dropped). */
+declare function toHex(c: readonly number[]): string;
+
+interface ImageDimensions {
+    width: number;
+    height: number;
+}
+interface ImagePoint {
+    x: number;
+    y: number;
+}
+interface CropBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+type AspectRatio = number | null;
+interface ImageTransform {
+    rotate: number;
+    flipH: boolean;
+    flipV: boolean;
+}
+interface ImageAdjustments {
+    brightness: number;
+    contrast: number;
+    saturation: number;
+    exposure: number;
+    temperature: number;
+    /**
+     * -100 (green) to 100 (magenta), 0 is default. White-balance tint correction in Duv × 3000
+     * (process 2 only; the legacy process ignores it).
+     */
+    tint?: number;
+    blur: number;
+    opacity: number;
+    /**
+     * Rendering process the values are interpreted by. `2` (the latest; new edits and Reset get
+     * it): linear-light exposure, Bradford white balance, LUT tone curve without intermediate
+     * clipping. `1` or missing: the legacy 8-bit rendering, so edits saved before process
+     * versions existed look exactly as they did. See `normalizeProcessVersion`.
+     */
+    process?: 1 | 2;
+    /**
+     * Non-destructive adjustment layers, evaluated bottom (first) to top (last) after the base
+     * adjustments above, on the encoded sRGB result. Missing or empty: no layers (edits saved
+     * before layers existed render exactly as before).
+     */
+    layers?: AdjustmentLayer[];
+}
+type AdjustmentKind = 'curves' | 'levels' | 'hueSaturation' | 'vibrance' | 'colorBalance' | 'blackWhite' | 'invert' | 'posterize' | 'threshold' | 'photoFilter';
+/** A Curves point; `input` and `output` are levels, 0..255. */
+interface CurvePoint {
+    input: number;
+    output: number;
+}
+/** Curves: each channel's curve first, then the master (composite) curve, as in Photoshop. */
+interface CurvesParams {
+    master: CurvePoint[];
+    red: CurvePoint[];
+    green: CurvePoint[];
+    blue: CurvePoint[];
+}
+/** One Levels record. Black / white points are levels (0..255); `gamma` is the midtone slider (0.1..9.99). */
+interface LevelsChannel {
+    inBlack: number;
+    inWhite: number;
+    gamma: number;
+    outBlack: number;
+    outWhite: number;
+}
+/** Levels: each channel's record first, then the master record, as in Photoshop. */
+interface LevelsParams {
+    master: LevelsChannel;
+    red: LevelsChannel;
+    green: LevelsChannel;
+    blue: LevelsChannel;
+}
+/** One of Hue/Saturation's six colour ranges (reds, yellows, greens, cyans, blues, magentas). */
+interface HueRange {
+    /** Hue shift in degrees (-180..180). */
+    hue: number;
+    /** Saturation change in percent (-100..100). */
+    saturation: number;
+    /** Lightness change in percent (-100..100). */
+    lightness: number;
+    /** Hue degrees where the range starts fading in, is fully on, starts fading out and ends (may wrap). */
+    bounds: [number, number, number, number];
+}
+interface HueSaturationParams {
+    /** Master hue shift in degrees (-180..180), or the hue when colorizing (0..360). */
+    hue: number;
+    /** Percent, -100..100 (0..100 when colorizing). */
+    saturation: number;
+    /** Percent, -100..100. */
+    lightness: number;
+    colorize: boolean;
+    /** Six ranges: reds, yellows, greens, cyans, blues, magentas. */
+    ranges: HueRange[];
+}
+interface VibranceParams {
+    /** -100..100 */
+    vibrance: number;
+    /** -100..100 */
+    saturation: number;
+}
+/** Cyan–red, magenta–green, yellow–blue sliders, -100..100 each. */
+type ColorBalanceTone = [number, number, number];
+interface ColorBalanceParams {
+    shadows: ColorBalanceTone;
+    midtones: ColorBalanceTone;
+    highlights: ColorBalanceTone;
+    preserveLuminosity: boolean;
+}
+/** Black & White: percent weights of the six colours (Photoshop defaults 40 60 40 60 20 80). */
+interface BlackWhiteParams {
+    reds: number;
+    yellows: number;
+    greens: number;
+    cyans: number;
+    blues: number;
+    magentas: number;
+    /** Tint colour (`#rrggbb`), applied like the Color blend mode, or `null` for none. */
+    tint: string | null;
+}
+interface PhotoFilterParams {
+    /** Filter colour, `#rrggbb`. */
+    color: string;
+    /** Percent, 0..100. */
+    density: number;
+    preserveLuminosity: boolean;
+}
+interface PosterizeParams {
+    /** 2..255 */
+    levels: number;
+}
+interface ThresholdParams {
+    /** 1..255: luma at or above it becomes white. */
+    level: number;
+}
+type InvertParams = Record<string, never>;
+interface AdjustmentParamsMap {
+    curves: CurvesParams;
+    levels: LevelsParams;
+    hueSaturation: HueSaturationParams;
+    vibrance: VibranceParams;
+    colorBalance: ColorBalanceParams;
+    blackWhite: BlackWhiteParams;
+    invert: InvertParams;
+    posterize: PosterizeParams;
+    threshold: ThresholdParams;
+    photoFilter: PhotoFilterParams;
+}
+interface AdjustmentLayerBase {
+    id: string;
+    /** Optional display name. */
+    name?: string;
+    enabled: boolean;
+    /** 0..1 */
+    opacity: number;
+    /** How the adjusted colour is blended over the layers below. */
+    blend: BlendMode;
+    /**
+     * Optional layer mask (natural image pixels): where it is 0 the layer has no effect. Missing:
+     * the layer applies everywhere (layers saved before masks existed are unchanged).
+     */
+    mask?: AdjustmentLayerMask;
+}
+/**
+ * A layer mask: 8-bit coverage of the source image, run-length encoded (see
+ * `encodeSelectionRle`), plus non-destructive density and feather.
+ */
+interface AdjustmentLayerMask {
+    width: number;
+    height: number;
+    /** `r1:` run-length encoding of the mask bytes. */
+    rle: string;
+    /** 0..1 (missing = 1). */
+    density?: number;
+    /** Gaussian σ in pixels (missing = 0). */
+    feather?: number;
+    /** `false` keeps the mask but ignores it. */
+    enabled?: boolean;
+}
+/** A non-destructive adjustment layer (Photoshop's Layer › New Adjustment Layer). */
+type AdjustmentLayer = {
+    [K in AdjustmentKind]: AdjustmentLayerBase & {
+        kind: K;
+        params: AdjustmentParamsMap[K];
+    };
+}[AdjustmentKind];
+type AdjustmentLayerOf<K extends AdjustmentKind> = Extract<AdjustmentLayer, {
+    kind: K;
+}>;
+interface DepthMaskOptions {
+    enabled: boolean;
+    maskSource: string | null;
+    mode: 'threshold' | 'brightness';
+    depthRange: [number, number];
+    softness: number;
+    invert: boolean;
+}
+type AnnotationType = 'pen' | 'rect' | 'circle' | 'arrow' | 'line' | 'text' | 'image';
+interface BaseAnnotation {
+    id: string;
+    type: AnnotationType;
+    x: number;
+    y: number;
+    rotation?: number;
+    opacity?: number;
+    /** Blend mode the annotation is drawn with (default `normal`). */
+    blend?: BlendMode;
+}
+interface PenAnnotation extends BaseAnnotation {
+    type: 'pen';
+    points: ImagePoint[];
+    strokeColor: string;
+    strokeWidth: number;
+}
+interface RectAnnotation extends BaseAnnotation {
+    type: 'rect';
+    width: number;
+    height: number;
+    strokeColor: string;
+    strokeWidth: number;
+    fillColor?: string;
+    cornerRadius?: number;
+}
+interface CircleAnnotation extends BaseAnnotation {
+    type: 'circle';
+    radiusX: number;
+    radiusY: number;
+    strokeColor: string;
+    strokeWidth: number;
+    fillColor?: string;
+}
+interface ArrowAnnotation extends BaseAnnotation {
+    type: 'arrow';
+    endX: number;
+    endY: number;
+    strokeColor: string;
+    strokeWidth: number;
+}
+interface LineAnnotation extends BaseAnnotation {
+    type: 'line';
+    endX: number;
+    endY: number;
+    strokeColor: string;
+    strokeWidth: number;
+}
+interface TextAnnotation extends BaseAnnotation {
+    type: 'text';
+    text: string;
+    fontSize: number;
+    fontFamily?: string;
+    color: string;
+    fontWeight?: string | number;
+}
+interface ImageAnnotation extends BaseAnnotation {
+    type: 'image';
+    src: string;
+    width: number;
+    height: number;
+}
+type Annotation = PenAnnotation | RectAnnotation | CircleAnnotation | ArrowAnnotation | LineAnnotation | TextAnnotation | ImageAnnotation;
+type CreateAnnotationPayload = Omit<PenAnnotation, 'id'> | Omit<RectAnnotation, 'id'> | Omit<CircleAnnotation, 'id'> | Omit<ArrowAnnotation, 'id'> | Omit<LineAnnotation, 'id'> | Omit<TextAnnotation, 'id'> | Omit<ImageAnnotation, 'id'>;
+type ImageEditorTool = 'select' | 'crop' | 'pen' | 'rect' | 'circle' | 'arrow' | 'line' | 'text' | 'watermark' | 'move' | 'brush' | 'eraser' | 'mixer';
+type ImageEditorFit = 'contain' | 'margin';
+interface ImageEditorState {
+    sourceUrl: string | null;
+    /** Canvas (document) size in pixels: the source image's natural size. */
+    imageDimensions: ImageDimensions;
+    crop: CropBox | null;
+    transform: ImageTransform;
+    /**
+     * Compatibility view of the layer stack: the develop filter of the active pixel layer (or the
+     * Background), its blur (or `legacyOutputBlur`), the output opacity and every adjustment layer
+     * in stack order. Edit it with `setAdjustments` and the adjustment-layer methods.
+     */
+    adjustments: ImageAdjustments;
+    /** Compatibility view: the parametric depth mask of the active pixel layer (or the Background). */
+    depthMask: DepthMaskOptions;
+    /** Compatibility view: the annotation of every annotation layer, bottom to top. */
+    annotations: Annotation[];
+    selectedAnnotationId: string | null;
+    activeTool: ImageEditorTool;
+    zoom: number;
+    pan: ImagePoint;
+    isOriginalCompared: boolean;
+    /** Viewport fit mode: 'contain' scales to full viewport bounds; 'margin' scales to 85% with 1.0 cap (default). */
+    fit?: ImageEditorFit;
+    /**
+     * The active selection (8-bit coverage over the source image), or null/missing when nothing is
+     * selected. Recorded in undo history and saved as `selection` in `toJSON()`.
+     */
+    selection?: SelectionMask | null;
+    /** Quick Mask view: tint the unselected area instead of drawing marching ants (view state). */
+    quickMask?: boolean;
+    /**
+     * The layer stack, bottom to top. Opening an image gives one pixel layer, "Background", whose
+     * pixels are the source image. Layers are immutable: compare them by identity.
+     */
+    layers: ImageLayer[];
+    /** The layer that layer commands, painting and `setAdjustments` act on, or `null`. */
+    activeLayerId: string | null;
+    /** Whether painting targets the active layer's pixels or its mask. */
+    activeTarget: LayerTarget;
+    /** Export alpha (0..1), applied after compositing; `adjustments.opacity` mirrors it. */
+    outputOpacity: number;
+    /**
+     * Blur that runs after the adjustment layers, kept from v1 / v2 documents that had both so
+     * they render as before. New edits blur a layer instead (`blur` filter).
+     */
+    legacyOutputBlur?: number;
+    /** Brush settings and foreground / background colours of the paint tools (view state). */
+    paint: PaintOptions;
+    /**
+     * The light layer effects use when they follow the global light (Photoshop's Global Light);
+     * missing = angle 120°, altitude 30°. Recorded in undo history and saved in `toJSON()`.
+     */
+    globalLight?: GlobalLight;
+    /**
+     * The document's patterns (from an opened PSD), which pattern effects use by id besides the
+     * built-in ones. Recorded in undo history and saved in `toJSON()`.
+     */
+    patterns?: EffectPattern[];
+    /**
+     * While a smart object's contents are open for editing (Edit Contents), the smart objects
+     * being edited, outermost first: the state shows the contents as a document of their own until
+     * `closeSmartObjectContents`. Missing when the document itself is shown.
+     */
+    editingContents?: Array<{
+        layerId: string;
+        name: string;
+    }>;
+}
+/**
+ * A stored editor state in the document-level schema (versions 1 and 2). Documents whose layer
+ * stack has exactly this shape are still written this way, byte for byte.
+ */
+interface LegacySerializedImageEditorState {
+    /**
+     * Schema version. `2` adds `adjustments.layers`; states without layers are still written as
+     * `1` so they round-trip unchanged. See `migrateSerializedImageEditorState`.
+     */
+    version: 1 | 2;
+    crop: CropBox | null;
+    transform: ImageTransform;
+    adjustments: ImageAdjustments;
+    depthMask: DepthMaskOptions;
+    annotations: Annotation[];
+    /** The active selection, run-length encoded. Missing when nothing is selected. */
+    selection?: SerializedSelection;
+}
+/**
+ * A stored editor state: the document-level schema (v1 / v2) or the layered schema (v3, see
+ * `SerializedLayeredImageEditorState`). `toJSON()` writes v1 / v2 while the layer stack still
+ * has the shape those versions describe.
+ */
+type SerializedImageEditorState = LegacySerializedImageEditorState | SerializedLayeredImageEditorState;
+interface ExportOptions {
+    format?: 'image/png' | 'image/jpeg' | 'image/webp';
+    quality?: number;
+    width?: number;
+    height?: number;
+    includeAnnotations?: boolean;
+    /** Render only these layers (groups with their children). */
+    layerIds?: string[];
+}
+interface ImageEditorOptions {
+    image?: string | HTMLImageElement;
+    initialState?: Partial<SerializedImageEditorState>;
+    onStateChange?: (state: ImageEditorState) => void;
+    maxHistoryDepth?: number;
+    /**
+     * Upper bound for the pixel data held only by undo / redo steps (tiles shared with the
+     * current state are free). The oldest steps are dropped first. Default 512 MiB.
+     */
+    maxHistoryBytes?: number;
+    /** Viewport fit mode: 'contain' scales to full viewport bounds; 'margin' scales to 85% with 1.0 cap (default). */
+    fit?: ImageEditorFit;
+}
+interface InpaintOptions {
+    prompt: string;
+    imageDataUrl: string;
+    maskDataUrl?: string;
+    cropBox?: CropBox | null;
+}
+interface RemoveBackgroundOptions {
+    imageDataUrl: string;
+}
+type InpaintHook = (options: InpaintOptions) => Promise<string | void> | string | void;
+type RemoveBackgroundHook = (options: RemoveBackgroundOptions) => Promise<string | void> | string | void;
+interface ImageEditorAIHooks {
+    onInpaint?: InpaintHook;
+    onRemoveBackground?: RemoveBackgroundHook;
+}
+
+interface PsdExportInput {
+    width: number;
+    height: number;
+    /** Prepared stack, bottom to top. */
+    layers: readonly ImageLayer[];
+    /** The composite, `width × height` RGBA, written as the merged image. */
+    merged: ArrayLike<number>;
+    /** Pixels per inch (default 72). */
+    resolution?: number;
+    /** The document's patterns; those the effects use are embedded (built-in ones too). */
+    patterns?: readonly EffectPattern[];
+    /** Written as image resources 1037 and 1049. */
+    globalLight?: GlobalLight;
+}
+interface PsdExportResult {
+    bytes: Uint8Array;
+    psb: boolean;
+    /** Layer records written (group folders and dividers included). */
+    records: number;
+    /** One sentence per loss, naming the layers. */
+    warnings: string[];
+}
+/** Writes the prepared stack as PSD (or PSB) bytes. */
+declare function exportPsd(input: PsdExportInput): PsdExportResult;
+
+export { type ArrowAnnotation as $, type AdjustmentKind as A, type SmartFilter as B, type CurvePoint as C, type DepthMaskOptions as D, type SmartObjectLayer as E, type SmartContents as F, type SmartDocument as G, type HueRange as H, type ImageEditorAssetStore as I, type SmartPlacement as J, type FreeTransformGeometry as K, type LevelsChannel as L, type LayerPlacement as M, type FreeTransformMode as N, type FreeTransformResult as O, type PsdExportResult as P, FreeTransformSession as Q, type RefineEdgeParams as R, type SerializedLayer as S, type FreeTransformInit as T, type TransformAnchor as U, type AIResultOptions as V, type AdjustmentLayerBase as W, type AdjustmentLayerInit as X, type AdjustmentLayerUpdate as Y, type AnnotationPlacement as Z, type AnnotationType as _, type ImageAdjustments as a, PaintStrokeSession as a$, type AspectRatio as a0, type BaseAnnotation as a1, type BlackWhiteParams as a2, type BlurFilter as a3, type CircleAnnotation as a4, type ColorBalanceParams as a5, type ColorBalanceTone as a6, type ColorRangeOptions as a7, type ColorRangeSample as a8, type CreateAnnotationPayload as a9, type ImageEditorFit as aA, type ImageEditorOptions as aB, ImageEditorRenderer as aC, type ImageEditorState as aD, type ImageEditorTool as aE, type ImageLayerType as aF, type InpaintHook as aG, type InpaintOptions as aH, type InvertParams as aI, LAYERED_SCHEMA_VERSION as aJ, type LayerBase as aK, type LayerBlendMode as aL, type LayerFilterKind as aM, type LayerLocation as aN, type LayerMaskProps as aO, LayerOperationError as aP, type LayerProperties as aQ, type LayerSourcesHost as aR, type LayerTarget as aS, type LegacySerializedImageEditorState as aT, type LevelsParams as aU, type LineAnnotation as aV, type MagicWandOptions as aW, type MixerStrokeInit as aX, PSD_BLEND_KEYS as aY, type PaintOptions as aZ, type PaintStrokeResult as a_, type CropHandle as aa, type CurvesParams as ab, DEFAULT_ADJUSTMENTS as ac, DEFAULT_DEPTH_MASK as ad, DEFAULT_REFINE_EDGE_PARAMS as ae, DEFAULT_TRANSFORM as af, type DeserializeContext as ag, type DevelopSettings as ah, EMPTY_DISTANCE as ai, type ExportOptions as aj, FREE_TRANSFORM_CONTENTS as ak, FREE_TRANSFORM_MODES as al, type FillOptions as am, type FreeTransformContent as an, type FreeTransformHost as ao, type FreeTransformPreview as ap, GUIDED_FILTER_EPS as aq, type GroupLayer as ar, HISTOGRAM_BINS as as, type HistogramChannel as at, type HistoryEntryHandle as au, type HueSaturationParams as av, IMAGE_EDITOR_SCHEMA_VERSION as aw, type ImageAnnotation as ax, type ImageDimensions as ay, type ImageEditorAIHooks as az, type SerializedImageEditorState as b, blurFilter as b$, type PenAnnotation as b0, type PhotoFilterParams as b1, type PixelBuffer as b2, type PixelLayerInit as b3, type PosterizeParams as b4, type PsdChannel as b5, type PsdExportInput as b6, type PsdFile as b7, type PsdHeader as b8, type PsdImportOptions as b9, type SerializedPixelLayer as bA, type SerializedRasterMask as bB, type SerializedSelection as bC, type SerializedSmartContents as bD, type SerializedSmartFilter as bE, type SerializedSmartObjectLayer as bF, type ShapeSelectionOptions as bG, type SmartFilterKind as bH, type SmartObjectInfo as bI, type SmartPsdData as bJ, type StrokeInit as bK, type StrokeTool as bL, TONE_RANGE_PRESETS as bM, TRANSFORM_ANCHORS as bN, type TextAnnotation as bO, type ThresholdParams as bP, type ToneRangePreset as bQ, type TransformParams as bR, type TransformReadout as bS, type VibranceParams as bT, type ViewportMetrics as bU, addLayerEffect as bV, addLayerFilter as bW, adjustmentNodeAsLayer as bX, anchorPoint as bY, applyImageProjectionToContext as bZ, applyParams as b_, type PsdImportResult as ba, type PsdLayerMask as bb, type PsdLayerRecord as bc, type PsdLayerSummary as bd, type PsdRect as be, type PsdResource as bf, type PsdSmartFilter as bg, type PsdTaggedBlock as bh, type PsdTreeNode as bi, type RectAnnotation as bj, type RemoveBackgroundHook as bk, type RemoveBackgroundOptions as bl, type RenderOptions as bm, SELECTION_MODES as bn, SELECTION_MODIFY_OPS as bo, type SampleOptions as bp, type SelectionChannel as bq, type SelectionCommandOptions as br, type SelectionModifyOp as bs, type SerializeContext as bt, type SerializedAdjustmentLayer as bu, type SerializedAnnotationLayer as bv, type SerializedGroupLayer as bw, type SerializedLayerEffects as bx, type SerializedLayeredImageEditorState as by, type SerializedPattern as bz, type AdjustmentLayer as c, isIdentityTransform as c$, borderCoverage as c0, boxMean as c1, boxPointOf as c2, buildLayerMaskPlanes as c3, calculateCropDrag as c4, canvasToImagePoint as c5, clampCropToImage as c6, colorRange as c7, combineSelections as c8, computeHistogram as c9, exportPsd as cA, featherCoverage as cB, flipCorners as cC, fullSelection as cD, geometryHomography as cE, getAnnotationBounds as cF, getCropCursor as cG, getRotatedSize as cH, getViewportMetrics as cI, getViewportProjection as cJ, globalImageCache as cK, greyMorphology as cL, groupLayers as cM, guidePlanes as cN, guidedFilterColor as cO, hasSurface as cP, hasWarp as cQ, hashMaskContent as cR, histogramPath as cS, hitTestAnnotation as cT, hitTestCrop as cU, hueRange as cV, identityTransform as cW, imageToCanvasPoint as cX, importPsd as cY, invertSelection as cZ, isActiveFilter as c_, computeSelectionBounds as ca, contractCoverage as cb, cornersFromMatrix as cc, coverageToByte as cd, createSelectionMask as ce, decodeLayerChannel as cf, decodeLayerMask as cg, decodeMergedImage as ch, decodePngDataUrl as ci, decodeSelectionRle as cj, depthMaskAlpha as ck, describeTransform as cl, deserializeEffects as cm, deserializeLayer as cn, deserializeLayers as co, deserializePatterns as cp, deserializeSelection as cq, developFilter as cr, distanceTransform as cs, duplicateLayer as ct, edgeWidth as cu, ellipsePoints as cv, ellipseSelection as cw, encodeSelectionRle as cx, encodeSurface as cy, expandCoverage as cz, type AdjustmentParamsMap as d, selectionToPixels as d$, isQuarterTurnSwapped as d0, isSelectionEmpty as d1, isSelectionMode as d2, isSpatialFilter as d3, isTransformAnchor as d4, isValidWarp as d5, layerEffectsOf as d6, layerMaskCoverage as d7, layerMaskFromSelection as d8, layerMaskKey as d9, polygonCoverage as dA, polygonSelection as dB, presetWarp as dC, previewStep as dD, projectImagePoint as dE, projectImageRect as dF, projectMaskCoverage as dG, psdToLayers as dH, readPsd as dI, rectSelection as dJ, referencePoint as dK, refineCoverage as dL, refineEdgeHalo as dM, refineSelection as dN, removeLayer as dO, removeLayerEffect as dP, removeLayerFilter as dQ, requireLayer as dR, requireUnlocked as dS, resizePixels as dT, resizeSelection as dU, resolveExternalAssets as dV, runLayerFilters as dW, selectionArea as dX, selectionFromCoverage as dY, selectionFromPixels as dZ, selectionToCoverage as d_, layerName as da, layerTree as db, layerTypeLabel as dc, magicWand as dd, mapCropHandle as de, matrixFromCorners as df, matrixFromParams as dg, migrateSerializedImageEditorState as dh, migrateToLayeredState as di, modifySelection as dj, moveLayer as dk, newLayerId as dl, normalizeAngle as dm, normalizeFilter as dn, normalizeLayerMask as dp, normalizeRect as dq, normalizeRefineEdgeParams as dr, normalizeStoredAdjustments as ds, offsetLayer as dt, parseBlend as du, parseColor as dv, parseSelectionMode as dw, pixelLayerBounds as dx, pixelLayers as dy, placeLayer as dz, type AdjustmentLayerMask as e, selectionValueAt as e0, serializeContents as e1, serializeEffects as e2, serializeLayer as e3, serializeLayers as e4, serializeLayersExternal as e5, serializePatterns as e6, serializeSelection as e7, setLayerEffects as e8, setLayerEffectsEnabled as e9, setLayerMask as ea, setLayerProperties as eb, shiftCoverage as ec, smartObjectLayers as ed, smoothCoverage as ee, srgb8ToLab as ef, toHex as eg, toneRange as eh, transformHomography as ei, transformMap as ej, transformedBox as ek, transformedPoint as el, ungroupLayer as em, unionRect as en, unprojectCanvasPoint as eo, updateLayerEffect as ep, updateLayerFilter as eq, updateLayerMaskProps as er, withNewIds as es, writePsd as et, type AdjustmentLayerOf as f, ImageEditorController as g, type SelectionMask as h, type SelectionMode as i, type ColorDistance as j, type ImagePoint as k, type ImageLayer as l, type CropBox as m, type RasterMask as n, type Annotation as o, type AdjustmentLayerNode as p, type AnnotationLayer as q, type LayerFilter as r, type PixelLayer as s, type DevelopFilter as t, type ImageTransform as u, type ImageHistogram as v, type ImageProjection as w, type CompositorSources as x, LayerCompositor as y, type SmartFilterStack as z };