@imagemagick/magick-wasm 0.0.32 → 0.0.34

package/dist/index.d.ts

@@ -17,280 +17,282 @@ export declare class ConfigurationFiles implements IConfigurationFiles {
 	readonly log: IConfigurationFile;
 	readonly policy: IConfigurationFile;
 }
-export declare enum MagickFormat {
-	Unknown = "UNKNOWN",
-	ThreeFr = "3FR",
-	ThreeG2 = "3G2",
-	ThreeGp = "3GP",
-	A = "A",
-	Aai = "AAI",
-	Ai = "AI",
-	APng = "APNG",
-	Art = "ART",
-	Arw = "ARW",
-	Ashlar = "ASHLAR",
-	Avi = "AVI",
-	Avif = "AVIF",
-	Avs = "AVS",
-	B = "B",
-	Bayer = "BAYER",
-	Bayera = "BAYERA",
-	Bgr = "BGR",
-	Bgra = "BGRA",
-	Bgro = "BGRO",
-	Bmp = "BMP",
-	Bmp2 = "BMP2",
-	Bmp3 = "BMP3",
-	Brf = "BRF",
-	C = "C",
-	Cal = "CAL",
-	Cals = "CALS",
-	Canvas = "CANVAS",
-	Caption = "CAPTION",
-	Cin = "CIN",
-	Cip = "CIP",
-	Clip = "CLIP",
-	Cmyk = "CMYK",
-	Cmyka = "CMYKA",
-	Cr2 = "CR2",
-	Cr3 = "CR3",
-	Crw = "CRW",
-	Cube = "CUBE",
-	Cur = "CUR",
-	Cut = "CUT",
-	Data = "DATA",
-	Dcm = "DCM",
-	Dcr = "DCR",
-	Dcraw = "DCRAW",
-	Dcx = "DCX",
-	Dds = "DDS",
-	Dfont = "DFONT",
-	Dng = "DNG",
-	Dpx = "DPX",
-	Dxt1 = "DXT1",
-	Dxt5 = "DXT5",
-	Epdf = "EPDF",
-	Epi = "EPI",
-	Eps = "EPS",
-	Eps2 = "EPS2",
-	Eps3 = "EPS3",
-	Epsf = "EPSF",
-	Epsi = "EPSI",
-	Ept = "EPT",
-	Ept2 = "EPT2",
-	Ept3 = "EPT3",
-	Erf = "ERF",
-	Exr = "EXR",
-	Farbfeld = "FARBFELD",
-	Fax = "FAX",
-	Ff = "FF",
-	Fff = "FFF",
-	File = "FILE",
-	Fits = "FITS",
-	Fl32 = "FL32",
-	Flv = "FLV",
-	Fractal = "FRACTAL",
-	Ftp = "FTP",
-	Fts = "FTS",
-	Ftxt = "FTXT",
-	G = "G",
-	G3 = "G3",
-	G4 = "G4",
-	Gif = "GIF",
-	Gif87 = "GIF87",
-	Gradient = "GRADIENT",
-	Gray = "GRAY",
-	Graya = "GRAYA",
-	Group4 = "GROUP4",
-	Hald = "HALD",
-	Hdr = "HDR",
-	Heic = "HEIC",
-	Heif = "HEIF",
-	Histogram = "HISTOGRAM",
-	Hrz = "HRZ",
-	Htm = "HTM",
-	Html = "HTML",
-	Http = "HTTP",
-	Https = "HTTPS",
-	Icb = "ICB",
-	Ico = "ICO",
-	Icon = "ICON",
-	Iiq = "IIQ",
-	Info = "INFO",
-	Inline = "INLINE",
-	Ipl = "IPL",
-	Isobrl = "ISOBRL",
-	Isobrl6 = "ISOBRL6",
-	J2c = "J2C",
-	J2k = "J2K",
-	Jng = "JNG",
-	Jnx = "JNX",
-	Jp2 = "JP2",
-	Jpc = "JPC",
-	Jpe = "JPE",
-	Jpeg = "JPEG",
-	Jpg = "JPG",
-	Jpm = "JPM",
-	Jps = "JPS",
-	Jpt = "JPT",
-	Json = "JSON",
-	Jxl = "JXL",
-	K = "K",
-	K25 = "K25",
-	Kdc = "KDC",
-	Label = "LABEL",
-	M = "M",
-	M2v = "M2V",
-	M4v = "M4V",
-	Mac = "MAC",
-	Map = "MAP",
-	Mask = "MASK",
-	Mat = "MAT",
-	Matte = "MATTE",
-	Mdc = "MDC",
-	Mef = "MEF",
-	Miff = "MIFF",
-	Mkv = "MKV",
-	Mng = "MNG",
-	Mono = "MONO",
-	Mov = "MOV",
-	Mos = "MOS",
-	Mp4 = "MP4",
-	Mpc = "MPC",
-	Mpeg = "MPEG",
-	Mpg = "MPG",
-	Mpo = "MPO",
-	Mrw = "MRW",
-	Msl = "MSL",
-	Msvg = "MSVG",
-	Mtv = "MTV",
-	Mvg = "MVG",
-	Nef = "NEF",
-	Nrw = "NRW",
-	Null = "NULL",
-	O = "O",
-	Ora = "ORA",
-	Orf = "ORF",
-	Otb = "OTB",
-	Otf = "OTF",
-	Pal = "PAL",
-	Palm = "PALM",
-	Pam = "PAM",
-	Pango = "PANGO",
-	Pattern = "PATTERN",
-	Pbm = "PBM",
-	Pcd = "PCD",
-	Pcds = "PCDS",
-	Pcl = "PCL",
-	Pct = "PCT",
-	Pcx = "PCX",
-	Pdb = "PDB",
-	Pdf = "PDF",
-	Pdfa = "PDFA",
-	Pef = "PEF",
-	Pes = "PES",
-	Pfa = "PFA",
-	Pfb = "PFB",
-	Pfm = "PFM",
-	Pgm = "PGM",
-	Pgx = "PGX",
-	Phm = "PHM",
-	Picon = "PICON",
-	Pict = "PICT",
-	Pix = "PIX",
-	Pjpeg = "PJPEG",
-	Plasma = "PLASMA",
-	Png = "PNG",
-	Png00 = "PNG00",
-	Png24 = "PNG24",
-	Png32 = "PNG32",
-	Png48 = "PNG48",
-	Png64 = "PNG64",
-	Png8 = "PNG8",
-	Pnm = "PNM",
-	Pocketmod = "POCKETMOD",
-	Ppm = "PPM",
-	Ps = "PS",
-	Ps2 = "PS2",
-	Ps3 = "PS3",
-	Psb = "PSB",
-	Psd = "PSD",
-	Ptif = "PTIF",
-	Pwp = "PWP",
-	Qoi = "QOI",
-	R = "R",
-	RadialGradient = "RADIAL-GRADIENT",
-	Raf = "RAF",
-	Ras = "RAS",
-	Raw = "RAW",
-	Rgb = "RGB",
-	Rgb565 = "RGB565",
-	Rgba = "RGBA",
-	Rgbo = "RGBO",
-	Rgf = "RGF",
-	Rla = "RLA",
-	Rle = "RLE",
-	Rmf = "RMF",
-	Rw2 = "RW2",
-	Rwl = "RWL",
-	Scr = "SCR",
-	Screenshot = "SCREENSHOT",
-	Sct = "SCT",
-	Sfw = "SFW",
-	Sgi = "SGI",
-	Shtml = "SHTML",
-	Six = "SIX",
-	Sixel = "SIXEL",
-	SparseColor = "SPARSE-COLOR",
-	Sr2 = "SR2",
-	Srf = "SRF",
-	Srw = "SRW",
-	Stegano = "STEGANO",
-	Sti = "STI",
-	StrImg = "STRIMG",
-	Sun = "SUN",
-	Svg = "SVG",
-	Svgz = "SVGZ",
-	Text = "TEXT",
-	Tga = "TGA",
-	Thumbnail = "THUMBNAIL",
-	Tif = "TIF",
-	Tiff = "TIFF",
-	Tiff64 = "TIFF64",
-	Tile = "TILE",
-	Tim = "TIM",
-	Tm2 = "TM2",
-	Ttc = "TTC",
-	Ttf = "TTF",
-	Txt = "TXT",
-	Ubrl = "UBRL",
-	Ubrl6 = "UBRL6",
-	Uil = "UIL",
-	Uyvy = "UYVY",
-	Vda = "VDA",
-	Vicar = "VICAR",
-	Vid = "VID",
-	Viff = "VIFF",
-	Vips = "VIPS",
-	Vst = "VST",
-	WebM = "WEBM",
-	WebP = "WEBP",
-	Wbmp = "WBMP",
-	Wmv = "WMV",
-	Wpg = "WPG",
-	X3f = "X3F",
-	Xbm = "XBM",
-	Xc = "XC",
-	Xcf = "XCF",
-	Xpm = "XPM",
-	Xps = "XPS",
-	Xv = "XV",
-	Y = "Y",
-	Yaml = "YAML",
-	Ycbcr = "YCBCR",
-	Ycbcra = "YCBCRA",
-	Yuv = "YUV"
-}
+export declare const MagickFormat: {
+	readonly Unknown: "UNKNOWN";
+	readonly ThreeFr: "3FR";
+	readonly ThreeG2: "3G2";
+	readonly ThreeGp: "3GP";
+	readonly A: "A";
+	readonly Aai: "AAI";
+	readonly Ai: "AI";
+	readonly APng: "APNG";
+	readonly Art: "ART";
+	readonly Arw: "ARW";
+	readonly Ashlar: "ASHLAR";
+	readonly Avci: "AVCI";
+	readonly Avi: "AVI";
+	readonly Avif: "AVIF";
+	readonly Avs: "AVS";
+	readonly B: "B";
+	readonly Bayer: "BAYER";
+	readonly Bayera: "BAYERA";
+	readonly Bgr: "BGR";
+	readonly Bgra: "BGRA";
+	readonly Bgro: "BGRO";
+	readonly Bmp: "BMP";
+	readonly Bmp2: "BMP2";
+	readonly Bmp3: "BMP3";
+	readonly Brf: "BRF";
+	readonly C: "C";
+	readonly Cal: "CAL";
+	readonly Cals: "CALS";
+	readonly Canvas: "CANVAS";
+	readonly Caption: "CAPTION";
+	readonly Cin: "CIN";
+	readonly Cip: "CIP";
+	readonly Clip: "CLIP";
+	readonly Cmyk: "CMYK";
+	readonly Cmyka: "CMYKA";
+	readonly Cr2: "CR2";
+	readonly Cr3: "CR3";
+	readonly Crw: "CRW";
+	readonly Cube: "CUBE";
+	readonly Cur: "CUR";
+	readonly Cut: "CUT";
+	readonly Data: "DATA";
+	readonly Dcm: "DCM";
+	readonly Dcr: "DCR";
+	readonly Dcraw: "DCRAW";
+	readonly Dcx: "DCX";
+	readonly Dds: "DDS";
+	readonly Dfont: "DFONT";
+	readonly Dng: "DNG";
+	readonly Dpx: "DPX";
+	readonly Dxt1: "DXT1";
+	readonly Dxt5: "DXT5";
+	readonly Epdf: "EPDF";
+	readonly Epi: "EPI";
+	readonly Eps: "EPS";
+	readonly Eps2: "EPS2";
+	readonly Eps3: "EPS3";
+	readonly Epsf: "EPSF";
+	readonly Epsi: "EPSI";
+	readonly Ept: "EPT";
+	readonly Ept2: "EPT2";
+	readonly Ept3: "EPT3";
+	readonly Erf: "ERF";
+	readonly Exr: "EXR";
+	readonly Farbfeld: "FARBFELD";
+	readonly Fax: "FAX";
+	readonly Ff: "FF";
+	readonly Fff: "FFF";
+	readonly File: "FILE";
+	readonly Fits: "FITS";
+	readonly Fl32: "FL32";
+	readonly Flv: "FLV";
+	readonly Fractal: "FRACTAL";
+	readonly Ftp: "FTP";
+	readonly Fts: "FTS";
+	readonly Ftxt: "FTXT";
+	readonly G: "G";
+	readonly G3: "G3";
+	readonly G4: "G4";
+	readonly Gif: "GIF";
+	readonly Gif87: "GIF87";
+	readonly Gradient: "GRADIENT";
+	readonly Gray: "GRAY";
+	readonly Graya: "GRAYA";
+	readonly Group4: "GROUP4";
+	readonly Hald: "HALD";
+	readonly Hdr: "HDR";
+	readonly Heic: "HEIC";
+	readonly Heif: "HEIF";
+	readonly Histogram: "HISTOGRAM";
+	readonly Hrz: "HRZ";
+	readonly Htm: "HTM";
+	readonly Html: "HTML";
+	readonly Http: "HTTP";
+	readonly Https: "HTTPS";
+	readonly Icb: "ICB";
+	readonly Ico: "ICO";
+	readonly Icon: "ICON";
+	readonly Iiq: "IIQ";
+	readonly Info: "INFO";
+	readonly Inline: "INLINE";
+	readonly Ipl: "IPL";
+	readonly Isobrl: "ISOBRL";
+	readonly Isobrl6: "ISOBRL6";
+	readonly J2c: "J2C";
+	readonly J2k: "J2K";
+	readonly Jng: "JNG";
+	readonly Jnx: "JNX";
+	readonly Jp2: "JP2";
+	readonly Jpc: "JPC";
+	readonly Jpe: "JPE";
+	readonly Jpeg: "JPEG";
+	readonly Jpg: "JPG";
+	readonly Jpm: "JPM";
+	readonly Jps: "JPS";
+	readonly Jpt: "JPT";
+	readonly Json: "JSON";
+	readonly Jxl: "JXL";
+	readonly K: "K";
+	readonly K25: "K25";
+	readonly Kdc: "KDC";
+	readonly Label: "LABEL";
+	readonly M: "M";
+	readonly M2v: "M2V";
+	readonly M4v: "M4V";
+	readonly Mac: "MAC";
+	readonly Map: "MAP";
+	readonly Mask: "MASK";
+	readonly Mat: "MAT";
+	readonly Matte: "MATTE";
+	readonly Mdc: "MDC";
+	readonly Mef: "MEF";
+	readonly Miff: "MIFF";
+	readonly Mkv: "MKV";
+	readonly Mng: "MNG";
+	readonly Mono: "MONO";
+	readonly Mov: "MOV";
+	readonly Mos: "MOS";
+	readonly Mp4: "MP4";
+	readonly Mpc: "MPC";
+	readonly Mpeg: "MPEG";
+	readonly Mpg: "MPG";
+	readonly Mpo: "MPO";
+	readonly Mrw: "MRW";
+	readonly Msl: "MSL";
+	readonly Msvg: "MSVG";
+	readonly Mtv: "MTV";
+	readonly Mvg: "MVG";
+	readonly Nef: "NEF";
+	readonly Nrw: "NRW";
+	readonly Null: "NULL";
+	readonly O: "O";
+	readonly Ora: "ORA";
+	readonly Orf: "ORF";
+	readonly Otb: "OTB";
+	readonly Otf: "OTF";
+	readonly Pal: "PAL";
+	readonly Palm: "PALM";
+	readonly Pam: "PAM";
+	readonly Pango: "PANGO";
+	readonly Pattern: "PATTERN";
+	readonly Pbm: "PBM";
+	readonly Pcd: "PCD";
+	readonly Pcds: "PCDS";
+	readonly Pcl: "PCL";
+	readonly Pct: "PCT";
+	readonly Pcx: "PCX";
+	readonly Pdb: "PDB";
+	readonly Pdf: "PDF";
+	readonly Pdfa: "PDFA";
+	readonly Pef: "PEF";
+	readonly Pes: "PES";
+	readonly Pfa: "PFA";
+	readonly Pfb: "PFB";
+	readonly Pfm: "PFM";
+	readonly Pgm: "PGM";
+	readonly Pgx: "PGX";
+	readonly Phm: "PHM";
+	readonly Picon: "PICON";
+	readonly Pict: "PICT";
+	readonly Pix: "PIX";
+	readonly Pjpeg: "PJPEG";
+	readonly Plasma: "PLASMA";
+	readonly Png: "PNG";
+	readonly Png00: "PNG00";
+	readonly Png24: "PNG24";
+	readonly Png32: "PNG32";
+	readonly Png48: "PNG48";
+	readonly Png64: "PNG64";
+	readonly Png8: "PNG8";
+	readonly Pnm: "PNM";
+	readonly Pocketmod: "POCKETMOD";
+	readonly Ppm: "PPM";
+	readonly Ps: "PS";
+	readonly Ps2: "PS2";
+	readonly Ps3: "PS3";
+	readonly Psb: "PSB";
+	readonly Psd: "PSD";
+	readonly Ptif: "PTIF";
+	readonly Pwp: "PWP";
+	readonly Qoi: "QOI";
+	readonly R: "R";
+	readonly RadialGradient: "RADIAL-GRADIENT";
+	readonly Raf: "RAF";
+	readonly Ras: "RAS";
+	readonly Raw: "RAW";
+	readonly Rgb: "RGB";
+	readonly Rgb565: "RGB565";
+	readonly Rgba: "RGBA";
+	readonly Rgbo: "RGBO";
+	readonly Rgf: "RGF";
+	readonly Rla: "RLA";
+	readonly Rle: "RLE";
+	readonly Rmf: "RMF";
+	readonly Rw2: "RW2";
+	readonly Rwl: "RWL";
+	readonly Scr: "SCR";
+	readonly Screenshot: "SCREENSHOT";
+	readonly Sct: "SCT";
+	readonly Sfw: "SFW";
+	readonly Sgi: "SGI";
+	readonly Shtml: "SHTML";
+	readonly Six: "SIX";
+	readonly Sixel: "SIXEL";
+	readonly SparseColor: "SPARSE-COLOR";
+	readonly Sr2: "SR2";
+	readonly Srf: "SRF";
+	readonly Srw: "SRW";
+	readonly Stegano: "STEGANO";
+	readonly Sti: "STI";
+	readonly StrImg: "STRIMG";
+	readonly Sun: "SUN";
+	readonly Svg: "SVG";
+	readonly Svgz: "SVGZ";
+	readonly Text: "TEXT";
+	readonly Tga: "TGA";
+	readonly Thumbnail: "THUMBNAIL";
+	readonly Tif: "TIF";
+	readonly Tiff: "TIFF";
+	readonly Tiff64: "TIFF64";
+	readonly Tile: "TILE";
+	readonly Tim: "TIM";
+	readonly Tm2: "TM2";
+	readonly Ttc: "TTC";
+	readonly Ttf: "TTF";
+	readonly Txt: "TXT";
+	readonly Ubrl: "UBRL";
+	readonly Ubrl6: "UBRL6";
+	readonly Uil: "UIL";
+	readonly Uyvy: "UYVY";
+	readonly Vda: "VDA";
+	readonly Vicar: "VICAR";
+	readonly Vid: "VID";
+	readonly Viff: "VIFF";
+	readonly Vips: "VIPS";
+	readonly Vst: "VST";
+	readonly WebM: "WEBM";
+	readonly WebP: "WEBP";
+	readonly Wbmp: "WBMP";
+	readonly Wmv: "WMV";
+	readonly Wpg: "WPG";
+	readonly X3f: "X3F";
+	readonly Xbm: "XBM";
+	readonly Xc: "XC";
+	readonly Xcf: "XCF";
+	readonly Xpm: "XPM";
+	readonly Xps: "XPS";
+	readonly Xv: "XV";
+	readonly Y: "Y";
+	readonly Yaml: "YAML";
+	readonly Ycbcr: "YCBCR";
+	readonly Ycbcra: "YCBCRA";
+	readonly Yuv: "YUV";
+};
+export type MagickFormat = typeof MagickFormat[keyof typeof MagickFormat];
 export interface IDefine {
 	readonly format: MagickFormat;
 	readonly name: string;
@@ -317,19 +319,20 @@ export declare abstract class DefinesCreator implements IDefines {
 export interface IDisposable {
 	dispose(): void;
 }
-export declare enum Gravity {
-	Undefined = 0,
-	Forget = 0,
-	Northwest = 1,
-	North = 2,
-	Northeast = 3,
-	West = 4,
-	Center = 5,
-	East = 6,
-	Southwest = 7,
-	South = 8,
-	Southeast = 9
-}
+export declare const Gravity: {
+	readonly Undefined: 0;
+	readonly Forget: 0;
+	readonly Northwest: 1;
+	readonly North: 2;
+	readonly Northeast: 3;
+	readonly West: 4;
+	readonly Center: 5;
+	readonly East: 6;
+	readonly Southwest: 7;
+	readonly South: 8;
+	readonly Southeast: 9;
+};
+export type Gravity = typeof Gravity[keyof typeof Gravity];
 export interface IMagickColor {
 	r: number;
 	g: number;
@@ -363,27 +366,30 @@ export declare abstract class NativeInstance {
 	dispose(): void;
 	private disposeInstance;
 }
-export declare enum PaintMethod {
-	Undefined = 0,
-	Point = 1,
-	Replace = 2,
-	Floodfill = 3,
-	FillToBorder = 4,
-	Reset = 5
-}
-export declare enum TextAlignment {
-	Undefined = 0,
-	Left = 1,
-	Center = 2,
-	Right = 3
-}
-export declare enum TextDecoration {
-	Undefined = 0,
-	None = 1,
-	Underline = 2,
-	Overline = 3,
-	LineThrough = 4
-}
+export declare const PaintMethod: {
+	readonly Undefined: 0;
+	readonly Point: 1;
+	readonly Replace: 2;
+	readonly Floodfill: 3;
+	readonly FillToBorder: 4;
+	readonly Reset: 5;
+};
+export type PaintMethod = typeof PaintMethod[keyof typeof PaintMethod];
+export declare const TextAlignment: {
+	readonly Undefined: 0;
+	readonly Left: 1;
+	readonly Center: 2;
+	readonly Right: 3;
+};
+export type TextAlignment = typeof TextAlignment[keyof typeof TextAlignment];
+export declare const TextDecoration: {
+	readonly Undefined: 0;
+	readonly None: 1;
+	readonly Underline: 2;
+	readonly Overline: 3;
+	readonly LineThrough: 4;
+};
+export type TextDecoration = typeof TextDecoration[keyof typeof TextDecoration];
 export interface IDrawingWand extends IDisposable {
 	color(x: number, y: number, paintMethod: number): void;
 	draw(drawables: IDrawable[]): void;
@@ -451,6 +457,7 @@ export declare class Percentage {
 	constructor(value: number);
 	multiply(value: number): number;
 	toDouble(): number;
+	toString(): string;
 }
 export declare class DrawableFillOpacity implements IDrawable {
 	private readonly _opacity;
@@ -558,160 +565,166 @@ export declare class DrawableText implements IDrawable {
 	constructor(x: number, y: number, value: string);
 	draw(wand: IDrawingWand): void;
 }
-declare enum AlphaOption$1 {
-	Undefined = 0,
-	Activate = 1,
-	Associate = 2,
-	Background = 3,
-	Copy = 4,
-	Deactivate = 5,
-	Discrete = 6,
-	Disassociate = 7,
-	Extract = 8,
-	Off = 9,
-	On = 10,
-	Opaque = 11,
-	Remove = 12,
-	Set = 13,
-	Shape = 14,
-	Transparent = 15,
-	OffIfOpaque = 16
-}
-export declare enum Channels {
-	Undefined = 0,
-	Red = 1,
-	Gray = 1,
-	Cyan = 1,
-	Green = 2,
-	Magenta = 2,
-	Blue = 4,
-	Yellow = 4,
-	Black = 8,
-	Alpha = 16,
-	Opacity = 16,
-	Index = 32,
-	Composite = 31,
-	TrueAlpha = 256,
-	RGB = 7,
-	CMYK = 15,
-	CMYKA = 31,
-	Meta0 = 1024,
-	Meta1 = 2048,
-	Meta2 = 4096,
-	Meta3 = 8192,
-	Meta4 = 16384,
-	Meta5 = 32768,
-	Meta6 = 65536,
-	Meta7 = 131072,
-	Meta8 = 262144,
-	Meta9 = 524288,
-	Meta10 = 1048576,
-	Meta11 = 2097152,
-	Meta12 = 4194304,
-	Meta13 = 8388608,
-	Meta14 = 16777216,
-	Meta15 = 33554432,
-	Meta16 = 67108864,
-	Meta17 = 134217728,
-	Meta18 = 268435456,
-	Meta19 = 536870912,
-	Meta20 = 1073741824,
-	Meta21 = -2147483648,
-	All = 134217727
-}
-export declare enum ColorSpace {
-	Undefined = 0,
-	CMY = 1,
-	CMYK = 2,
-	Gray = 3,
-	HCL = 4,
-	HCLp = 5,
-	HSB = 6,
-	HSI = 7,
-	HSL = 8,
-	HSV = 9,
-	HWB = 10,
-	Lab = 11,
-	LCH = 12,
-	LCHab = 13,
-	LCHuv = 14,
-	Log = 15,
-	LMS = 16,
-	Luv = 17,
-	OHTA = 18,
-	Rec601YCbCr = 19,
-	Rec709YCbCr = 20,
-	RGB = 21,
-	scRGB = 22,
-	sRGB = 23,
-	Transparent = 24,
-	XyY = 25,
-	XYZ = 26,
-	YCbCr = 27,
-	YCC = 28,
-	YDbDr = 29,
-	YIQ = 30,
-	YPbPr = 31,
-	YUV = 32,
-	LinearGray = 33,
-	Jzazbz = 34,
-	DisplayP3 = 35,
-	Adobe98 = 36,
-	ProPhoto = 37,
-	Oklab = 38,
-	Oklch = 39
-}
-export declare enum ComplexOperator {
-	Undefined = 0,
-	Add = 1,
-	Conjugate = 2,
-	Divide = 3,
-	MagnitudePhase = 4,
-	Multiply = 5,
-	RealImaginary = 6,
-	Subtract = 7
-}
+export declare const AlphaAction: {
+	readonly Undefined: 0;
+	readonly Activate: 1;
+	readonly Associate: 2;
+	readonly Background: 3;
+	readonly Copy: 4;
+	readonly Deactivate: 5;
+	readonly Discrete: 6;
+	readonly Disassociate: 7;
+	readonly Extract: 8;
+	readonly Off: 9;
+	readonly On: 10;
+	readonly Opaque: 11;
+	readonly Remove: 12;
+	readonly Set: 13;
+	readonly Shape: 14;
+	readonly Transparent: 15;
+	readonly OffIfOpaque: 16;
+};
+export type AlphaAction = typeof AlphaAction[keyof typeof AlphaAction];
+export declare const Channels: {
+	readonly Undefined: 0;
+	readonly Red: 1;
+	readonly Gray: 1;
+	readonly Cyan: 1;
+	readonly Green: 2;
+	readonly Magenta: 2;
+	readonly Blue: 4;
+	readonly Yellow: 4;
+	readonly Black: 8;
+	readonly Alpha: 16;
+	readonly Opacity: 16;
+	readonly Index: 32;
+	readonly Composite: 31;
+	readonly TrueAlpha: 256;
+	readonly RGB: number;
+	readonly CMYK: number;
+	readonly CMYKA: number;
+	readonly Meta0: number;
+	readonly Meta1: number;
+	readonly Meta2: number;
+	readonly Meta3: number;
+	readonly Meta4: number;
+	readonly Meta5: number;
+	readonly Meta6: number;
+	readonly Meta7: number;
+	readonly Meta8: number;
+	readonly Meta9: number;
+	readonly Meta10: number;
+	readonly Meta11: number;
+	readonly Meta12: number;
+	readonly Meta13: number;
+	readonly Meta14: number;
+	readonly Meta15: number;
+	readonly Meta16: number;
+	readonly Meta17: number;
+	readonly Meta18: number;
+	readonly Meta19: number;
+	readonly Meta20: number;
+	readonly Meta21: number;
+	readonly All: 134217727;
+};
+export type Channels = typeof Channels[keyof typeof Channels];
+export declare const ColorSpace: {
+	readonly Undefined: 0;
+	readonly CMY: 1;
+	readonly CMYK: 2;
+	readonly Gray: 3;
+	readonly HCL: 4;
+	readonly HCLp: 5;
+	readonly HSB: 6;
+	readonly HSI: 7;
+	readonly HSL: 8;
+	readonly HSV: 9;
+	readonly HWB: 10;
+	readonly Lab: 11;
+	readonly LCH: 12;
+	readonly LCHab: 13;
+	readonly LCHuv: 14;
+	readonly Log: 15;
+	readonly LMS: 16;
+	readonly Luv: 17;
+	readonly OHTA: 18;
+	readonly Rec601YCbCr: 19;
+	readonly Rec709YCbCr: 20;
+	readonly RGB: 21;
+	readonly scRGB: 22;
+	readonly sRGB: 23;
+	readonly Transparent: 24;
+	readonly XyY: 25;
+	readonly XYZ: 26;
+	readonly YCbCr: 27;
+	readonly YCC: 28;
+	readonly YDbDr: 29;
+	readonly YIQ: 30;
+	readonly YPbPr: 31;
+	readonly YUV: 32;
+	readonly LinearGray: 33;
+	readonly Jzazbz: 34;
+	readonly DisplayP3: 35;
+	readonly Adobe98: 36;
+	readonly ProPhoto: 37;
+	readonly Oklab: 38;
+	readonly Oklch: 39;
+	readonly CAT02LMSC: 40;
+};
+export type ColorSpace = typeof ColorSpace[keyof typeof ColorSpace];
+export declare const ComplexOperator: {
+	readonly Undefined: 0;
+	readonly Add: 1;
+	readonly Conjugate: 2;
+	readonly Divide: 3;
+	readonly MagnitudePhase: 4;
+	readonly Multiply: 5;
+	readonly RealImaginary: 6;
+	readonly Subtract: 7;
+};
+export type ComplexOperator = typeof ComplexOperator[keyof typeof ComplexOperator];
 export declare class ComplexSettings {
 	constructor(complexOperator: ComplexOperator);
 	readonly complexOperator: ComplexOperator;
 	signalToNoiseRatio?: number;
 }
-export declare enum EvaluateOperator {
-	Undefined = 0,
-	Abs = 1,
-	Add = 2,
-	AddModulus = 3,
-	And = 4,
-	Cosine = 5,
-	Divide = 6,
-	Exponential = 7,
-	GaussianNoise = 8,
-	ImpulseNoise = 9,
-	LaplacianNoise = 10,
-	LeftShift = 11,
-	Log = 12,
-	Max = 13,
-	Mean = 14,
-	Median = 15,
-	Min = 16,
-	MultiplicativeNoise = 17,
-	Multiply = 18,
-	Or = 19,
-	PoissonNoise = 20,
-	Pow = 21,
-	RightShift = 22,
-	RootMeanSquare = 23,
-	Set = 24,
-	Sine = 25,
-	Subtract = 26,
-	Sum = 27,
-	ThresholdBlack = 28,
-	Threshold = 29,
-	ThresholdWhite = 30,
-	UniformNoise = 31,
-	Xor = 32,
-	InverseLog = 33
-}
+export declare const EvaluateOperator: {
+	readonly Undefined: 0;
+	readonly Abs: 1;
+	readonly Add: 2;
+	readonly AddModulus: 3;
+	readonly And: 4;
+	readonly Cosine: 5;
+	readonly Divide: 6;
+	readonly Exponential: 7;
+	readonly GaussianNoise: 8;
+	readonly ImpulseNoise: 9;
+	readonly LaplacianNoise: 10;
+	readonly LeftShift: 11;
+	readonly Log: 12;
+	readonly Max: 13;
+	readonly Mean: 14;
+	readonly Median: 15;
+	readonly Min: 16;
+	readonly MultiplicativeNoise: 17;
+	readonly Multiply: 18;
+	readonly Or: 19;
+	readonly PoissonNoise: 20;
+	readonly Pow: 21;
+	readonly RightShift: 22;
+	readonly RootMeanSquare: 23;
+	readonly Set: 24;
+	readonly Sine: 25;
+	readonly Subtract: 26;
+	readonly Sum: 27;
+	readonly ThresholdBlack: 28;
+	readonly Threshold: 29;
+	readonly ThresholdWhite: 30;
+	readonly UniformNoise: 31;
+	readonly Xor: 32;
+	readonly InverseLog: 33;
+};
+export type EvaluateOperator = typeof EvaluateOperator[keyof typeof EvaluateOperator];
 export declare class MagickErrorInfo {
 	private constructor();
 	readonly meanErrorPerPixel: number;
@@ -776,55 +789,58 @@ export declare class MagickGeometry implements IMagickGeometry {
 	private isNumber;
 	private hasFlag;
 }
-export declare enum ColorType {
-	Undefined = 0,
-	Bilevel = 1,
-	Grayscale = 2,
-	GrayscaleAlpha = 3,
-	Palette = 4,
-	PaletteAlpha = 5,
-	TrueColor = 6,
-	TrueColorAlpha = 7,
-	ColorSeparation = 8,
-	ColorSeparationAlpha = 9,
-	Optimize = 10,
-	PaletteBilevelAlpha = 11
-}
-export declare enum CompressionMethod {
-	Undefined = 0,
-	B44A = 1,
-	B44 = 2,
-	BZip = 3,
-	DXT1 = 4,
-	DXT3 = 5,
-	DXT5 = 6,
-	Fax = 7,
-	Group4 = 8,
-	JBIG1 = 9,
-	JBIG2 = 10,
-	JPEG2000 = 11,
-	JPEG = 12,
-	LosslessJPEG = 13,
-	LZMA = 14,
-	LZW = 15,
-	NoCompression = 16,
-	Piz = 17,
-	Pxr24 = 18,
-	RLE = 19,
-	Zip = 20,
-	ZipS = 21,
-	Zstd = 22,
-	WebP = 23,
-	DWAA = 24,
-	DWAB = 25,
-	BC7 = 26,
-	BC5 = 27
-}
-export declare enum DensityUnit {
-	Undefined = 0,
-	PixelsPerInch = 1,
-	PixelsPerCentimeter = 2
-}
+export declare const ColorType: {
+	readonly Undefined: 0;
+	readonly Bilevel: 1;
+	readonly Grayscale: 2;
+	readonly GrayscaleAlpha: 3;
+	readonly Palette: 4;
+	readonly PaletteAlpha: 5;
+	readonly TrueColor: 6;
+	readonly TrueColorAlpha: 7;
+	readonly ColorSeparation: 8;
+	readonly ColorSeparationAlpha: 9;
+	readonly Optimize: 10;
+	readonly PaletteBilevelAlpha: 11;
+};
+export type ColorType = typeof ColorType[keyof typeof ColorType];
+export declare const CompressionMethod: {
+	readonly Undefined: 0;
+	readonly B44A: 1;
+	readonly B44: 2;
+	readonly BZip: 3;
+	readonly DXT1: 4;
+	readonly DXT3: 5;
+	readonly DXT5: 6;
+	readonly Fax: 7;
+	readonly Group4: 8;
+	readonly JBIG1: 9;
+	readonly JBIG2: 10;
+	readonly JPEG2000: 11;
+	readonly JPEG: 12;
+	readonly LosslessJPEG: 13;
+	readonly LZMA: 14;
+	readonly LZW: 15;
+	readonly NoCompression: 16;
+	readonly Piz: 17;
+	readonly Pxr24: 18;
+	readonly RLE: 19;
+	readonly Zip: 20;
+	readonly ZipS: 21;
+	readonly Zstd: 22;
+	readonly WebP: 23;
+	readonly DWAA: 24;
+	readonly DWAB: 25;
+	readonly BC7: 26;
+	readonly BC5: 27;
+};
+export type CompressionMethod = typeof CompressionMethod[keyof typeof CompressionMethod];
+export declare const DensityUnit: {
+	readonly Undefined: 0;
+	readonly PixelsPerInch: 1;
+	readonly PixelsPerCentimeter: 2;
+};
+export type DensityUnit = typeof DensityUnit[keyof typeof DensityUnit];
 export declare class Density {
 	constructor(xy: number);
 	constructor(xy: number, unit: DensityUnit);
@@ -835,21 +851,23 @@ export declare class Density {
 	toString(units?: DensityUnit): string;
 	private static toString;
 }
-export declare enum Endian {
-	Undefined = 0,
-	LSB = 1,
-	MSB = 2
-}
-export declare enum Interlace {
-	Undefined = 0,
-	NoInterlace = 1,
-	Line = 2,
-	Plane = 3,
-	Partition = 4,
-	Gif = 5,
-	Jpeg = 6,
-	Png = 7
-}
+export declare const Endian: {
+	readonly Undefined: 0;
+	readonly LSB: 1;
+	readonly MSB: 2;
+};
+export type Endian = typeof Endian[keyof typeof Endian];
+export declare const Interlace: {
+	readonly Undefined: 0;
+	readonly NoInterlace: 1;
+	readonly Line: 2;
+	readonly Plane: 3;
+	readonly Partition: 4;
+	readonly Gif: 5;
+	readonly Jpeg: 6;
+	readonly Png: 7;
+};
+export type Interlace = typeof Interlace[keyof typeof Interlace];
 export declare class MagickSettings {
 	antiAlias?: boolean;
 	backgroundColor?: IMagickColor;
@@ -909,12 +927,13 @@ export declare class MontageSettings {
 	title?: string;
 	transparentColor?: IMagickColor;
 }
-export declare enum DitherMethod {
-	Undefined = 0,
-	No = 1,
-	Riemersma = 2,
-	FloydSteinberg = 3
-}
+export declare const DitherMethod: {
+	readonly Undefined: 0;
+	readonly No: 1;
+	readonly Riemersma: 2;
+	readonly FloydSteinberg: 3;
+};
+export type DitherMethod = typeof DitherMethod[keyof typeof DitherMethod];
 export declare class QuantizeSettings {
 	constructor();
 	colors: number;
@@ -1050,12 +1069,13 @@ export type ImageCallback<TReturnType> = (image: IMagickImage) => TReturnType |
 export type AsyncImageCollectionCallback<TReturnType> = (images: IMagickImageCollection) => Promise<TReturnType>;
 export type SyncImageCollectionCallback<TReturnType> = (images: IMagickImageCollection) => TReturnType;
 export type ImageCollectionCallback<TReturnType> = (images: IMagickImageCollection) => TReturnType | Promise<TReturnType>;
-export declare enum AutoThresholdMethod {
-	Undefined = 0,
-	Kapur = 1,
-	OTSU = 2,
-	Triangle = 3
-}
+export declare const AutoThresholdMethod: {
+	readonly Undefined: 0;
+	readonly Kapur: 1;
+	readonly OTSU: 2;
+	readonly Triangle: 3;
+};
+export type AutoThresholdMethod = typeof AutoThresholdMethod[keyof typeof AutoThresholdMethod];
 export declare class PrimaryInfo {
 	constructor(x: number, y: number, z: number);
 	readonly x: number;
@@ -1069,11 +1089,12 @@ export declare class ChromaticityInfo {
 	readonly blue: PrimaryInfo;
 	readonly white: PrimaryInfo;
 }
-export declare enum ClassType {
-	Undefined = 0,
-	Direct = 1,
-	Pseudo = 2
-}
+export declare const ClassType: {
+	readonly Undefined: 0;
+	readonly Direct: 1;
+	readonly Pseudo: 2;
+};
+export type ClassType = typeof ClassType[keyof typeof ClassType];
 export interface IImageProfile {
 	readonly name: string;
 	readonly data: Uint8Array;
@@ -1093,7 +1114,6 @@ export interface IColorProfile extends IImageProfile {
 export declare class ColorProfile extends ImageProfile implements IColorProfile {
 	private _data?;
 	constructor(data: Uint8Array);
-	constructor(name: string, data: Uint8Array);
 	get colorSpace(): ColorSpace;
 	get copyright(): string | null;
 	get description(): string | null;
@@ -1101,26 +1121,32 @@ export declare class ColorProfile extends ImageProfile implements IColorProfile
 	get model(): string | null;
 	private initialize;
 }
+export declare const ColorTransformMode: {
+	readonly HighRes: 0;
+	readonly Quantum: 1;
+};
+export type ColorTransformMode = typeof ColorTransformMode[keyof typeof ColorTransformMode];
 export declare class CompareResult {
 	private constructor();
 	readonly difference: IMagickImage;
 	readonly distortion: number;
 }
-export declare enum ErrorMetric {
-	Undefined = 0,
-	Absolute = 1,
-	Fuzz = 2,
-	MeanAbsolute = 3,
-	MeanErrorPerPixel = 4,
-	MeanSquared = 5,
-	NormalizedCrossCorrelation = 6,
-	PeakAbsolute = 7,
-	PeakSignalToNoiseRatio = 8,
-	PerceptualHash = 9,
-	RootMeanSquared = 10,
-	StructuralSimilarity = 11,
-	StructuralDissimilarity = 12
-}
+export declare const ErrorMetric: {
+	readonly Undefined: 0;
+	readonly Absolute: 1;
+	readonly Fuzz: 2;
+	readonly MeanAbsolute: 3;
+	readonly MeanErrorPerPixel: 4;
+	readonly MeanSquared: 5;
+	readonly NormalizedCrossCorrelation: 6;
+	readonly PeakAbsolute: 7;
+	readonly PeakSignalToNoiseRatio: 8;
+	readonly PerceptualHash: 9;
+	readonly RootMeanSquared: 10;
+	readonly StructuralSimilarity: 11;
+	readonly StructuralDissimilarity: 12;
+};
+export type ErrorMetric = typeof ErrorMetric[keyof typeof ErrorMetric];
 export declare class CompareSettings {
 	constructor(metric: ErrorMetric);
 	readonly metric: ErrorMetric;
@@ -1128,90 +1154,91 @@ export declare class CompareSettings {
 	lowlightColor?: IMagickColor;
 	masklightColor?: IMagickColor;
 }
-export declare enum CompositeOperator {
-	Undefined = 0,
-	Alpha = 1,
-	Atop = 2,
-	Blend = 3,
-	Blur = 4,
-	Bumpmap = 5,
-	ChangeMask = 6,
-	Clear = 7,
-	ColorBurn = 8,
-	ColorDodge = 9,
-	Colorize = 10,
-	CopyBlack = 11,
-	CopyBlue = 12,
-	Copy = 13,
-	CopyCyan = 14,
-	CopyGreen = 15,
-	CopyMagenta = 16,
-	CopyAlpha = 17,
-	CopyRed = 18,
-	CopyYellow = 19,
-	Darken = 20,
-	DarkenIntensity = 21,
-	Difference = 22,
-	Displace = 23,
-	Dissolve = 24,
-	Distort = 25,
-	DivideDst = 26,
-	DivideSrc = 27,
-	DstAtop = 28,
-	Dst = 29,
-	DstIn = 30,
-	DstOut = 31,
-	DstOver = 32,
-	Exclusion = 33,
-	HardLight = 34,
-	HardMix = 35,
-	Hue = 36,
-	In = 37,
-	Intensity = 38,
-	Lighten = 39,
-	LightenIntensity = 40,
-	LinearBurn = 41,
-	LinearDodge = 42,
-	LinearLight = 43,
-	Luminize = 44,
-	Mathematics = 45,
-	MinusDst = 46,
-	MinusSrc = 47,
-	Modulate = 48,
-	ModulusAdd = 49,
-	ModulusSubtract = 50,
-	Multiply = 51,
-	No = 52,
-	Out = 53,
-	Over = 54,
-	Overlay = 55,
-	PegtopLight = 56,
-	PinLight = 57,
-	Plus = 58,
-	Replace = 59,
-	Saturate = 60,
-	Screen = 61,
-	SoftLight = 62,
-	SrcAtop = 63,
-	Src = 64,
-	SrcIn = 65,
-	SrcOut = 66,
-	SrcOver = 67,
-	Threshold = 68,
-	VividLight = 69,
-	Xor = 70,
-	Stereo = 71,
-	Freeze = 72,
-	Interpolate = 73,
-	Negate = 74,
-	Reflect = 75,
-	SoftBurn = 76,
-	SoftDodge = 77,
-	Stamp = 78,
-	RMSE = 79,
-	SaliencyBlend = 80,
-	SeamlessBlend = 81
-}
+export declare const CompositeOperator: {
+	readonly Undefined: 0;
+	readonly Alpha: 1;
+	readonly Atop: 2;
+	readonly Blend: 3;
+	readonly Blur: 4;
+	readonly Bumpmap: 5;
+	readonly ChangeMask: 6;
+	readonly Clear: 7;
+	readonly ColorBurn: 8;
+	readonly ColorDodge: 9;
+	readonly Colorize: 10;
+	readonly CopyBlack: 11;
+	readonly CopyBlue: 12;
+	readonly Copy: 13;
+	readonly CopyCyan: 14;
+	readonly CopyGreen: 15;
+	readonly CopyMagenta: 16;
+	readonly CopyAlpha: 17;
+	readonly CopyRed: 18;
+	readonly CopyYellow: 19;
+	readonly Darken: 20;
+	readonly DarkenIntensity: 21;
+	readonly Difference: 22;
+	readonly Displace: 23;
+	readonly Dissolve: 24;
+	readonly Distort: 25;
+	readonly DivideDst: 26;
+	readonly DivideSrc: 27;
+	readonly DstAtop: 28;
+	readonly Dst: 29;
+	readonly DstIn: 30;
+	readonly DstOut: 31;
+	readonly DstOver: 32;
+	readonly Exclusion: 33;
+	readonly HardLight: 34;
+	readonly HardMix: 35;
+	readonly Hue: 36;
+	readonly In: 37;
+	readonly Intensity: 38;
+	readonly Lighten: 39;
+	readonly LightenIntensity: 40;
+	readonly LinearBurn: 41;
+	readonly LinearDodge: 42;
+	readonly LinearLight: 43;
+	readonly Luminize: 44;
+	readonly Mathematics: 45;
+	readonly MinusDst: 46;
+	readonly MinusSrc: 47;
+	readonly Modulate: 48;
+	readonly ModulusAdd: 49;
+	readonly ModulusSubtract: 50;
+	readonly Multiply: 51;
+	readonly No: 52;
+	readonly Out: 53;
+	readonly Over: 54;
+	readonly Overlay: 55;
+	readonly PegtopLight: 56;
+	readonly PinLight: 57;
+	readonly Plus: 58;
+	readonly Replace: 59;
+	readonly Saturate: 60;
+	readonly Screen: 61;
+	readonly SoftLight: 62;
+	readonly SrcAtop: 63;
+	readonly Src: 64;
+	readonly SrcIn: 65;
+	readonly SrcOut: 66;
+	readonly SrcOver: 67;
+	readonly Threshold: 68;
+	readonly VividLight: 69;
+	readonly Xor: 70;
+	readonly Stereo: 71;
+	readonly Freeze: 72;
+	readonly Interpolate: 73;
+	readonly Negate: 74;
+	readonly Reflect: 75;
+	readonly SoftBurn: 76;
+	readonly SoftDodge: 77;
+	readonly Stamp: 78;
+	readonly RMSE: 79;
+	readonly SaliencyBlend: 80;
+	readonly SeamlessBlend: 81;
+};
+export type CompositeOperator = typeof CompositeOperator[keyof typeof CompositeOperator];
 export declare class Point {
 	constructor(xy: number);
 	constructor(x: number, y: number);
@@ -1250,28 +1277,29 @@ export declare class ConnectedComponentsSettings {
 	perimeterThreshold?: Threshold;
 	constructor(connectivity: Connectivity);
 }
-export declare enum DistortMethod {
-	Undefined = 0,
-	Affine = 1,
-	AffineProjection = 2,
-	ScaleRotateTranslate = 3,
-	Perspective = 4,
-	PerspectiveProjection = 5,
-	BilinearForward = 6,
-	BilinearReverse = 7,
-	Polynomial = 8,
-	Arc = 9,
-	Polar = 10,
-	DePolar = 11,
-	Cylinder2Plane = 12,
-	Plane2Cylinder = 13,
-	Barrel = 14,
-	BarrelInverse = 15,
-	Shepards = 16,
-	Resize = 17,
-	Sentinel = 18,
-	RigidAffine = 19
-}
+export declare const DistortMethod: {
+	readonly Undefined: 0;
+	readonly Affine: 1;
+	readonly AffineProjection: 2;
+	readonly ScaleRotateTranslate: 3;
+	readonly Perspective: 4;
+	readonly PerspectiveProjection: 5;
+	readonly BilinearForward: 6;
+	readonly BilinearReverse: 7;
+	readonly Polynomial: 8;
+	readonly Arc: 9;
+	readonly Polar: 10;
+	readonly DePolar: 11;
+	readonly Cylinder2Plane: 12;
+	readonly Plane2Cylinder: 13;
+	readonly Barrel: 14;
+	readonly BarrelInverse: 15;
+	readonly Shepards: 16;
+	readonly Resize: 17;
+	readonly Sentinel: 18;
+	readonly RigidAffine: 19;
+};
+export type DistortMethod = typeof DistortMethod[keyof typeof DistortMethod];
 export declare class DistortSettings {
 	constructor(method: DistortMethod);
 	readonly method: DistortMethod;
@@ -1279,111 +1307,115 @@ export declare class DistortSettings {
 	scale?: number;
 	viewport?: IMagickGeometry;
 }
-export declare enum FilterType {
-	Undefined = 0,
-	Point = 1,
-	Box = 2,
-	Triangle = 3,
-	Hermite = 4,
-	Hann = 5,
-	Hamming = 6,
-	Blackman = 7,
-	Gaussian = 8,
-	Quadratic = 9,
-	Cubic = 10,
-	Catrom = 11,
-	Mitchell = 12,
-	Jinc = 13,
-	Sinc = 14,
-	SincFast = 15,
-	Kaiser = 16,
-	Welch = 17,
-	Parzen = 18,
-	Bohman = 19,
-	Bartlett = 20,
-	Lagrange = 21,
-	Lanczos = 22,
-	LanczosSharp = 23,
-	Lanczos2 = 24,
-	Lanczos2Sharp = 25,
-	Robidoux = 26,
-	RobidouxSharp = 27,
-	Cosine = 28,
-	Spline = 29,
-	LanczosRadius = 30,
-	CubicSpline = 31
-}
-export declare enum GifDisposeMethod {
-	Undefined = 0,
-	None = 1,
-	Background = 2,
-	Previous = 3
-}
-export declare enum Kernel {
-	Undefined = "Undefined",
-	Unity = "Unity",
-	Gaussian = "Gaussian",
-	DoG = "DoG",
-	LoG = "LoG",
-	Blur = "Blur",
-	Comet = "Comet",
-	Binomial = "Binomial",
-	Laplacian = "Laplacian",
-	Sobel = "Sobel",
-	FreiChen = "FreiChen",
-	Roberts = "Roberts",
-	Prewitt = "Prewitt",
-	Compass = "Compass",
-	Kirsch = "Kirsch",
-	Diamond = "Diamond",
-	Square = "Square",
-	Rectangle = "Rectangle",
-	Octagon = "Octagon",
-	Disk = "Disk",
-	Plus = "Plus",
-	Cross = "Cross",
-	Ring = "Ring",
-	Peaks = "Peaks",
-	Edges = "Edges",
-	Corners = "Corners",
-	Diagonals = "Diagonals",
-	LineEnds = "LineEnds",
-	LineJunctions = "LineJunctions",
-	Ridges = "Ridges",
-	ConvexHull = "ConvexHull",
-	ThinSE = "ThinSE",
-	Skeleton = "Skeleton",
-	Chebyshev = "Chebyshev",
-	Manhattan = "Manhattan",
-	Octagonal = "Octagonal",
-	Euclidean = "Euclidean",
-	UserDefined = "UserDefined"
-}
-export declare enum MorphologyMethod {
-	Undefined = 0,
-	Convolve = 1,
-	Correlate = 2,
-	Erode = 3,
-	Dilate = 4,
-	ErodeIntensity = 5,
-	DilateIntensity = 6,
-	IterativeDistance = 7,
-	Open = 8,
-	Close = 9,
-	OpenIntensity = 10,
-	CloseIntensity = 11,
-	Smooth = 12,
-	EdgeIn = 13,
-	EdgeOut = 14,
-	Edge = 15,
-	TopHat = 16,
-	BottomHat = 17,
-	HitAndMiss = 18,
-	Thinning = 19,
-	Thicken = 20,
-	Distance = 21,
-	Voronoi = 22
-}
+export declare const FilterType: {
+	readonly Undefined: 0;
+	readonly Point: 1;
+	readonly Box: 2;
+	readonly Triangle: 3;
+	readonly Hermite: 4;
+	readonly Hann: 5;
+	readonly Hamming: 6;
+	readonly Blackman: 7;
+	readonly Gaussian: 8;
+	readonly Quadratic: 9;
+	readonly Cubic: 10;
+	readonly Catrom: 11;
+	readonly Mitchell: 12;
+	readonly Jinc: 13;
+	readonly Sinc: 14;
+	readonly SincFast: 15;
+	readonly Kaiser: 16;
+	readonly Welch: 17;
+	readonly Parzen: 18;
+	readonly Bohman: 19;
+	readonly Bartlett: 20;
+	readonly Lagrange: 21;
+	readonly Lanczos: 22;
+	readonly LanczosSharp: 23;
+	readonly Lanczos2: 24;
+	readonly Lanczos2Sharp: 25;
+	readonly Robidoux: 26;
+	readonly RobidouxSharp: 27;
+	readonly Cosine: 28;
+	readonly Spline: 29;
+	readonly LanczosRadius: 30;
+	readonly CubicSpline: 31;
+};
+export type FilterType = typeof FilterType[keyof typeof FilterType];
+export declare const GifDisposeMethod: {
+	readonly Undefined: 0;
+	readonly None: 1;
+	readonly Background: 2;
+	readonly Previous: 3;
+};
+export type GifDisposeMethod = typeof GifDisposeMethod[keyof typeof GifDisposeMethod];
+export declare const Kernel: {
+	readonly Undefined: "Undefined";
+	readonly Unity: "Unity";
+	readonly Gaussian: "Gaussian";
+	readonly DoG: "DoG";
+	readonly LoG: "LoG";
+	readonly Blur: "Blur";
+	readonly Comet: "Comet";
+	readonly Binomial: "Binomial";
+	readonly Laplacian: "Laplacian";
+	readonly Sobel: "Sobel";
+	readonly FreiChen: "FreiChen";
+	readonly Roberts: "Roberts";
+	readonly Prewitt: "Prewitt";
+	readonly Compass: "Compass";
+	readonly Kirsch: "Kirsch";
+	readonly Diamond: "Diamond";
+	readonly Square: "Square";
+	readonly Rectangle: "Rectangle";
+	readonly Octagon: "Octagon";
+	readonly Disk: "Disk";
+	readonly Plus: "Plus";
+	readonly Cross: "Cross";
+	readonly Ring: "Ring";
+	readonly Peaks: "Peaks";
+	readonly Edges: "Edges";
+	readonly Corners: "Corners";
+	readonly Diagonals: "Diagonals";
+	readonly LineEnds: "LineEnds";
+	readonly LineJunctions: "LineJunctions";
+	readonly Ridges: "Ridges";
+	readonly ConvexHull: "ConvexHull";
+	readonly ThinSE: "ThinSE";
+	readonly Skeleton: "Skeleton";
+	readonly Chebyshev: "Chebyshev";
+	readonly Manhattan: "Manhattan";
+	readonly Octagonal: "Octagonal";
+	readonly Euclidean: "Euclidean";
+	readonly UserDefined: "UserDefined";
+};
+export type Kernel = typeof Kernel[keyof typeof Kernel];
+export declare const MorphologyMethod: {
+	readonly Undefined: 0;
+	readonly Convolve: 1;
+	readonly Correlate: 2;
+	readonly Erode: 3;
+	readonly Dilate: 4;
+	readonly ErodeIntensity: 5;
+	readonly DilateIntensity: 6;
+	readonly IterativeDistance: 7;
+	readonly Open: 8;
+	readonly Close: 9;
+	readonly OpenIntensity: 10;
+	readonly CloseIntensity: 11;
+	readonly Smooth: 12;
+	readonly EdgeIn: 13;
+	readonly EdgeOut: 14;
+	readonly Edge: 15;
+	readonly TopHat: 16;
+	readonly BottomHat: 17;
+	readonly HitAndMiss: 18;
+	readonly Thinning: 19;
+	readonly Thicken: 20;
+	readonly Distance: 21;
+	readonly Voronoi: 22;
+};
+export type MorphologyMethod = typeof MorphologyMethod[keyof typeof MorphologyMethod];
 export declare class MorphologySettings {
 	constructor(method: MorphologyMethod, kernel: Kernel | string, args?: string);
 	channels: Channels;
@@ -1393,92 +1425,118 @@ export declare class MorphologySettings {
 	readonly kernel: string;
 	readonly method: MorphologyMethod;
 }
-export declare enum NoiseType {
-	Undefined = 0,
-	Uniform = 1,
-	Gaussian = 2,
-	MultiplicativeGaussian = 3,
-	Impulse = 4,
-	Laplacian = 5,
-	Poisson = 6,
-	Random = 7
-}
-declare enum OrientationType$1 {
-	Undefined = 0,
-	TopLeft = 1,
-	TopRight = 2,
-	BottomRight = 3,
-	BottomLeft = 4,
-	LeftTop = 5,
-	RightTop = 6,
-	RightBottom = 7,
-	LeftBottom = 8
-}
-export declare enum PixelChannel {
-	Red = 0,
-	Cyan = 0,
-	Gray = 0,
-	Green = 1,
-	Magenta = 1,
-	Blue = 2,
-	Yellow = 2,
-	Black = 3,
-	Alpha = 4,
-	Index = 5,
-	Meta0 = 10,
-	Meta1 = 11,
-	Meta2 = 12,
-	Meta3 = 13,
-	Meta4 = 14,
-	Meta5 = 15,
-	Meta6 = 16,
-	Meta7 = 17,
-	Meta8 = 18,
-	Meta9 = 19,
-	Meta10 = 20,
-	Meta11 = 21,
-	Meta12 = 22,
-	Meta13 = 23,
-	Meta14 = 24,
-	Meta15 = 25,
-	Meta16 = 26,
-	Meta17 = 27,
-	Meta18 = 28,
-	Meta19 = 29,
-	Meta20 = 30,
-	Meta21 = 31,
-	Meta22 = 32,
-	Meta23 = 33,
-	Meta24 = 34,
-	Meta25 = 35,
-	Meta26 = 36,
-	Meta27 = 37,
-	Meta28 = 38,
-	Meta29 = 39,
-	Meta30 = 40,
-	Meta31 = 41,
-	Meta32 = 42,
-	Meta33 = 43,
-	Meta34 = 44,
-	Meta35 = 45,
-	Meta36 = 46,
-	Meta37 = 47,
-	Meta38 = 48,
-	Meta39 = 49,
-	Meta40 = 50,
-	Meta41 = 51,
-	Meta42 = 52,
-	Meta43 = 53,
-	Meta44 = 54,
-	Meta45 = 55,
-	Meta46 = 56,
-	Meta47 = 57,
-	Meta48 = 58,
-	Meta49 = 59,
-	Meta50 = 60,
-	Meta51 = 61,
-	Meta52 = 62,
-	Composite = 64
+export declare const Orientation: {
+	readonly Undefined: 0;
+	readonly TopLeft: 1;
+	readonly TopRight: 2;
+	readonly BottomRight: 3;
+	readonly BottomLeft: 4;
+	readonly LeftTop: 5;
+	readonly RightTop: 6;
+	readonly RightBottom: 7;
+	readonly LeftBottom: 8;
+};
+export type Orientation = typeof Orientation[keyof typeof Orientation];
+export declare const NoiseType: {
+	readonly Undefined: 0;
+	readonly Uniform: 1;
+	readonly Gaussian: 2;
+	readonly MultiplicativeGaussian: 3;
+	readonly Impulse: 4;
+	readonly Laplacian: 5;
+	readonly Poisson: 6;
+	readonly Random: 7;
+};
+export type NoiseType = typeof NoiseType[keyof typeof NoiseType];
+export declare const PixelChannel: {
+	readonly Red: 0;
+	readonly Cyan: 0;
+	readonly Gray: 0;
+	readonly Green: 1;
+	readonly Magenta: 1;
+	readonly Blue: 2;
+	readonly Yellow: 2;
+	readonly Black: 3;
+	readonly Alpha: 4;
+	readonly Index: 5;
+	readonly Meta0: 10;
+	readonly Meta1: 11;
+	readonly Meta2: 12;
+	readonly Meta3: 13;
+	readonly Meta4: 14;
+	readonly Meta5: 15;
+	readonly Meta6: 16;
+	readonly Meta7: 17;
+	readonly Meta8: 18;
+	readonly Meta9: 19;
+	readonly Meta10: 20;
+	readonly Meta11: 21;
+	readonly Meta12: 22;
+	readonly Meta13: 23;
+	readonly Meta14: 24;
+	readonly Meta15: 25;
+	readonly Meta16: 26;
+	readonly Meta17: 27;
+	readonly Meta18: 28;
+	readonly Meta19: 29;
+	readonly Meta20: 30;
+	readonly Meta21: 31;
+	readonly Meta22: 32;
+	readonly Meta23: 33;
+	readonly Meta24: 34;
+	readonly Meta25: 35;
+	readonly Meta26: 36;
+	readonly Meta27: 37;
+	readonly Meta28: 38;
+	readonly Meta29: 39;
+	readonly Meta30: 40;
+	readonly Meta31: 41;
+	readonly Meta32: 42;
+	readonly Meta33: 43;
+	readonly Meta34: 44;
+	readonly Meta35: 45;
+	readonly Meta36: 46;
+	readonly Meta37: 47;
+	readonly Meta38: 48;
+	readonly Meta39: 49;
+	readonly Meta40: 50;
+	readonly Meta41: 51;
+	readonly Meta42: 52;
+	readonly Meta43: 53;
+	readonly Meta44: 54;
+	readonly Meta45: 55;
+	readonly Meta46: 56;
+	readonly Meta47: 57;
+	readonly Meta48: 58;
+	readonly Meta49: 59;
+	readonly Meta50: 60;
+	readonly Meta51: 61;
+	readonly Meta52: 62;
+	readonly Composite: 64;
+};
+export type PixelChannel = typeof PixelChannel[keyof typeof PixelChannel];
+export interface IChannelPerceptualHash {
+	readonly channel: PixelChannel;
+	huPhash(colorSpace: ColorSpace, channelIndex: number): number;
+	sumSquaredDistance(other: IChannelPerceptualHash): number;
+	toString(): string;
+}
+export declare class ChannelPerceptualHash implements IChannelPerceptualHash {
+	private readonly _huPhashes;
+	private _hash;
+	channel: PixelChannel;
+	constructor(channel: PixelChannel, colorSpaces: ReadonlyArray<ColorSpace>, instance: number);
+	huPhash(colorSpace: ColorSpace, index: number): number;
+	sumSquaredDistance(other: IChannelPerceptualHash): number;
+	toString(): string;
+	private parseHash;
+	private static powerOfTen;
+	private setHash;
+}
+export interface IPerceptualHash {
+	getChannel(channel: number): IChannelPerceptualHash | null;
+	sumSquaredDistance(other: IPerceptualHash): number;
+	toString(): string;
 }
 export type quantumArray = Uint8Array;
 export interface IPixelCollection extends IDisposable {
@@ -1502,44 +1560,47 @@ export declare class PixelCollection extends NativeInstance implements IPixelCol
 	toByteArray(x: number, y: number, width: number, height: number, mapping: string): Uint8Array | null;
 	private use;
 }
-export declare enum PixelIntensityMethod {
-	Undefined = 0,
-	Average = 1,
-	Brightness = 2,
-	Lightness = 3,
-	MS = 4,
-	Rec601Luma = 5,
-	Rec601Luminance = 6,
-	Rec709Luma = 7,
-	Rec709Luminance = 8,
-	RMS = 9
-}
-export declare enum PixelInterpolateMethod {
-	Undefined = 0,
-	Average = 1,
-	Average9 = 2,
-	Average16 = 3,
-	Background = 4,
-	Bilinear = 5,
-	Blend = 6,
-	Catrom = 7,
-	Integer = 8,
-	Mesh = 9,
-	Nearest = 10,
-	Spline = 11
-}
+export declare const PixelIntensityMethod: {
+	readonly Undefined: 0;
+	readonly Average: 1;
+	readonly Brightness: 2;
+	readonly Lightness: 3;
+	readonly MS: 4;
+	readonly Rec601Luma: 5;
+	readonly Rec601Luminance: 6;
+	readonly Rec709Luma: 7;
+	readonly Rec709Luminance: 8;
+	readonly RMS: 9;
+};
+export type PixelIntensityMethod = typeof PixelIntensityMethod[keyof typeof PixelIntensityMethod];
+export declare const PixelInterpolateMethod: {
+	readonly Undefined: 0;
+	readonly Average: 1;
+	readonly Average9: 2;
+	readonly Average16: 3;
+	readonly Background: 4;
+	readonly Bilinear: 5;
+	readonly Blend: 6;
+	readonly Catrom: 7;
+	readonly Integer: 8;
+	readonly Mesh: 9;
+	readonly Nearest: 10;
+	readonly Spline: 11;
+};
+export type PixelInterpolateMethod = typeof PixelInterpolateMethod[keyof typeof PixelInterpolateMethod];
 declare class ProgressEvent$1 {
 	readonly origin: string | null;
 	readonly progress: Percentage;
 	cancel: boolean;
 }
-export declare enum RenderingIntent {
-	Undefined = 0,
-	Saturation = 1,
-	Perceptual = 2,
-	Absolute = 3,
-	Relative = 4
-}
+export declare const RenderingIntent: {
+	readonly Undefined: 0;
+	readonly Saturation: 1;
+	readonly Perceptual: 2;
+	readonly Absolute: 3;
+	readonly Relative: 4;
+};
+export type RenderingIntent = typeof RenderingIntent[keyof typeof RenderingIntent];
 export interface IChannelStatistics {
 	readonly channel: PixelChannel;
 	readonly depth: number;
@@ -1556,73 +1617,75 @@ export interface IStatistics {
 	composite(): IChannelStatistics;
 	getChannel(channel: PixelChannel): IChannelStatistics | null;
 }
-export declare enum VirtualPixelMethod {
-	Undefined = 0,
-	Background = 1,
-	Dither = 2,
-	Edge = 3,
-	Mirror = 4,
-	Random = 5,
-	Tile = 6,
-	Transparent = 7,
-	Mask = 8,
-	Black = 9,
-	Gray = 10,
-	White = 11,
-	HorizontalTile = 12,
-	VerticalTile = 13,
-	HorizontalTileEdge = 14,
-	VerticalTileEdge = 15,
-	CheckerTile = 16
-}
-export declare enum MagickErrorSeverity {
-	Warning = 300,
-	ResourceLimitWarning = 300,
-	TypeWarning = 305,
-	OptionWarning = 310,
-	DelegateWarning = 315,
-	MissingDelegateWarning = 320,
-	CorruptImageWarning = 325,
-	FileOpenWarning = 330,
-	BlobWarning = 335,
-	StreamWarning = 340,
-	CacheWarning = 345,
-	CoderWarning = 350,
-	FilterWarning = 352,
-	ModuleWarning = 355,
-	DrawWarning = 360,
-	ImageWarning = 365,
-	WandWarning = 370,
-	RandomWarning = 375,
-	XServerWarning = 380,
-	MonitorWarning = 385,
-	RegistryWarning = 390,
-	ConfigureWarning = 395,
-	PolicyWarning = 399,
-	Error = 400,
-	ResourceLimitError = 400,
-	TypeError = 405,
-	OptionError = 410,
-	DelegateError = 415,
-	MissingDelegateError = 420,
-	CorruptImageError = 425,
-	FileOpenError = 430,
-	BlobError = 435,
-	StreamError = 440,
-	CacheError = 445,
-	CoderError = 450,
-	FilterError = 452,
-	ModuleError = 455,
-	DrawError = 460,
-	ImageError = 465,
-	WandError = 470,
-	RandomError = 475,
-	XServerError = 480,
-	MonitorError = 485,
-	RegistryError = 490,
-	ConfigureError = 495,
-	PolicyError = 499
-}
+export declare const VirtualPixelMethod: {
+	readonly Undefined: 0;
+	readonly Background: 1;
+	readonly Dither: 2;
+	readonly Edge: 3;
+	readonly Mirror: 4;
+	readonly Random: 5;
+	readonly Tile: 6;
+	readonly Transparent: 7;
+	readonly Mask: 8;
+	readonly Black: 9;
+	readonly Gray: 10;
+	readonly White: 11;
+	readonly HorizontalTile: 12;
+	readonly VerticalTile: 13;
+	readonly HorizontalTileEdge: 14;
+	readonly VerticalTileEdge: 15;
+	readonly CheckerTile: 16;
+};
+export type VirtualPixelMethod = typeof VirtualPixelMethod[keyof typeof VirtualPixelMethod];
+export declare const MagickErrorSeverity: {
+	readonly Warning: 300;
+	readonly ResourceLimitWarning: 300;
+	readonly TypeWarning: 305;
+	readonly OptionWarning: 310;
+	readonly DelegateWarning: 315;
+	readonly MissingDelegateWarning: 320;
+	readonly CorruptImageWarning: 325;
+	readonly FileOpenWarning: 330;
+	readonly BlobWarning: 335;
+	readonly StreamWarning: 340;
+	readonly CacheWarning: 345;
+	readonly CoderWarning: 350;
+	readonly FilterWarning: 352;
+	readonly ModuleWarning: 355;
+	readonly DrawWarning: 360;
+	readonly ImageWarning: 365;
+	readonly WandWarning: 370;
+	readonly RandomWarning: 375;
+	readonly XServerWarning: 380;
+	readonly MonitorWarning: 385;
+	readonly RegistryWarning: 390;
+	readonly ConfigureWarning: 395;
+	readonly PolicyWarning: 399;
+	readonly Error: 400;
+	readonly ResourceLimitError: 400;
+	readonly TypeError: 405;
+	readonly OptionError: 410;
+	readonly DelegateError: 415;
+	readonly MissingDelegateError: 420;
+	readonly CorruptImageError: 425;
+	readonly FileOpenError: 430;
+	readonly BlobError: 435;
+	readonly StreamError: 440;
+	readonly CacheError: 445;
+	readonly CoderError: 450;
+	readonly FilterError: 452;
+	readonly ModuleError: 455;
+	readonly DrawError: 460;
+	readonly ImageError: 465;
+	readonly WandError: 470;
+	readonly RandomError: 475;
+	readonly XServerError: 480;
+	readonly MonitorError: 485;
+	readonly RegistryError: 490;
+	readonly ConfigureError: 495;
+	readonly PolicyError: 499;
+};
+export type MagickErrorSeverity = typeof MagickErrorSeverity[keyof typeof MagickErrorSeverity];
 export declare class MagickError extends Error {
 	private _relatedErrors;
 	readonly severity: MagickErrorSeverity;
@@ -1670,7 +1733,7 @@ export interface IMagickImage extends IDisposable {
 	label: string | null;
 	matteColor: IMagickColor;
 	metaChannelCount: number;
-	orientation: OrientationType$1;
+	orientation: Orientation;
 	onProgress?: (event: ProgressEvent$1) => void;
 	onWarning?: (event: WarningEvent) => void;
 	page: IMagickGeometry;
@@ -1691,17 +1754,32 @@ export interface IMagickImage extends IDisposable {
 	adaptiveSharpen(channels: Channels): void;
 	adaptiveSharpen(radius: number, sigma: number): void;
 	adaptiveSharpen(radius: number, sigma: number, channels: Channels): void;
+	adaptiveThreshold(width: number, height: number): void;
+	adaptiveThreshold(width: number, height: number, channels: Channels): void;
+	adaptiveThreshold(width: number, height: number, bias: Percentage): void;
+	adaptiveThreshold(width: number, height: number, bias: Percentage, channels: Channels): void;
 	addNoise(noiseType: NoiseType): void;
 	addNoise(noiseType: NoiseType, channels: Channels): void;
 	addNoise(noiseType: NoiseType, attenuate: number): void;
 	addNoise(noiseType: NoiseType, attenuate: number, channels: Channels): void;
-	alpha(value: AlphaOption$1): void;
+	alpha(value: AlphaAction): void;
+	annotate(text: string, boundingArea: MagickGeometry): void;
+	annotate(text: string, boundingArea: MagickGeometry, gravity: Gravity): void;
+	annotate(text: string, boundingArea: MagickGeometry, gravity: Gravity, angle: number): void;
+	annotate(text: string, gravity: Gravity): void;
+	annotate(text: string, gravity: Gravity, angle: number): void;
 	autoGamma(): void;
 	autoGamma(channels: Channels): void;
 	autoLevel(): void;
 	autoLevel(channels: Channels): void;
 	autoOrient(): void;
 	autoThreshold(method: AutoThresholdMethod): void;
+	bilateralBlur(width: number, height: number): void;
+	bilateralBlur(width: number, height: number, intensitySigma: number, spatialSigma: number): void;
+	blackThreshold(threshold: Percentage): void;
+	blackThreshold(threshold: Percentage, channels: Channels): void;
+	blueShift(): void;
+	blueShift(factor: number): void;
 	blur(): void;
 	blur(channels: Channels): void;
 	blur(radius: number, sigma: number): void;
@@ -1710,8 +1788,11 @@ export interface IMagickImage extends IDisposable {
 	border(width: number, height: number): void;
 	brightnessContrast(brightness: Percentage, contrast: Percentage): void;
 	brightnessContrast(brightness: Percentage, contrast: Percentage, channels: Channels): void;
+	cannyEdge(): void;
+	cannyEdge(radius: number, sigma: number, lower: Percentage, upper: Percentage): void;
 	charcoal(): void;
 	charcoal(radius: number, sigma: number): void;
+	chop(geometry: MagickGeometry): void;
 	clahe(xTiles: number, yTiles: number, numberBins: number, clipLimit: number): void;
 	clahe(xTiles: Percentage, yTiles: Percentage, numberBins: number, clipLimit: number): void;
 	clone<TReturnType>(func: SyncImageCallback<TReturnType>): TReturnType;
@@ -1783,6 +1864,7 @@ export interface IMagickImage extends IDisposable {
 	extent(geometry: IMagickGeometry, backgroundColor: IMagickColor): void;
 	flip(): void;
 	flop(): void;
+	formatExpression(expression: string): string | null;
 	gammaCorrect(gamma: number): void;
 	gammaCorrect(gamma: number, channels: Channels): void;
 	gaussianBlur(radius: number): void;
@@ -1829,6 +1911,8 @@ export interface IMagickImage extends IDisposable {
 	oilPaint(): void;
 	oilPaint(radius: number): void;
 	opaque(target: IMagickColor, fill: IMagickColor): void;
+	perceptualHash(): IPerceptualHash;
+	perceptualHash(colorSpaces: ReadonlyArray<ColorSpace>): IPerceptualHash;
 	ping(fileName: string, settings?: MagickReadSettings): void;
 	ping(array: ByteArray, settings?: MagickReadSettings): void;
 	quantize(settings?: QuantizeSettings): MagickErrorInfo | null;
@@ -1873,7 +1957,9 @@ export interface IMagickImage extends IDisposable {
 	statistics(channels: Channels): IStatistics;
 	strip(): void;
 	transformColorSpace(target: IColorProfile): boolean;
+	transformColorSpace(target: IColorProfile, mode: ColorTransformMode): boolean;
 	transformColorSpace(source: IColorProfile, target: IColorProfile): boolean;
+	transformColorSpace(source: IColorProfile, target: IColorProfile, mode: ColorTransformMode): boolean;
 	threshold(percentage: Percentage): void;
 	threshold(percentage: Percentage, channels: Channels): void;
 	thumbnail(width: number, height: number): void;
@@ -1887,6 +1973,8 @@ export interface IMagickImage extends IDisposable {
 	vignette(radius: number, sigma: number, x: number, y: number): void;
 	wave(): void;
 	wave(method: PixelInterpolateMethod, amplitude: number, length: number): void;
+	whiteThreshold(threshold: Percentage): void;
+	whiteThreshold(threshold: Percentage, channels: Channels): void;
 	write<TReturnType>(func: (data: Uint8Array) => TReturnType): TReturnType;
 	write<TReturnType>(func: (data: Uint8Array) => Promise<TReturnType>): Promise<TReturnType>;
 	write<TReturnType>(format: MagickFormat, func: (data: Uint8Array) => TReturnType): TReturnType;
@@ -1938,11 +2026,11 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
 	set density(value: Density);
 	get depth(): number;
 	set depth(value: number);
-	get endian(): number;
-	set endian(value: number);
+	get endian(): Endian;
+	set endian(value: Endian);
 	get fileName(): string | null;
-	get filterType(): number;
-	set filterType(value: number);
+	get filterType(): FilterType;
+	set filterType(value: FilterType);
 	get format(): MagickFormat;
 	set format(value: MagickFormat);
 	get gamma(): number;
@@ -1961,8 +2049,8 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
 	set matteColor(value: IMagickColor);
 	get metaChannelCount(): number;
 	set metaChannelCount(value: number);
-	get orientation(): OrientationType$1;
-	set orientation(value: OrientationType$1);
+	get orientation(): Orientation;
+	set orientation(value: Orientation);
 	get onProgress(): ((event: ProgressEvent$1) => number) | undefined;
 	set onProgress(value: ((event: ProgressEvent$1) => number) | undefined);
 	get onWarning(): ((event: WarningEvent) => number) | undefined;
@@ -1989,15 +2077,30 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
 	adaptiveSharpen(channels: Channels): void;
 	adaptiveSharpen(radius: number, sigma: number): void;
 	adaptiveSharpen(radius: number, sigma: number, channels: Channels): void;
+	adaptiveThreshold(width: number, height: number): void;
+	adaptiveThreshold(width: number, height: number, channels: Channels): void;
+	adaptiveThreshold(width: number, height: number, bias: Percentage): void;
+	adaptiveThreshold(width: number, height: number, bias: Percentage, channels: Channels): void;
 	addNoise(noiseType: NoiseType): void;
 	addNoise(noiseType: NoiseType, channels: Channels): void;
 	addNoise(noiseType: NoiseType, attenuate: number): void;
 	addNoise(noiseType: NoiseType, attenuate: number, channels: Channels): void;
-	alpha(value: AlphaOption$1): void;
+	alpha(value: AlphaAction): void;
+	annotate(text: string, boundingArea: MagickGeometry): void;
+	annotate(text: string, boundingArea: MagickGeometry, gravity: Gravity): void;
+	annotate(text: string, boundingArea: MagickGeometry, gravity: Gravity, angle: number): void;
+	annotate(text: string, gravity: Gravity): void;
+	annotate(text: string, gravity: Gravity, angle: number): void;
 	autoGamma(): void;
 	autoLevel(): void;
 	autoOrient(): void;
 	autoThreshold(method: AutoThresholdMethod): void;
+	bilateralBlur(width: number, height: number): void;
+	bilateralBlur(width: number, height: number, intensitySigma: number, spatialSigma: number): void;
+	blackThreshold(threshold: Percentage): void;
+	blackThreshold(threshold: Percentage, channels: Channels): void;
+	blueShift(): void;
+	blueShift(factor: number): void;
 	blur(): void;
 	blur(channels: Channels): void;
 	blur(radius: number, sigma: number): void;
@@ -2006,8 +2109,11 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
 	border(width: number, height: number): void;
 	brightnessContrast(brightness: Percentage, contrast: Percentage): void;
 	brightnessContrast(brightness: Percentage, contrast: Percentage, channels: Channels): void;
+	cannyEdge(): void;
+	cannyEdge(radius: number, sigma: number, lower: Percentage, upper: Percentage): void;
 	charcoal(): void;
 	charcoal(radius: number, sigma: number): void;
+	chop(geometry: MagickGeometry): void;
 	clahe(xTiles: number, yTiles: number, numberBins: number, clipLimit: number): void;
 	clahe(xTiles: Percentage, yTiles: Percentage, numberBins: number, clipLimit: number): void;
 	clone<TReturnType>(func: SyncImageCallback<TReturnType>): TReturnType;
@@ -2083,6 +2189,7 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
 	extent(geometry: IMagickGeometry, backgroundColor: IMagickColor): void;
 	flip(): void;
 	flop(): void;
+	formatExpression(expression: string): string | null;
 	gammaCorrect(gamma: number): void;
 	gammaCorrect(gamma: number, channels: Channels): void;
 	gaussianBlur(radius: number): void;
@@ -2128,6 +2235,8 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
 	opaque: (target: IMagickColor, fill: IMagickColor) => void;
 	ping(fileName: string, settings?: MagickReadSettings): void;
 	ping(array: ByteArray, settings?: MagickReadSettings): void;
+	perceptualHash(): IPerceptualHash;
+	perceptualHash(colorSpaces: ReadonlyArray<ColorSpace>): IPerceptualHash;
 	quantize(settingsOrUndefined?: QuantizeSettings): MagickErrorInfo | null;
 	read(color: IMagickColor, width: number, height: number): void;
 	read(fileName: string, settings?: MagickReadSettings): void;
@@ -2166,7 +2275,9 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
 	statistics(channels: Channels): IStatistics;
 	strip(): void;
 	transformColorSpace(target: IColorProfile): boolean;
+	transformColorSpace(target: IColorProfile, mode: ColorTransformMode): boolean;
 	transformColorSpace(source: IColorProfile, target: IColorProfile): boolean;
+	transformColorSpace(source: IColorProfile, target: IColorProfile, mode: ColorTransformMode): boolean;
 	threshold(percentage: Percentage): void;
 	threshold(percentage: Percentage, channels: Channels): void;
 	thumbnail(width: number, height: number): void;
@@ -2180,6 +2291,8 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
 	wave(method: PixelInterpolateMethod, amplitude: number, length: number): void;
 	vignette(): void;
 	vignette(radius: number, sigma: number, x: number, y: number): void;
+	whiteThreshold(threshold: Percentage): void;
+	whiteThreshold(threshold: Percentage, channels: Channels): void;
 	write<TReturnType>(func: (data: Uint8Array) => TReturnType): TReturnType;
 	write<TReturnType>(func: (data: Uint8Array) => Promise<TReturnType>): Promise<TReturnType>;
 	write<TReturnType>(format: MagickFormat, func: (data: Uint8Array) => TReturnType): TReturnType;
@@ -2198,6 +2311,7 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
 	private readFromArray;
 	private toBool;
 	private valueOrDefault;
+	private valueOrComputedDefault;
 	private useException;
 	private useExceptionPointer;
 }
@@ -2236,30 +2350,31 @@ export declare class Drawables {
 	textUnderColor(color: IMagickColor): Drawables;
 	draw(image: IMagickImage): Drawables;
 }
-export declare enum LogEventTypes {
-	None = 0,
-	Accelerate = 1,
-	Annotate = 2,
-	Blob = 4,
-	Cache = 8,
-	Coder = 16,
-	Configure = 32,
-	Deprecate = 64,
-	Draw = 128,
-	Exception = 256,
-	Image = 512,
-	Locale = 1024,
-	Module = 2048,
-	Pixel = 4096,
-	Policy = 8192,
-	Resource = 16384,
-	Trace = 32768,
-	Transform = 65536,
-	User = 131072,
-	Wand = 262144,
-	Detailed = 2147450879,
-	All = 2147483647
-}
+export declare const LogEventTypes: {
+	readonly None: 0;
+	readonly Accelerate: 1;
+	readonly Annotate: 2;
+	readonly Blob: 4;
+	readonly Cache: 8;
+	readonly Coder: 16;
+	readonly Configure: 32;
+	readonly Deprecate: 64;
+	readonly Draw: 128;
+	readonly Exception: 256;
+	readonly Image: 512;
+	readonly Locale: 1024;
+	readonly Module: 2048;
+	readonly Pixel: 4096;
+	readonly Policy: 8192;
+	readonly Resource: 16384;
+	readonly Trace: 32768;
+	readonly Transform: 65536;
+	readonly User: 131072;
+	readonly Wand: 262144;
+	readonly Detailed: 2147450879;
+	readonly All: number;
+};
+export type LogEventTypes = typeof LogEventTypes[keyof typeof LogEventTypes];
 export declare class LogEvent {
 	constructor(eventType: LogEventTypes, message?: string);
 	readonly eventType: LogEventTypes;
@@ -2484,7 +2599,7 @@ export interface IMagickImageInfo {
 	readonly format: MagickFormat;
 	readonly height: number;
 	readonly interlace: Interlace;
-	readonly orientation: OrientationType$1;
+	readonly orientation: Orientation;
 	readonly quality: number;
 	readonly width: number;
 	read(array: ByteArray, settings?: MagickReadSettings): void;
@@ -2505,7 +2620,7 @@ export declare class MagickImageInfo implements IMagickImageInfo {
 	get format(): MagickFormat;
 	get height(): number;
 	get interlace(): Interlace;
-	get orientation(): OrientationType$1;
+	get orientation(): Orientation;
 	get quality(): number;
 	get width(): number;
 	constructor();
@@ -2531,8 +2646,6 @@ export declare class Quantum {
 }
 
 export {
-	AlphaOption$1 as AlphaOption,
-	OrientationType$1 as OrientationType,
 	ProgressEvent$1 as ProgressEvent,
 };