@pixerate/editor 0.101.0 → 0.102.0

package/dist/image-editor/index.d.cts

@@ -1,10 +1,10 @@
-import { RasterLayerBase, RasterMask as RasterMask$1, RasterPixelLayer, GroupBlendMode, LayerLocation as LayerLocation$1, LayerLocks, LayerEffect, GlobalLight, LayerEffects, EffectPattern, RasterSources, RasterCompositor, CompositorOptions, LayerEffectKind, Interpolation } from '../raster/index.cjs';
+import { RasterLayerBase, RasterMask as RasterMask$1, RasterPixelLayer, GroupBlendMode, GlobalLight, EffectPattern, Interpolation, LayerLocation as LayerLocation$1, LayerLocks, LayerEffect, LayerEffects, RasterSources, RasterCompositor, CompositorOptions, LayerEffectKind } from '../raster/index.cjs';
 export { BevelContour, BevelEmbossEffect, BevelStyle, BevelTechnique, BevelTexture, ColorOverlayEffect, CompositeCallOptions, CompositeStats, ContourPoint, DEFAULT_GLOBAL_LIGHT, DIRECT_GAUSSIAN_MAX_SIGMA, DecodedPng, DropShadowEffect, EffectContour, EffectFill, EffectGradient, EffectPatternRef, EffectRect, GlowTechnique, GradientColorStop, GradientOpacityStop, GradientOverlayEffect, GradientStyle, INTERPOLATIONS, InnerGlowEffect, InnerShadowEffect, LAYER_EFFECT_KINDS, LayerEffectError, MAX_EFFECT_REACH, MAX_TRANSFORM_PIXELS, OuterGlowEffect, PatternOverlayEffect, PatternPlacement, PatternTile, ResampleOptions, SatinEffect, StrokeEffect, StrokePosition, TransformTooLargeError, ZlibError, adler32, base64ToBytes, blendTile, builtinPattern, builtinPatternIds, bytesToBase64, changedTiles, compositeSurfaceOver, curveLut, decodePng, defaultEffectGradient, defaultLayerEffect, deflate, deflateRaw, effectColorHex, effectReach, effectsFingerprint, effectsMargin, effectsScale, encodePng, findLayer, flattenLayers, gaussianBlur, hasActiveEffects, hashNoise, inflate, inflateRaw, insertLayer, isInterpolation, isLayerEffectKind, isLayerLocked, isPng, keysWeight, layerEffectFields, layerEffectLabel, mapLayer, mergeLayerEffect, newEffectId, normalizeLayerEffects, parseDataUrl, parseEffectColor, pngDataUrl, reduceSurface, renderLayerEffects, scaleLayerEffect, transformSurface, transformedBounds, validateEffectGradient, validateLayerEffect, validateLayerEffects, warpSurface } from '../raster/index.cjs';
-import { P as PixelSurface, T as TiledSurface, B as BlendMode } from '../surface-DIA-XatS.cjs';
-export { a as BLEND_MODES, b as BlendModeInfo, M as MaskSurface, R as RasterRect, c as Rgb, d as Rgba, S as SurfaceDraft, e as TILE, f as TILE_SHIFT, g as Tile, h as TileKey, i as blendChannel, j as blendImageData, k as blendLum, l as blendPixel, m as blendRgb, n as canvasCompositeOperation, o as collectTiles, p as contentBounds, q as emptySurface, r as fillRect, s as finishTile, t as isBlendMode, u as isSeparableBlendMode, v as mixPigment8, w as mixPigmentRgb, x as normalizeBlendMode, y as packRgba, z as readPixel, A as readRegion, C as setLum, D as solidSurface, E as surfaceBytes, F as surfaceFromPixels, G as surfacesEqual, H as tileCoord, I as tileKey, J as tileRect, K as tilesInRect, L as translateSurface, N as uniformTile, O as writeRegion } from '../surface-DIA-XatS.cjs';
+import { P as PixelSurface, B as BlendMode, T as TiledSurface, R as RasterRect } from '../surface-DIA-XatS.cjs';
+export { a as BLEND_MODES, b as BlendModeInfo, M as MaskSurface, c as Rgb, d as Rgba, S as SurfaceDraft, e as TILE, f as TILE_SHIFT, g as Tile, h as TileKey, i as blendChannel, j as blendImageData, k as blendLum, l as blendPixel, m as blendRgb, n as canvasCompositeOperation, o as collectTiles, p as contentBounds, q as emptySurface, r as fillRect, s as finishTile, t as isBlendMode, u as isSeparableBlendMode, v as mixPigment8, w as mixPigmentRgb, x as normalizeBlendMode, y as packRgba, z as readPixel, A as readRegion, C as setLum, D as solidSurface, E as surfaceBytes, F as surfaceFromPixels, G as surfacesEqual, H as tileCoord, I as tileKey, J as tileRect, K as tilesInRect, L as translateSurface, N as uniformTile, O as writeRegion } from '../surface-DIA-XatS.cjs';
+import { Q as Quad, a as WarpMesh, V as Vec2, A as AffineMatrix, H as Homography, W as WarpStyle } from '../types-CwMPoRMU.cjs';
 import { BrushSettings, MixerSettings, MixerLoad, StrokeCoverage, MixerTarget, MixerStroke, StrokeApply, StrokePoint } from '../paint/index.cjs';
 export { CoverageMap, DEFAULT_BRUSH, DEFAULT_MIXER, Dab, DabWalker, EMPTY_MIXER_LOAD, MAX_BRUSH_SIZE, MIXER_DRAIN, MIXER_PICKUP_RATE, MIXING_MODELS, MixingModel, PIGMENT_BANDS, PIGMENT_LAMBDA_MIN, PIGMENT_LAMBDA_STEP, PIGMENT_WAVELENGTHS, Pigment, PigmentOptions, PigmentRgb, applyStrokeToTile, cleanMixer, coverageTileCoord, createPigment, createPigmentTools, dabCoverage, dabRect, lerpPigment, lerpPigmentInto, loadMixer, mixPigments, normalizeBrush, normalizeMixer, rasterizeDab, reflectanceToRgb, rgbToReflectance, setPigmentColor, smoothPoints, tipFalloff, tipReach, tipShape, walkDabs } from '../paint/index.cjs';
-import { Q as Quad, a as WarpMesh, V as Vec2, A as AffineMatrix, H as Homography, W as WarpStyle } from '../types-CwMPoRMU.cjs';
 import { b as WarpPreset } from '../warp-nYs2DPrx.cjs';
 export { W as WARP_STYLES, a as WARP_STYLE_LABELS, c as applyHomography, B as boxQuad, d as dragWarpMeshPoint, e as evalWarpMesh, C as homographyFromAffine, l as homographyFromPoints, q as identityWarpMesh, D as invertHomography, p as pullWarpMesh, E as rectToQuad, h as resizeWarpMesh, u as warpMeshEditPoints, v as warpMeshGridCurves, x as warpMeshParamAt, A as warpPresetMesh } from '../warp-nYs2DPrx.cjs';
 import { b as LoadReport, J as JsonObject, f as MigrationStep } from '../migrate-iTlm3a8h.cjs';
@@ -175,10 +175,125 @@ interface AnnotationLayer extends LayerBase {
     type: 'annotation';
     annotation: Annotation;
 }
-type ImageLayer = PixelLayer | AdjustmentLayerNode | GroupLayer | AnnotationLayer;
+/** 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. */
-type LayerTarget = 'pixels' | 'mask';
+/** 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>;
@@ -196,6 +311,10 @@ declare function isSpatialFilter(f: LayerFilter): boolean;
 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
@@ -270,7 +389,65 @@ interface SerializedAnnotationLayer extends SerializedLayerBase {
     type: 'annotation';
     annotation: Annotation;
 }
-type SerializedLayer = SerializedPixelLayer | SerializedAdjustmentLayer | SerializedGroupLayer | SerializedAnnotationLayer;
+/** 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;
@@ -293,6 +470,8 @@ interface SerializedLayeredImageEditorState {
     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;
@@ -312,15 +491,23 @@ 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;
-/** Serializes a layer tree with inline assets (asset ids are derived from layer ids). */
+/** 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 })`):
@@ -341,6 +528,7 @@ interface ImageEditorAssetStore {
 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),
@@ -349,6 +537,15 @@ declare function serializeLayersExternal(layers: readonly ImageLayer[], store: I
 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;
@@ -419,8 +616,8 @@ declare function histogramPath(histogram: ImageHistogram, channel: HistogramChan
 
 /** What the compositor needs from its host besides the layers. */
 interface CompositorSources extends RasterSources {
-    /** The pixels of a pixel layer (resolves layers whose pixels are the document source). */
-    surfaceOf?(layer: PixelLayer): PixelSurface;
+    /** 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).
@@ -437,6 +634,8 @@ interface CompositorSources extends RasterSources {
 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);
@@ -1413,8 +1612,8 @@ interface FreeTransformHost {
         width: number;
         height: number;
     };
-    /** The pixels a pixel layer composites (the decoded source for the Background). */
-    pixelsOf(layer: PixelLayer): TiledSurface;
+    /** 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). */
@@ -1442,7 +1641,19 @@ declare class FreeTransformSession {
     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;
@@ -1469,6 +1680,10 @@ declare class FreeTransformSession {
     }, 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;
@@ -1477,6 +1692,65 @@ declare class FreeTransformSession {
     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. */
@@ -1780,7 +2054,7 @@ declare class ImageEditorController {
     private nextSourceId;
     /** Changes whenever the Background's source pixels can have changed. */
     private sourceVersion;
-    /** The pixels a pixel layer composites (the decoded source for the Background). */
+    /** 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
@@ -1912,6 +2186,152 @@ declare class ImageEditorController {
     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;
     /**
@@ -2640,6 +3060,15 @@ interface ImageEditorState {
      * 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
@@ -3141,6 +3570,12 @@ interface ImageEditorToolProviderOptions {
  *   `flip_image`, `undo_image`, `redo_image` (see `createImageEditTools`).
  * - Free Transform: `get_transform_frame`, `transform_layer`, `warp_layer`, `transform_selection`,
  *   `flip_layer`, `rotate_layer_90` (see `createImageTransformTools`).
+ * - Smart objects and smart filters: `get_smart_object`, `convert_to_smart_object`,
+ *   `rasterize_smart_object`, `set_smart_object_transform`, `replace_smart_object_contents`,
+ *   `export_smart_object_contents`, `copy_smart_object`, `edit_smart_object_contents`,
+ *   `close_smart_object_contents`, `add_smart_filter`, `update_smart_filter`, `remove_smart_filter`,
+ *   `move_smart_filter`, `set_smart_filters_enabled`, `set_smart_filter_mask` (see
+ *   `createImageSmartObjectTools`).
  */
 declare function createImageEditorToolProvider(controller: ImageEditorController, options?: ImageEditorToolProviderOptions): AgentToolProvider;
 
@@ -3520,6 +3955,187 @@ declare function addToHistogram(h: ImageHistogram, data: ArrayLike<number>, stri
 /** Sums histograms (and recomputes `max`). */
 declare function sumHistograms(parts: Iterable<ImageHistogram>): ImageHistogram;
 
+/**
+ * How far beyond the canvas a smart object is rendered (document pixels): enough for any layer
+ * effect to see the parts just outside the canvas. Further out a smart object is not drawn.
+ */
+declare const SMART_RENDER_MARGIN = 512;
+/** The document canvas a smart object renders for. */
+interface SmartCanvas {
+    width: number;
+    height: number;
+}
+/** A fresh contents id (independent contents). */
+declare function newContentsId(): string;
+/** The contents' rectangle in its own pixels. */
+declare function contentsBox(contents: SmartContents): CropBox;
+/** A smart object's placement as Free Transform geometry (the frame is the contents' rectangle). */
+declare function placementGeometry(layer: Pick<SmartObjectLayer, 'contents' | 'placement'>): FreeTransformGeometry;
+/** The placement that draws the contents 1:1 with their top-left corner at (`x`, `y`). */
+declare function placementAt(contents: Pick<SmartContents, 'width' | 'height'>, x: number, y: number): SmartPlacement;
+/** Whether the contents can be rendered here (decoded pixels or a layer document). */
+declare function isContentsDecoded(contents: SmartContents): boolean;
+/** The layer with `id`, which must be a smart object. */
+declare function requireSmartObject(layers: readonly ImageLayer[], id: string): SmartObjectLayer;
+/**
+ * The contents as pixels at (0, 0) in their own space: the raster, or the nested document
+ * composited at its size (annotation layers inside need a canvas and are left out). Memoised.
+ */
+declare function contentsSurface(contents: SmartContents): PixelSurface;
+/** Raster contents from RGBA pixels. */
+declare function rasterContents(pixels: {
+    width: number;
+    height: number;
+    data: ArrayLike<number>;
+}, name: string, id?: string): SmartContents;
+/** Document contents from layers on a `width × height` canvas. */
+declare function documentContents(document: SmartDocument, width: number, height: number, name: string, id?: string): SmartContents;
+/** How a render runs: full quality (default), or a fast preview. */
+interface SmartRenderOptions {
+    /** Preview block size (a power of two): sample a reduced copy of the contents once per block. */
+    step?: number;
+    /** Only this part of the document (the visible area). */
+    clip?: RasterRect;
+    /** Leave the smart filters out (previews while transforming). */
+    skipFilters?: boolean;
+    /** Reduced copies of the contents by factor, kept by the caller between previews. */
+    reduced?: Map<number, PixelSurface>;
+}
+/** The contents placed in the document (no filters), clipped to the canvas grown by the render margin. */
+declare function placeContents(layer: Pick<SmartObjectLayer, 'contents' | 'placement'>, canvas: SmartCanvas, options?: SmartRenderOptions): PixelSurface;
+/** The filters of a stack that change pixels (the stack enabled, each filter active, a modelled kind). */
+declare function activeSmartFilters(stack: SmartFilterStack | undefined): Array<SmartFilter & LayerFilter>;
+/** A filter mask's coverage over the canvas (0..1), after density and feather; `null` reveals all. */
+declare function filterMaskCoverage(mask: RasterMask | undefined, canvas: SmartCanvas): Float32Array | null;
+/**
+ * Runs a smart filter stack over the placed contents, over the canvas (spatial filters clamp at
+ * its edges, as a pixel layer's filters do): each filter filters the result below it, and its own
+ * blend mode and opacity mix its result with that input. The filter mask then mixes the filtered
+ * result with the unfiltered contents. Returns `placed` itself when no filter is active.
+ */
+declare function applySmartFilters(placed: PixelSurface, stack: SmartFilterStack | undefined, canvas: SmartCanvas): PixelSurface;
+/** A smart object's pixels: the contents through the placement, then the smart filters. */
+declare function renderSmartObject(layer: Pick<SmartObjectLayer, 'contents' | 'placement' | 'smartFilters'>, canvas: SmartCanvas, options?: SmartRenderOptions): PixelSurface;
+/** The layer with its pixels rendered again (refused when the contents are not decoded). */
+declare function rerender(layer: SmartObjectLayer, canvas: SmartCanvas, action?: string): SmartObjectLayer;
+/** Validates a placement for contents of `width × height`; returns a clean copy. */
+declare function normalizePlacement(raw: SmartPlacement, contents: Pick<SmartContents, 'width' | 'height'>): SmartPlacement;
+/**
+ * Sets a smart object's placement (corners, warp, interpolation) and renders it again from its
+ * contents. A linked layer mask and filter mask follow a warp-free change. Returns the stack and
+ * whether the masks moved.
+ */
+declare function setSmartPlacement(layers: readonly ImageLayer[], id: string, placement: SmartPlacement, canvas: SmartCanvas): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+    masksMoved: boolean;
+};
+/**
+ * Moves a smart object by whole pixels (the move tool): its corners, a linked mask and filter mask
+ * move with it. Without spatial smart filters the rendered pixels are shifted, not resampled.
+ */
+declare function offsetSmartObject(layers: readonly ImageLayer[], id: string, dx: number, dy: number, canvas: SmartCanvas): ImageLayer[];
+interface ConvertOptions {
+    /** The pixels of a pixel layer (resolves the Background's document source). */
+    surfaceOf(layer: PixelLayer): PixelSurface;
+    /** Name of the new layer (default: the top layer's name). */
+    name?: string;
+}
+/**
+ * Layer › Smart Objects › Convert to Smart Object: sibling layers become one smart object at the
+ * position of the topmost one.
+ *
+ * - One pixel layer becomes raster contents (its pixels, cropped to their bounds) and keeps its
+ *   id, name, visibility, opacity, fill, blend, clipping, mask and effects; its filters become
+ *   smart filters. It renders exactly as before.
+ * - Anything else (several layers, a group, an adjustment, a smart object) becomes a nested
+ *   document holding the layers as they were, sized to their bounds (effects included), and the
+ *   new layer is a plain Normal layer named after the top one, rendering the isolated composite.
+ *
+ * Returns the stack, the new layer and its contents.
+ */
+declare function convertToSmartObject(layers: readonly ImageLayer[], ids: readonly string[], canvas: SmartCanvas, options: ConvertOptions): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+};
+/**
+ * Layer › Smart Objects › Rasterize: the smart object becomes a pixel layer holding what it
+ * renders (filters baked), with its mask, effects, blend, opacity and fill. Same id.
+ */
+declare function rasterizeSmartObject(layers: readonly ImageLayer[], id: string): {
+    layers: ImageLayer[];
+    layer: PixelLayer;
+};
+/**
+ * Layer › Smart Objects › New Smart Object via Copy (`linked: false`, fresh contents that edit
+ * independently) or a linked duplicate (`linked: true`, shared contents), directly above.
+ */
+declare function copySmartObject(layers: readonly ImageLayer[], id: string, linked: boolean, name?: string): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+};
+/** Ids of the smart objects in the stack placed from contents `contentsId` (linked instances), bottom first. */
+declare function instancesOf(layers: readonly ImageLayer[], contentsId: string): string[];
+/**
+ * Puts new contents into every instance of `contentsId` and renders them again. With
+ * `keepPlacement` false (Replace Contents of a different size), each instance keeps its scale and
+ * rotation about the contents' centre, and a warp is stretched to the new size.
+ */
+declare function replaceContents(layers: readonly ImageLayer[], contentsId: string, contents: SmartContents, canvas: SmartCanvas): {
+    layers: ImageLayer[];
+    ids: string[];
+};
+/** A clean smart filter from loose input: a `develop` or `blur` filter plus blend and opacity. */
+declare function normalizeSmartFilter(raw: Record<string, unknown> & {
+    kind: string;
+}, id?: string): SmartFilter;
+/** Adds a smart filter at `index` (default the top). Returns the stack and the filter. */
+declare function addSmartFilter(layers: readonly ImageLayer[], id: string, filter: SmartFilter, canvas: SmartCanvas, index?: number): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+    filter: SmartFilter;
+};
+/** Changes one smart filter (settings, enabled, blend, opacity; validated). */
+declare function updateSmartFilter(layers: readonly ImageLayer[], id: string, filterId: string, changes: Record<string, unknown>, canvas: SmartCanvas): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+    filter: SmartFilter;
+};
+/** Removes one smart filter. */
+declare function removeSmartFilter(layers: readonly ImageLayer[], id: string, filterId: string, canvas: SmartCanvas): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+};
+/** Moves one smart filter to `index` (0 = bottom, applied first). */
+declare function moveSmartFilter(layers: readonly ImageLayer[], id: string, filterId: string, index: number, canvas: SmartCanvas): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+};
+/** Turns the whole smart filter stack on or off (each filter keeps its own switch). */
+declare function setSmartFiltersEnabled(layers: readonly ImageLayer[], id: string, enabled: boolean, canvas: SmartCanvas): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+};
+/** Sets or removes (`null`) the smart filter mask. */
+declare function setSmartFilterMask(layers: readonly ImageLayer[], id: string, mask: RasterMask | null, canvas: SmartCanvas): {
+    layers: ImageLayer[];
+    layer: SmartObjectLayer;
+};
+/** A smart object's filter mask surface replaced (painting it), rendered again. */
+declare function withFilterMaskSurface(layer: SmartObjectLayer, surface: PixelSurface, canvas: SmartCanvas): SmartObjectLayer;
+/** The transformed outline of a smart object's contents (document bounds, warp included). */
+declare function placementBounds(layer: Pick<SmartObjectLayer, 'contents' | 'placement'>): CropBox | null;
+
+/**
+ * Agent tools for smart objects in the image editor: `get_smart_object`, `convert_to_smart_object`,
+ * `rasterize_smart_object`, `set_smart_object_transform`, `replace_smart_object_contents`,
+ * `export_smart_object_contents`, `copy_smart_object`, `edit_smart_object_contents`,
+ * `close_smart_object_contents`, and the smart filter stack: `add_smart_filter`,
+ * `update_smart_filter`, `remove_smart_filter`, `move_smart_filter`, `set_smart_filters_enabled`,
+ * `set_smart_filter_mask`. Every write is one undo step, validates first and returns what changed.
+ */
+declare function createImageSmartObjectTools(controller: ImageEditorController): AgentTool[];
+
 /**
  * The layers panel's view model, shared by the React and Svelte panels: the rows to show (top of
  * the stack first, groups indented, collapsed groups hiding their children), where a drop lands,
@@ -3550,7 +4166,7 @@ type DropZone = 'above' | 'below' | 'inside';
 declare function dropZone(fraction: number, isGroup: boolean): DropZone;
 /** The placement for `move_layer` when `dragId` is dropped on row `targetId` in `zone`, or `null` for a no-op. */
 declare function dropPlacement(layers: readonly ImageLayer[], dragId: string, targetId: string, zone: DropZone): LayerPlacement | null;
-type LayerMenuAction = 'new-layer' | 'new-group' | 'duplicate' | 'delete' | 'group-selected' | 'ungroup' | 'merge-down' | 'merge-visible' | 'flatten' | 'via-copy' | 'via-cut' | 'add-mask' | 'add-mask-selection' | 'apply-mask' | 'delete-mask' | 'toggle-mask' | 'toggle-mask-link' | 'toggle-clip' | 'rasterize';
+type LayerMenuAction = 'new-layer' | 'new-group' | 'duplicate' | 'delete' | 'group-selected' | 'ungroup' | 'merge-down' | 'merge-visible' | 'flatten' | 'via-copy' | 'via-cut' | 'add-mask' | 'add-mask-selection' | 'apply-mask' | 'delete-mask' | 'toggle-mask' | 'toggle-mask-link' | 'toggle-clip' | 'rasterize' | 'convert-smart' | 'edit-contents' | 'smart-via-copy' | 'add-filter-mask';
 interface LayerMenuItem {
     action: LayerMenuAction;
     label: string;
@@ -3560,6 +4176,18 @@ interface LayerMenuItem {
 declare function layerMenu(controller: ImageEditorController): LayerMenuItem[];
 /** Runs a menu action on the active layer. Resolves to the error message when it was refused. */
 declare function runLayerMenuAction(controller: ImageEditorController, action: LayerMenuAction): Promise<string | null>;
+/** One row of a smart object's filter list (Photoshop shows them under the layer, top filter first). */
+interface SmartFilterRow {
+    filter: SmartFilter;
+    /** Display name: Develop, Blur (radius), or the Photoshop filter's name. */
+    label: string;
+    /** Index in the stack, 0 = bottom (applied first). */
+    index: number;
+    /** False for Photoshop filters we keep but do not draw. */
+    drawn: boolean;
+}
+/** The filter rows of a smart object, top filter first (empty when it has none). */
+declare function smartFilterRows(layer: ImageLayer): SmartFilterRow[];
 
 /**
  * The layer effects section's view model, shared by the React and Svelte panels: whether a layer
@@ -4192,4 +4820,4 @@ declare class FreeTransformTool {
     key(e: ShortcutEvent): boolean;
 }
 
-export { ADJUSTMENT_KEYS, ADJUSTMENT_KINDS, ADJUSTMENT_LAYER_CONTROLS, ADJUSTMENT_LAYER_OPACITY_CONTROL, ADJUSTMENT_LUT_SIZE, type AIResultOptions, AS_SHOT_KELVIN, type AdjustmentKind, type AdjustmentKindInfo, type AdjustmentLayer, type AdjustmentLayerBase, type AdjustmentLayerInit, type AdjustmentLayerMask, type AdjustmentLayerNode, type AdjustmentLayerOf, type AdjustmentLayerUpdate, type AdjustmentParamsMap, AffineMatrix, type Annotation, type AnnotationLayer, type AnnotationPlacement, type AnnotationType, type ArrowAnnotation, type AspectRatio, BACKGROUND_LAYER_ID, BACKGROUND_LAYER_NAME, BLUR_FILTER_ID, BRUSH_OPTION_CONTROLS, type BaseAnnotation, type BlackWhiteParams, BlendMode, type BlurFilter, BrushSettings, type Chromaticity, type CircleAnnotation, type ColorBalanceParams, type ColorBalanceTone, type ColorDistance, type ColorRangeOptions, type ColorRangeSample, CompositorOptions, type CompositorSources, type ControlSection, type ControlSpec, type ControlTrack, type CreateAnnotationPayload, type CropBox, type CropHandle, type CurvePoint, type CurvesParams, D50, D65, DEFAULT_ADJUSTMENTS, DEFAULT_DEPTH_MASK, DEFAULT_REFINE_EDGE_PARAMS, DEFAULT_SELECTION_TOOL_OPTIONS, DEFAULT_TRANSFORM, DEVELOP_FILTER_ID, type DepthMaskOptions, type DescValue, type Descriptor, type DeserializeContext, type DevelopFilter, type DevelopSettings, type DropZone, EMPTY_DISTANCE, type EffectControl, EffectPattern, type ExportOptions, FREE_TRANSFORM_CONTENTS, FREE_TRANSFORM_FIELDS, FREE_TRANSFORM_MODES, FREE_TRANSFORM_MODE_OPTIONS, type FillOptions, type FreeTransformBar, type FreeTransformContent, type FreeTransformField, type FreeTransformGeometry, type FreeTransformHost, type FreeTransformInit, type FreeTransformMode, type FreeTransformPreview, type FreeTransformResult, FreeTransformSession, FreeTransformTool, type FreeTransformToolOptions, GUIDED_FILTER_EPS, type GestureModifiers, GlobalLight, type GroupLayer, HISTOGRAM_BINS, HUE_RANGE_LABELS, type HistogramChannel, type HistoryEntryHandle, Homography, type HueRange, type HueSaturationParams, IDENTITY_MATRIX3, IMAGE_ADJUSTMENT_CONTROLS, IMAGE_EDITOR_SCHEMA_VERSION, IMAGE_EDITOR_STATE_VERSION, type ImageAdjustments, type ImageAnnotation, type ImageDimensions, type ImageEditorAIHooks, type ImageEditorAssetStore, ImageEditorController, type ImageEditorDocumentLoad, type ImageEditorFit, type ImageEditorOptions, ImageEditorRenderer, type ImageEditorState, type ImageEditorTool, type ImageEditorToolProviderOptions, type ImageHistogram, type ImageLayer, type ImageLayerType, type ImagePoint, type ImageProcessVersion, type ImageProjection, type ImageTransform, type InpaintHook, type InpaintOptions, Interpolation, type InvertParams, LATEST_PROCESS_VERSION, LAYERED_SCHEMA_VERSION, LAYER_EFFECT_MENU, LEGACY_PROCESS_VERSION, LUMA_709, type LayerBase, type LayerBlendMode, LayerCompositor, LayerEffect, LayerEffectKind, type LayerEffectRow, LayerEffects, type LayerEffectsPanelModel, type LayerFilter, type LayerFilterKind, type LayerLocation, LayerLocks, type LayerMaskProps, type LayerMenuAction, type LayerMenuItem, LayerOperationError, type LayerPanelRow, type LayerPlacement, type LayerProperties, type LayerSourcesHost, type LayerStack, type LayerTarget, type LegacyParts, type LegacySerializedImageEditorState, type LegacyViewResult, type LevelsChannel, type LevelsParams, type LineAnnotation, MAX_KELVIN, MIN_KELVIN, MIRED_PER_TEMPERATURE_UNIT, MIXER_MIXING_OPTIONS, MIXER_OPTION_CONTROLS, type MagicWandOptions, type Matrix3, MixerLoad, MixerSettings, MixerStroke, type MixerStrokeInit, MixerTarget, type MosaicImageDataLike, type MosaicRegion, PAINT_TOOLS, PATTERN_BLOCK_KEYS, PSD_BLEND_KEYS, PSD_FILE_ACCEPT, PaintGesture, type PaintOptions, type PaintPointerSample, type PaintStrokeResult, PaintStrokeSession, type PaintTool, type ParsedAdjustment, type ParsedLayerEffects, type PenAnnotation, type PhotoFilterParams, type PixelBuffer, type PixelLayer, type PixelLayerInit, type PixelOp, PixelSurface, type PlaneLayout, type PosterizeParams, type PsdChannel, PsdError, type PsdExportInput, type PsdExportResult, type PsdFile, type PsdHeader, type PsdImportOptions, type PsdImportResult, type PsdLayerMask, type PsdLayerRecord, type PsdLayerSummary, type PsdPattern, type PsdRect, type PsdResource, type PsdTaggedBlock, type PsdTreeNode, Quad, type QuickMaskStyle, REFINE_EDGE_CONTROLS, type RasterMask, type RectAnnotation, type ReferenceItem, type RefineEdgeControl, type RefineEdgeParams, type RemoveBackgroundHook, type RemoveBackgroundOptions, type RenderOptions, type RouteInput, SELECTION_MODES, SELECTION_MODE_LABELS, SELECTION_MODIFY_OPS, SELECTION_TOOLS, SUPPORTED_ADJUSTMENT_KEYS, type SampleOptions, type SelectionChannel, type SelectionCommandOptions, SelectionGesture, type SelectionMask, type SelectionMode, type SelectionModifyOp, type SelectionToolKind, type SelectionToolOptions, type SerializeContext, type SerializedAdjustmentLayer, type SerializedAnnotationLayer, type SerializedGroupLayer, type SerializedImageEditorState, type SerializedLayer, type SerializedLayerEffects, type SerializedLayeredImageEditorState, type SerializedPattern, type SerializedPixelLayer, type SerializedRasterMask, type SerializedSelection, type ShapeSelectionOptions, type ShortcutEvent, StrokeApply, StrokeCoverage, type StrokeInit, StrokePoint, type StrokeTool, TINT_SCALE, TONE_LUT_SIZE, TONE_RANGE_PRESETS, TRANSFORM_ANCHORS, type TextAnnotation, type ThresholdParams, TiledSurface, type ToneRangePreset, type TransformAnchor, type TransformHandle, type TransformModifiers, type TransformOverlay, type TransformParams, type TransformReadout, type UnitLevels, VIBRANCE_GREY, Vec2, type VibranceParams, type ViewportMetrics, WARP_GRID_OPTIONS, WARP_STYLE_OPTIONS, type WarpBar, WarpMesh, WarpPreset, WarpStyle, XYZ_D50_TO_SRGB, activeAdjustmentLayers, addLayerEffect, addLayerFilter, addToHistogram, adjustmentKindLabel, adjustmentLayersKey, adjustmentNodeAsLayer, adjustmentNodeFromLegacy, anchorPoint, annotationLayerFor, annotationLayerName, applyAdjustmentLayers, applyAdjustments, applyBoxBlur, applyDepthMask, applyImageProjectionToContext, applyLegacyAdjustments, applyMatrix3, applyOutputStage, applyParams, applyProcess2Adjustments, applyRegionBlur, applyRegionMosaic, backgroundLayer, baseProjection, blackWhiteGray, blurFilter, borderCoverage, boxMean, boxPointOf, boxToCurvePoint, bradfordAdaptation, buildLayerMaskPlanes, buildToneLut, calculateCropDrag, canvasToImagePoint, clampControlValue, clampCropToImage, colorBalanceChannel, colorRange, combineSelections, compileAdjustmentLayer, computeHistogram, computeSelectionBounds, contractCoverage, controlPosition, controlTrackBackground, cornersFromMatrix, coverageToByte, coveringRect, createAdjustmentLayer, createImageCaptureSurface, createImageEditTools, createImageEditorToolProvider, createImageEffectTools, createImageLayerTools, createImagePaintTools, createImagePsdTools, createImageSelectionTools, createImageTransformTools, createSelectionMask, curveLutFromLevels, curvePointToBox, curveSvgPath, decodeLayerChannel, decodeLayerMask, decodeMergedImage, decodePlanes, decodePngDataUrl, decodeSelectionRle, defaultAdjustmentParams, depthMaskAlpha, depthRasterMask, describeLayer, describeLayerEffects, describeSelection, describeTransform, deserializeEffects, deserializeLayer, deserializeLayers, deserializePatterns, deserializeSelection, developFilter, developFromAdjustments, developTarget, distanceTransform, downloadPsd, dropPlacement, dropZone, duplicateLayer, edgeWidth, effectControlChange, ellipsePoints, ellipseSelection, emptyHistogram, encodeRle, encodeSelectionRle, encodeSurface, evaluateAdjustmentLayers, expandCoverage, exportPsd, featherCoverage, findAdjustmentControl, findLayerControl, flipCorners, formatControlValue, fullSelection, geometryHomography, getAnnotationBounds, getControlPath, getCropCursor, getRotatedSize, getViewportMetrics, getViewportProjection, globalImageCache, greyMorphology, groupLayers, guidePlanes, guidedFilterColor, handlePaintShortcut, hasResampledLegacyMask, hasWarp, hashMaskContent, hexToRgb, histogramPath, hitTestAnnotation, hitTestCrop, hitTestCurvePoint, hslToRgb, hueRange, hueRangeTables, hueRangeWeight, hueSaturation, identityCurve, identityLevels, identityTransform, imageEditorStateMigrations, imageToCanvasPoint, importPsd, insertCurvePoint, invertMatrix3, invertSelection, isActiveFilter, isAdjustmentKind, isDefaultDepthMask, isIdentityTransform, isLegacyShape, isPaintTool, isQuarterTurn, isQuarterTurnSwapped, isSelectionEmpty, isSelectionMode, isSpatialFilter, isTransformAnchor, isValidWarp, kelvinToTemperature, layerBadge, layerEffectControls, layerEffectsBadge, layerEffectsOf, layerEffectsPanel, layerLabel, layerMaskCoverage, layerMaskFromSelection, layerMaskKey, layerMenu, layerName, layerPanelRows, layerTree, layerTypeLabel, layersFromLegacy, legacyAdjustmentLayer, legacyMaskOf, legacyView, levelsValue, linearSrgbToXy, linearToSrgb, loadImageEditorDocument, magicWand, mapCropHandle, maskSummary, matrixFromCorners, matrixFromParams, migrateSerializedImageEditorState, migrateToLayeredState, mixerLoadResult, modifySelection, moveCurvePoint, moveLayer, mulMatrix3, needsLegacyBase, neutralHueRange, newLayerId, normalizeAdjustmentLayer, normalizeAdjustmentLayers, normalizeAngle, normalizeFilter, normalizeLayerMask, normalizeProcessVersion, normalizeRect, normalizeRefineEdgeParams, normalizeStoredAdjustments, offsetLayer, openPsdFile, parseAdjustmentBlock, parseBlend, parseColor, parseLfx2, parseLrfx, parsePatternBlock, parseSelectionMode, parseVersionedDescriptor, photoFilterMatrix, pixelLayerBounds, pixelLayers, placeLayer, pointerPressure, polygonCoverage, polygonSelection, posterizeValue, presetWarp, previewStep, projectImagePoint, projectImageRect, projectMaskCoverage, projectQuarterTurn, psdBytesFromBase64, psdFileName, psdPatternToEffectPattern, psdToLayers, quickMaskPixels, rangeLightness, rasterMaskFromLegacy, readAdjustmentControls, readPsd, rectSelection, referencePoint, refineCoverage, refineEdgeHalo, refineSelection, removeAlpha, removeCurvePoint, removeLayer, removeLayerEffect, removeLayerFilter, renderLayeredBase, requireLayer, requireUnlocked, resizePixels, resizeSelection, resolveExternalAssets, resolveMosaicRegionBounds, rgbToGray, rgbToHsl, rgbUnitToHex, runLayerMenuAction, sampleLut, sampleToneLut, selectionArea, selectionFromCoverage, selectionFromPixels, selectionModeFromModifiers, selectionOutline, selectionToCoverage, selectionToPixels, selectionValueAt, serializeEffects, serializeLayer, serializeLayers, serializeLayersExternal, serializePatterns, serializeSelection, setControlPath, setLayerEffects, setLayerEffectsEnabled, setLayerMask, setLayerProperties, shiftCoverage, smoothCoverage, splitOverlayAnnotations, srgb8ToLab, srgbToLinear, sumHistograms, tempTintToXy, temperatureToKelvin, toHex, toneCurve, toneLuts, toneRange, transformHomography, transformMap, transformedBox, transformedPoint, ungroupLayer, unionRect, unprojectCanvasPoint, updateLayerEffect, updateLayerFilter, updateLayerMaskProps, uvToXy, versionedDescriptorBytes, vibranceLinear, vibrancePixel, wbMatrix, whiteBalanceFromSample, whiteBalanceMatrix, withNewIds, writeAdjustmentBlock, writeLfx2, writePatternBlock, writePsd, xyToTempTint, xyToUv };
+export { ADJUSTMENT_KEYS, ADJUSTMENT_KINDS, ADJUSTMENT_LAYER_CONTROLS, ADJUSTMENT_LAYER_OPACITY_CONTROL, ADJUSTMENT_LUT_SIZE, type AIResultOptions, AS_SHOT_KELVIN, type AdjustmentKind, type AdjustmentKindInfo, type AdjustmentLayer, type AdjustmentLayerBase, type AdjustmentLayerInit, type AdjustmentLayerMask, type AdjustmentLayerNode, type AdjustmentLayerOf, type AdjustmentLayerUpdate, type AdjustmentParamsMap, AffineMatrix, type Annotation, type AnnotationLayer, type AnnotationPlacement, type AnnotationType, type ArrowAnnotation, type AspectRatio, BACKGROUND_LAYER_ID, BACKGROUND_LAYER_NAME, BLUR_FILTER_ID, BRUSH_OPTION_CONTROLS, type BaseAnnotation, type BlackWhiteParams, BlendMode, type BlurFilter, BrushSettings, type Chromaticity, type CircleAnnotation, type ColorBalanceParams, type ColorBalanceTone, type ColorDistance, type ColorRangeOptions, type ColorRangeSample, CompositorOptions, type CompositorSources, type ControlSection, type ControlSpec, type ControlTrack, type ConvertOptions, type CreateAnnotationPayload, type CropBox, type CropHandle, type CurvePoint, type CurvesParams, D50, D65, DEFAULT_ADJUSTMENTS, DEFAULT_DEPTH_MASK, DEFAULT_REFINE_EDGE_PARAMS, DEFAULT_SELECTION_TOOL_OPTIONS, DEFAULT_TRANSFORM, DEVELOP_FILTER_ID, type DepthMaskOptions, type DescValue, type Descriptor, type DeserializeContext, type DevelopFilter, type DevelopSettings, type DropZone, EMPTY_DISTANCE, type EffectControl, EffectPattern, type ExportOptions, FREE_TRANSFORM_CONTENTS, FREE_TRANSFORM_FIELDS, FREE_TRANSFORM_MODES, FREE_TRANSFORM_MODE_OPTIONS, type FillOptions, type FreeTransformBar, type FreeTransformContent, type FreeTransformField, type FreeTransformGeometry, type FreeTransformHost, type FreeTransformInit, type FreeTransformMode, type FreeTransformPreview, type FreeTransformResult, FreeTransformSession, FreeTransformTool, type FreeTransformToolOptions, GUIDED_FILTER_EPS, type GestureModifiers, GlobalLight, type GroupLayer, HISTOGRAM_BINS, HUE_RANGE_LABELS, type HistogramChannel, type HistoryEntryHandle, Homography, type HueRange, type HueSaturationParams, IDENTITY_MATRIX3, IMAGE_ADJUSTMENT_CONTROLS, IMAGE_EDITOR_SCHEMA_VERSION, IMAGE_EDITOR_STATE_VERSION, type ImageAdjustments, type ImageAnnotation, type ImageDimensions, type ImageEditorAIHooks, type ImageEditorAssetStore, ImageEditorController, type ImageEditorDocumentLoad, type ImageEditorFit, type ImageEditorOptions, ImageEditorRenderer, type ImageEditorState, type ImageEditorTool, type ImageEditorToolProviderOptions, type ImageHistogram, type ImageLayer, type ImageLayerType, type ImagePoint, type ImageProcessVersion, type ImageProjection, type ImageTransform, type InpaintHook, type InpaintOptions, Interpolation, type InvertParams, LATEST_PROCESS_VERSION, LAYERED_SCHEMA_VERSION, LAYER_EFFECT_MENU, LEGACY_PROCESS_VERSION, LUMA_709, type LayerBase, type LayerBlendMode, LayerCompositor, LayerEffect, LayerEffectKind, type LayerEffectRow, LayerEffects, type LayerEffectsPanelModel, type LayerFilter, type LayerFilterKind, type LayerLocation, LayerLocks, type LayerMaskProps, type LayerMenuAction, type LayerMenuItem, LayerOperationError, type LayerPanelRow, type LayerPlacement, type LayerProperties, type LayerSourcesHost, type LayerStack, type LayerTarget, type LegacyParts, type LegacySerializedImageEditorState, type LegacyViewResult, type LevelsChannel, type LevelsParams, type LineAnnotation, MAX_KELVIN, MIN_KELVIN, MIRED_PER_TEMPERATURE_UNIT, MIXER_MIXING_OPTIONS, MIXER_OPTION_CONTROLS, type MagicWandOptions, type Matrix3, MixerLoad, MixerSettings, MixerStroke, type MixerStrokeInit, MixerTarget, type MosaicImageDataLike, type MosaicRegion, PAINT_TOOLS, PATTERN_BLOCK_KEYS, PSD_BLEND_KEYS, PSD_FILE_ACCEPT, PaintGesture, type PaintOptions, type PaintPointerSample, type PaintStrokeResult, PaintStrokeSession, type PaintTool, type ParsedAdjustment, type ParsedLayerEffects, type PenAnnotation, type PhotoFilterParams, type PixelBuffer, type PixelLayer, type PixelLayerInit, type PixelOp, PixelSurface, type PlaneLayout, type PosterizeParams, type PsdChannel, PsdError, type PsdExportInput, type PsdExportResult, type PsdFile, type PsdHeader, type PsdImportOptions, type PsdImportResult, type PsdLayerMask, type PsdLayerRecord, type PsdLayerSummary, type PsdPattern, type PsdRect, type PsdResource, type PsdSmartFilter, type PsdTaggedBlock, type PsdTreeNode, Quad, type QuickMaskStyle, REFINE_EDGE_CONTROLS, type RasterMask, RasterRect, type RectAnnotation, type ReferenceItem, type RefineEdgeControl, type RefineEdgeParams, type RemoveBackgroundHook, type RemoveBackgroundOptions, type RenderOptions, type RouteInput, SELECTION_MODES, SELECTION_MODE_LABELS, SELECTION_MODIFY_OPS, SELECTION_TOOLS, SMART_RENDER_MARGIN, SUPPORTED_ADJUSTMENT_KEYS, type SampleOptions, type SelectionChannel, type SelectionCommandOptions, SelectionGesture, type SelectionMask, type SelectionMode, type SelectionModifyOp, type SelectionToolKind, type SelectionToolOptions, type SerializeContext, type SerializedAdjustmentLayer, type SerializedAnnotationLayer, type SerializedGroupLayer, type SerializedImageEditorState, type SerializedLayer, type SerializedLayerEffects, type SerializedLayeredImageEditorState, type SerializedPattern, type SerializedPixelLayer, type SerializedRasterMask, type SerializedSelection, type SerializedSmartContents, type SerializedSmartFilter, type SerializedSmartObjectLayer, type ShapeSelectionOptions, type ShortcutEvent, type SmartCanvas, type SmartContents, type SmartDocument, type SmartFilter, type SmartFilterKind, type SmartFilterRow, type SmartFilterStack, type SmartObjectInfo, type SmartObjectLayer, type SmartPlacement, type SmartPsdData, type SmartRenderOptions, StrokeApply, StrokeCoverage, type StrokeInit, StrokePoint, type StrokeTool, TINT_SCALE, TONE_LUT_SIZE, TONE_RANGE_PRESETS, TRANSFORM_ANCHORS, type TextAnnotation, type ThresholdParams, TiledSurface, type ToneRangePreset, type TransformAnchor, type TransformHandle, type TransformModifiers, type TransformOverlay, type TransformParams, type TransformReadout, type UnitLevels, VIBRANCE_GREY, Vec2, type VibranceParams, type ViewportMetrics, WARP_GRID_OPTIONS, WARP_STYLE_OPTIONS, type WarpBar, WarpMesh, WarpPreset, WarpStyle, XYZ_D50_TO_SRGB, activeAdjustmentLayers, activeSmartFilters, addLayerEffect, addLayerFilter, addSmartFilter, addToHistogram, adjustmentKindLabel, adjustmentLayersKey, adjustmentNodeAsLayer, adjustmentNodeFromLegacy, anchorPoint, annotationLayerFor, annotationLayerName, applyAdjustmentLayers, applyAdjustments, applyBoxBlur, applyDepthMask, applyImageProjectionToContext, applyLegacyAdjustments, applyMatrix3, applyOutputStage, applyParams, applyProcess2Adjustments, applyRegionBlur, applyRegionMosaic, applySmartFilters, backgroundLayer, baseProjection, blackWhiteGray, blurFilter, borderCoverage, boxMean, boxPointOf, boxToCurvePoint, bradfordAdaptation, buildLayerMaskPlanes, buildToneLut, calculateCropDrag, canvasToImagePoint, clampControlValue, clampCropToImage, colorBalanceChannel, colorRange, combineSelections, compileAdjustmentLayer, computeHistogram, computeSelectionBounds, contentsBox, contentsSurface, contractCoverage, controlPosition, controlTrackBackground, convertToSmartObject, copySmartObject, cornersFromMatrix, coverageToByte, coveringRect, createAdjustmentLayer, createImageCaptureSurface, createImageEditTools, createImageEditorToolProvider, createImageEffectTools, createImageLayerTools, createImagePaintTools, createImagePsdTools, createImageSelectionTools, createImageSmartObjectTools, createImageTransformTools, createSelectionMask, curveLutFromLevels, curvePointToBox, curveSvgPath, decodeLayerChannel, decodeLayerMask, decodeMergedImage, decodePlanes, decodePngDataUrl, decodeSelectionRle, defaultAdjustmentParams, depthMaskAlpha, depthRasterMask, describeLayer, describeLayerEffects, describeSelection, describeTransform, deserializeEffects, deserializeLayer, deserializeLayers, deserializePatterns, deserializeSelection, developFilter, developFromAdjustments, developTarget, distanceTransform, documentContents, downloadPsd, dropPlacement, dropZone, duplicateLayer, edgeWidth, effectControlChange, ellipsePoints, ellipseSelection, emptyHistogram, encodeRle, encodeSelectionRle, encodeSurface, evaluateAdjustmentLayers, expandCoverage, exportPsd, featherCoverage, filterMaskCoverage, findAdjustmentControl, findLayerControl, flipCorners, formatControlValue, fullSelection, geometryHomography, getAnnotationBounds, getControlPath, getCropCursor, getRotatedSize, getViewportMetrics, getViewportProjection, globalImageCache, greyMorphology, groupLayers, guidePlanes, guidedFilterColor, handlePaintShortcut, hasResampledLegacyMask, hasSurface, hasWarp, hashMaskContent, hexToRgb, histogramPath, hitTestAnnotation, hitTestCrop, hitTestCurvePoint, hslToRgb, hueRange, hueRangeTables, hueRangeWeight, hueSaturation, identityCurve, identityLevels, identityTransform, imageEditorStateMigrations, imageToCanvasPoint, importPsd, insertCurvePoint, instancesOf, invertMatrix3, invertSelection, isActiveFilter, isAdjustmentKind, isContentsDecoded, isDefaultDepthMask, isIdentityTransform, isLegacyShape, isPaintTool, isQuarterTurn, isQuarterTurnSwapped, isSelectionEmpty, isSelectionMode, isSpatialFilter, isTransformAnchor, isValidWarp, kelvinToTemperature, layerBadge, layerEffectControls, layerEffectsBadge, layerEffectsOf, layerEffectsPanel, layerLabel, layerMaskCoverage, layerMaskFromSelection, layerMaskKey, layerMenu, layerName, layerPanelRows, layerTree, layerTypeLabel, layersFromLegacy, legacyAdjustmentLayer, legacyMaskOf, legacyView, levelsValue, linearSrgbToXy, linearToSrgb, loadImageEditorDocument, magicWand, mapCropHandle, maskSummary, matrixFromCorners, matrixFromParams, migrateSerializedImageEditorState, migrateToLayeredState, mixerLoadResult, modifySelection, moveCurvePoint, moveLayer, moveSmartFilter, mulMatrix3, needsLegacyBase, neutralHueRange, newContentsId, newLayerId, normalizeAdjustmentLayer, normalizeAdjustmentLayers, normalizeAngle, normalizeFilter, normalizeLayerMask, normalizePlacement, normalizeProcessVersion, normalizeRect, normalizeRefineEdgeParams, normalizeSmartFilter, normalizeStoredAdjustments, offsetLayer, offsetSmartObject, openPsdFile, parseAdjustmentBlock, parseBlend, parseColor, parseLfx2, parseLrfx, parsePatternBlock, parseSelectionMode, parseVersionedDescriptor, photoFilterMatrix, pixelLayerBounds, pixelLayers, placeContents, placeLayer, placementAt, placementBounds, placementGeometry, pointerPressure, polygonCoverage, polygonSelection, posterizeValue, presetWarp, previewStep, projectImagePoint, projectImageRect, projectMaskCoverage, projectQuarterTurn, psdBytesFromBase64, psdFileName, psdPatternToEffectPattern, psdToLayers, quickMaskPixels, rangeLightness, rasterContents, rasterMaskFromLegacy, rasterizeSmartObject, readAdjustmentControls, readPsd, rectSelection, referencePoint, refineCoverage, refineEdgeHalo, refineSelection, removeAlpha, removeCurvePoint, removeLayer, removeLayerEffect, removeLayerFilter, removeSmartFilter, renderLayeredBase, renderSmartObject, replaceContents, requireLayer, requireSmartObject, requireUnlocked, rerender, resizePixels, resizeSelection, resolveExternalAssets, resolveMosaicRegionBounds, rgbToGray, rgbToHsl, rgbUnitToHex, runLayerFilters, runLayerMenuAction, sampleLut, sampleToneLut, selectionArea, selectionFromCoverage, selectionFromPixels, selectionModeFromModifiers, selectionOutline, selectionToCoverage, selectionToPixels, selectionValueAt, serializeContents, serializeEffects, serializeLayer, serializeLayers, serializeLayersExternal, serializePatterns, serializeSelection, setControlPath, setLayerEffects, setLayerEffectsEnabled, setLayerMask, setLayerProperties, setSmartFilterMask, setSmartFiltersEnabled, setSmartPlacement, shiftCoverage, smartFilterRows, smartObjectLayers, smoothCoverage, splitOverlayAnnotations, srgb8ToLab, srgbToLinear, sumHistograms, tempTintToXy, temperatureToKelvin, toHex, toneCurve, toneLuts, toneRange, transformHomography, transformMap, transformedBox, transformedPoint, ungroupLayer, unionRect, unprojectCanvasPoint, updateLayerEffect, updateLayerFilter, updateLayerMaskProps, updateSmartFilter, uvToXy, versionedDescriptorBytes, vibranceLinear, vibrancePixel, wbMatrix, whiteBalanceFromSample, whiteBalanceMatrix, withFilterMaskSurface, withNewIds, writeAdjustmentBlock, writeLfx2, writePatternBlock, writePsd, xyToTempTint, xyToUv };