From a0c6592149faa7bb7b6047379be9d555738fa6dd Mon Sep 17 00:00:00 2001
From: Remi Collet <remi@remirepo.net>
Date: Mon, 22 Nov 2021 16:40:31 +0100
Subject: refresh reflection with PHP 8

---
 PHPINFO-im6    |    4 +-
 PHPINFO-im7    |    4 +-
 REFLECTION-im7 | 2296 +++++++++++++++++++++++++++++++++++++-------------------
 3 files changed, 1512 insertions(+), 792 deletions(-)

diff --git a/PHPINFO-im6 b/PHPINFO-im6
index f1d1679..676a762 100644
--- a/PHPINFO-im6
+++ b/PHPINFO-im6
@@ -5,9 +5,9 @@ imagick module => enabled
 imagick module version => 3.6.0
 imagick classes => Imagick, ImagickDraw, ImagickPixel, ImagickPixelIterator, ImagickKernel
 Imagick compiled with ImageMagick version => ImageMagick 6.9.12-29 Q16 x86_64 2021-11-14 https://imagemagick.org
-Imagick using ImageMagick library version => ImageMagick 6.9.12-29 Q16 x86_64 2021-11-14 https://imagemagick.org
+Imagick using ImageMagick library version => ImageMagick 6.9.12-30 Q16 x86_64 2021-11-20 https://imagemagick.org
 ImageMagick copyright => (C) 1999-2021 ImageMagick Studio LLC
-ImageMagick release date => 2021-11-14
+ImageMagick release date => 2021-11-20
 ImageMagick number of supported formats:  => 247
 ImageMagick supported formats => 3FR, 3G2, 3GP, AAI, AI, APNG, ART, ARW, AVI, AVIF, AVS, BGR, BGRA, BGRO, BIE, BMP, BMP2, BMP3, BRF, CAL, CALS, CANVAS, CAPTION, CIN, CIP, CLIP, CMYK, CMYKA, CR2, CR3, CRW, CUR, CUT, DATA, DCM, DCR, DCX, DDS, DFONT, DJVU, DNG, DOT, DPX, DXT1, DXT5, EPDF, EPI, EPS, EPS2, EPS3, EPSF, EPSI, EPT, EPT2, EPT3, ERF, EXR, FAX, FILE, FITS, FRACTAL, FTP, FTS, G3, G4, GIF, GIF87, GRADIENT, GRAY, GRAYA, GROUP4, GV, H, HALD, HDR, HEIC, HISTOGRAM, HRZ, HTM, HTML, HTTP, HTTPS, ICB, ICO, ICON, IIQ, INFO, INLINE, IPL, ISOBRL, ISOBRL6, J2C, J2K, JBG, JBIG, JNG, JNX, JP2, JPC, JPE, JPEG, JPG, JPM, JPS, JPT, JSON, K25, KDC, LABEL, M2V, M4V, MAC, MAGICK, MAP, MASK, MAT, MATTE, MEF, MIFF, MKV, MNG, MONO, MOV, MP4, MPC, MPG, MRW, MSL, MSVG, MTV, MVG, NEF, NRW, NULL, ORF, OTB, OTF, PAL, PALM, PAM, PANGO, PATTERN, PBM, PCD, PCDS, PCL, PCT, PCX, PDB, PDF, PDFA, PEF, PES, PFA, PFB, PFM, PGM, PGX, PICON, PICT, PIX, PJPEG, PLASMA, PNG, PNG00, PNG24, PNG32, PNG48, PNG64, PNG8, PNM, POCKETMOD, PPM, PREVIEW, PS, PS2, PS3, PSB, PSD, PTIF, PWP, RADIAL-GRADIENT, RAF, RAS, RAW, RGB, RGBA, RGBO, RGF, RLA, RLE, RMF, RW2, SCR, SCT, SFW, SGI, SHTML, SIX, SIXEL, SPARSE-COLOR, SR2, SRF, STEGANO, SUN, SVG, SVGZ, TEXT, TGA, THUMBNAIL, TIFF, TIFF64, TILE, TIM, TTC, TTF, TXT, UBRL, UBRL6, UIL, UYVY, VDA, VICAR, VID, VIDEO, VIFF, VIPS, VST, WBMP, WEBM, WEBP, WMF, WMV, WMZ, WPG, X, X3F, XBM, XC, XCF, XPM, XPS, XV, XWD, YCbCr, YCbCrA, YUV
 
diff --git a/PHPINFO-im7 b/PHPINFO-im7
index 0b4dbe1..f1ae8b4 100644
--- a/PHPINFO-im7
+++ b/PHPINFO-im7
@@ -5,9 +5,9 @@ imagick module => enabled
 imagick module version => 3.6.0
 imagick classes => Imagick, ImagickDraw, ImagickPixel, ImagickPixelIterator, ImagickKernel
 Imagick compiled with ImageMagick version => ImageMagick 7.1.0-14 Q16-HDRI x86_64 2021-11-14 https://imagemagick.org
-Imagick using ImageMagick library version => ImageMagick 7.1.0-14 Q16-HDRI x86_64 2021-11-14 https://imagemagick.org
+Imagick using ImageMagick library version => ImageMagick 7.1.0-15 Q16-HDRI x86_64 2021-11-20 https://imagemagick.org
 ImageMagick copyright => (C) 1999-2021 ImageMagick Studio LLC
-ImageMagick release date => 2021-11-14
+ImageMagick release date => 2021-11-20
 ImageMagick number of supported formats:  => 259
 ImageMagick supported formats => 3FR, 3G2, 3GP, AAI, AI, APNG, ART, ARW, ASHLAR, AVI, AVIF, AVS, BGR, BGRA, BGRO, BIE, BMP, BMP2, BMP3, BRF, CAL, CALS, CANVAS, CAPTION, CIN, CIP, CLIP, CMYK, CMYKA, CR2, CR3, CRW, CUBE, CUR, CUT, DATA, DCM, DCR, DCRAW, DCX, DDS, DFONT, DJVU, DNG, DOT, DPX, DXT1, DXT5, EPDF, EPI, EPS, EPS2, EPS3, EPSF, EPSI, EPT, EPT2, EPT3, ERF, EXR, FARBFELD, FAX, FF, FILE, FITS, FL32, FLV, FRACTAL, FTP, FTS, G3, G4, GIF, GIF87, GRADIENT, GRAY, GRAYA, GROUP4, GV, HALD, HDR, HEIC, HEIF, HISTOGRAM, HRZ, HTM, HTML, HTTP, HTTPS, ICB, ICO, ICON, IIQ, INFO, INLINE, IPL, ISOBRL, ISOBRL6, J2C, J2K, JBG, JBIG, JNG, JNX, JP2, JPC, JPE, JPEG, JPG, JPM, JPS, JPT, JSON, K25, KDC, KERNEL, LABEL, M2V, M4V, MAC, MAP, MASK, MAT, MATTE, MEF, MIFF, MKV, MNG, MONO, MOV, MP4, MPC, MPEG, MPG, MRW, MSL, MSVG, MTV, MVG, NEF, NRW, NULL, ORA, ORF, OTB, OTF, PAL, PALM, PAM, PANGO, PATTERN, PBM, PCD, PCDS, PCL, PCT, PCX, PDB, PDF, PDFA, PEF, PES, PFA, PFB, PFM, PGM, PGX, PHM, PICON, PICT, PIX, PJPEG, PLASMA, PNG, PNG00, PNG24, PNG32, PNG48, PNG64, PNG8, PNM, POCKETMOD, PPM, PS, PS2, PS3, PSB, PSD, PTIF, PWP, RADIAL-GRADIENT, RAF, RAS, RAW, RGB, RGB565, RGBA, RGBO, RGF, RLA, RLE, RMF, RSVG, RW2, SCR, SCT, SFW, SGI, SHTML, SIX, SIXEL, SPARSE-COLOR, SR2, SRF, STEGANO, SUN, SVG, SVGZ, TEXT, TGA, THUMBNAIL, TIFF, TIFF64, TILE, TIM, TM2, TTC, TTF, TXT, UBRL, UBRL6, UIL, UYVY, VDA, VICAR, VID, VIFF, VIPS, VST, WBMP, WEBM, WEBP, WMF, WMV, WMZ, WPG, X, X3F, XBM, XC, XCF, XPM, XPS, XV, XWD, YAML, YCbCr, YCbCrA, YUV
 
diff --git a/REFLECTION-im7 b/REFLECTION-im7
index 6cbce9f..5b75617 100644
--- a/REFLECTION-im7
+++ b/REFLECTION-im7
@@ -1,4 +1,4 @@
-Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
+Extension [ <persistent> extension #78 imagick version 3.6.0 ] {
 
   - Dependencies {
     Dependency [ gmagick (Conflicts) ]
@@ -28,7 +28,7 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
   }
 
   - Classes [10] {
-    Class [ <internal:imagick> class ImagickException extends Exception implements Throwable ] {
+    Class [ <internal:imagick> class ImagickException extends Exception implements Stringable, Throwable ] {
 
       - Constants [0] {
       }
@@ -40,52 +40,86 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
       }
 
       - Properties [4] {
-        Property [ <default> protected $message ]
-        Property [ <default> protected $code ]
-        Property [ <default> protected $file ]
-        Property [ <default> protected $line ]
+        Property [ protected $message = '' ]
+        Property [ protected $code = 0 ]
+        Property [ protected $file = NULL ]
+        Property [ protected $line = NULL ]
       }
 
       - Methods [10] {
         Method [ <internal:Core, inherits Exception, ctor> public method __construct ] {
 
           - Parameters [3] {
-            Parameter #0 [ <optional> $message ]
-            Parameter #1 [ <optional> $code ]
-            Parameter #2 [ <optional> $previous ]
+            Parameter #0 [ <optional> string $message = "" ]
+            Parameter #1 [ <optional> int $code = 0 ]
+            Parameter #2 [ <optional> ?Throwable $previous = null ]
           }
         }
 
         Method [ <internal:Core, inherits Exception> public method __wakeup ] {
+
+          - Parameters [0] {
+          }
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getMessage ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getCode ] {
+
+          - Parameters [0] {
+          }
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getFile ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getLine ] {
+
+          - Parameters [0] {
+          }
+          - Return [ int ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getTrace ] {
+
+          - Parameters [0] {
+          }
+          - Return [ array ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getPrevious ] {
+
+          - Parameters [0] {
+          }
+          - Return [ ?Throwable ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getTraceAsString ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
 
-        Method [ <internal:Core, inherits Exception, prototype Throwable> public method __toString ] {
+        Method [ <internal:Core, inherits Exception, prototype Stringable> public method __toString ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
       }
     }
 
-    Class [ <internal:imagick> class ImagickDrawException extends Exception implements Throwable ] {
+    Class [ <internal:imagick> class ImagickDrawException extends Exception implements Stringable, Throwable ] {
 
       - Constants [0] {
       }
@@ -97,52 +131,86 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
       }
 
       - Properties [4] {
-        Property [ <default> protected $message ]
-        Property [ <default> protected $code ]
-        Property [ <default> protected $file ]
-        Property [ <default> protected $line ]
+        Property [ protected $message = '' ]
+        Property [ protected $code = 0 ]
+        Property [ protected $file = NULL ]
+        Property [ protected $line = NULL ]
       }
 
       - Methods [10] {
         Method [ <internal:Core, inherits Exception, ctor> public method __construct ] {
 
           - Parameters [3] {
-            Parameter #0 [ <optional> $message ]
-            Parameter #1 [ <optional> $code ]
-            Parameter #2 [ <optional> $previous ]
+            Parameter #0 [ <optional> string $message = "" ]
+            Parameter #1 [ <optional> int $code = 0 ]
+            Parameter #2 [ <optional> ?Throwable $previous = null ]
           }
         }
 
         Method [ <internal:Core, inherits Exception> public method __wakeup ] {
+
+          - Parameters [0] {
+          }
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getMessage ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getCode ] {
+
+          - Parameters [0] {
+          }
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getFile ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getLine ] {
+
+          - Parameters [0] {
+          }
+          - Return [ int ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getTrace ] {
+
+          - Parameters [0] {
+          }
+          - Return [ array ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getPrevious ] {
+
+          - Parameters [0] {
+          }
+          - Return [ ?Throwable ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getTraceAsString ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
 
-        Method [ <internal:Core, inherits Exception, prototype Throwable> public method __toString ] {
+        Method [ <internal:Core, inherits Exception, prototype Stringable> public method __toString ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
       }
     }
 
-    Class [ <internal:imagick> class ImagickPixelIteratorException extends Exception implements Throwable ] {
+    Class [ <internal:imagick> class ImagickPixelIteratorException extends Exception implements Stringable, Throwable ] {
 
       - Constants [0] {
       }
@@ -154,52 +222,86 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
       }
 
       - Properties [4] {
-        Property [ <default> protected $message ]
-        Property [ <default> protected $code ]
-        Property [ <default> protected $file ]
-        Property [ <default> protected $line ]
+        Property [ protected $message = '' ]
+        Property [ protected $code = 0 ]
+        Property [ protected $file = NULL ]
+        Property [ protected $line = NULL ]
       }
 
       - Methods [10] {
         Method [ <internal:Core, inherits Exception, ctor> public method __construct ] {
 
           - Parameters [3] {
-            Parameter #0 [ <optional> $message ]
-            Parameter #1 [ <optional> $code ]
-            Parameter #2 [ <optional> $previous ]
+            Parameter #0 [ <optional> string $message = "" ]
+            Parameter #1 [ <optional> int $code = 0 ]
+            Parameter #2 [ <optional> ?Throwable $previous = null ]
           }
         }
 
         Method [ <internal:Core, inherits Exception> public method __wakeup ] {
+
+          - Parameters [0] {
+          }
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getMessage ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getCode ] {
+
+          - Parameters [0] {
+          }
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getFile ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getLine ] {
+
+          - Parameters [0] {
+          }
+          - Return [ int ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getTrace ] {
+
+          - Parameters [0] {
+          }
+          - Return [ array ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getPrevious ] {
+
+          - Parameters [0] {
+          }
+          - Return [ ?Throwable ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getTraceAsString ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
 
-        Method [ <internal:Core, inherits Exception, prototype Throwable> public method __toString ] {
+        Method [ <internal:Core, inherits Exception, prototype Stringable> public method __toString ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
       }
     }
 
-    Class [ <internal:imagick> class ImagickPixelException extends Exception implements Throwable ] {
+    Class [ <internal:imagick> class ImagickPixelException extends Exception implements Stringable, Throwable ] {
 
       - Constants [0] {
       }
@@ -211,52 +313,86 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
       }
 
       - Properties [4] {
-        Property [ <default> protected $message ]
-        Property [ <default> protected $code ]
-        Property [ <default> protected $file ]
-        Property [ <default> protected $line ]
+        Property [ protected $message = '' ]
+        Property [ protected $code = 0 ]
+        Property [ protected $file = NULL ]
+        Property [ protected $line = NULL ]
       }
 
       - Methods [10] {
         Method [ <internal:Core, inherits Exception, ctor> public method __construct ] {
 
           - Parameters [3] {
-            Parameter #0 [ <optional> $message ]
-            Parameter #1 [ <optional> $code ]
-            Parameter #2 [ <optional> $previous ]
+            Parameter #0 [ <optional> string $message = "" ]
+            Parameter #1 [ <optional> int $code = 0 ]
+            Parameter #2 [ <optional> ?Throwable $previous = null ]
           }
         }
 
         Method [ <internal:Core, inherits Exception> public method __wakeup ] {
+
+          - Parameters [0] {
+          }
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getMessage ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getCode ] {
+
+          - Parameters [0] {
+          }
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getFile ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getLine ] {
+
+          - Parameters [0] {
+          }
+          - Return [ int ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getTrace ] {
+
+          - Parameters [0] {
+          }
+          - Return [ array ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getPrevious ] {
+
+          - Parameters [0] {
+          }
+          - Return [ ?Throwable ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getTraceAsString ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
 
-        Method [ <internal:Core, inherits Exception, prototype Throwable> public method __toString ] {
+        Method [ <internal:Core, inherits Exception, prototype Stringable> public method __toString ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
       }
     }
 
-    Class [ <internal:imagick> class ImagickKernelException extends Exception implements Throwable ] {
+    Class [ <internal:imagick> class ImagickKernelException extends Exception implements Stringable, Throwable ] {
 
       - Constants [0] {
       }
@@ -268,47 +404,81 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
       }
 
       - Properties [4] {
-        Property [ <default> protected $message ]
-        Property [ <default> protected $code ]
-        Property [ <default> protected $file ]
-        Property [ <default> protected $line ]
+        Property [ protected $message = '' ]
+        Property [ protected $code = 0 ]
+        Property [ protected $file = NULL ]
+        Property [ protected $line = NULL ]
       }
 
       - Methods [10] {
         Method [ <internal:Core, inherits Exception, ctor> public method __construct ] {
 
           - Parameters [3] {
-            Parameter #0 [ <optional> $message ]
-            Parameter #1 [ <optional> $code ]
-            Parameter #2 [ <optional> $previous ]
+            Parameter #0 [ <optional> string $message = "" ]
+            Parameter #1 [ <optional> int $code = 0 ]
+            Parameter #2 [ <optional> ?Throwable $previous = null ]
           }
         }
 
         Method [ <internal:Core, inherits Exception> public method __wakeup ] {
+
+          - Parameters [0] {
+          }
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getMessage ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getCode ] {
+
+          - Parameters [0] {
+          }
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getFile ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getLine ] {
+
+          - Parameters [0] {
+          }
+          - Return [ int ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getTrace ] {
+
+          - Parameters [0] {
+          }
+          - Return [ array ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getPrevious ] {
+
+          - Parameters [0] {
+          }
+          - Return [ ?Throwable ]
         }
 
         Method [ <internal:Core, inherits Exception, prototype Throwable> final public method getTraceAsString ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
 
-        Method [ <internal:Core, inherits Exception, prototype Throwable> public method __toString ] {
+        Method [ <internal:Core, inherits Exception, prototype Stringable> public method __toString ] {
+
+          - Parameters [0] {
+          }
+          - Return [ string ]
         }
       }
     }
@@ -940,143 +1110,164 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
         Method [ <internal:imagick> static public method queryFormats ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $pattern ]
+            Parameter #0 [ <optional> string $pattern = "*" ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> static public method queryFonts ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $pattern ]
+            Parameter #0 [ <optional> string $pattern = "*" ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> static public method calculateCrop ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $original_width ]
-            Parameter #1 [ <required> $original_height ]
-            Parameter #2 [ <required> $desired_width ]
-            Parameter #3 [ <required> $desired_height ]
-            Parameter #4 [ <optional> $legacy ]
+            Parameter #0 [ <required> int $original_width ]
+            Parameter #1 [ <required> int $original_height ]
+            Parameter #2 [ <required> int $desired_width ]
+            Parameter #3 [ <required> int $desired_height ]
+            Parameter #4 [ <optional> bool $legacy = false ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> static public method getCopyright ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> static public method getConfigureOptions ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $pattern ]
+            Parameter #0 [ <optional> string $pattern = "*" ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> static public method getFeatures ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> static public method getHomeURL ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> static public method getPackageName ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> static public method getQuantum ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> static public method getHdriEnabled ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> static public method getQuantumDepth ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> static public method getQuantumRange ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> static public method getReleaseDate ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> static public method getResource ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $type ]
+            Parameter #0 [ <required> int $type ]
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> static public method getResourceLimit ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $type ]
+            Parameter #0 [ <required> int $type ]
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> static public method getVersion ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> static public method setResourceLimit ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $type ]
-            Parameter #1 [ <required> $limit ]
+            Parameter #0 [ <required> int $type ]
+            Parameter #1 [ <required> int $limit ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> static public method setRegistry ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $value ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> static public method getRegistry ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> static public method listRegistry ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> static public method setSeed ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $seed ]
+            Parameter #0 [ <required> int $seed ]
           }
+          - Return [ void ]
         }
       }
 
@@ -1088,664 +1279,748 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method compareImageLayers ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $metric ]
+            Parameter #0 [ <required> int $metric ]
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method pingImageBlob ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $image ]
+            Parameter #0 [ <required> string $image ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pingImageFile ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $filehandle ]
-            Parameter #1 [ <optional> $filename ]
+            Parameter #0 [ <required> mixed $filehandle ]
+            Parameter #1 [ <optional> ?string $filename = null ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method transposeImage ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method transverseImage ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method trimImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $fuzz ]
+            Parameter #0 [ <required> float $fuzz ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method waveImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $amplitude ]
-            Parameter #1 [ <required> $length ]
+            Parameter #0 [ <required> float $amplitude ]
+            Parameter #1 [ <required> float $length ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method vignetteImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $black_point ]
-            Parameter #1 [ <required> $white_point ]
-            Parameter #2 [ <required> $x ]
-            Parameter #3 [ <required> $y ]
+            Parameter #0 [ <required> float $black_point ]
+            Parameter #1 [ <required> float $white_point ]
+            Parameter #2 [ <required> int $x ]
+            Parameter #3 [ <required> int $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method uniqueImageColors ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageMatte ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $matte ]
+            Parameter #0 [ <required> bool $matte ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method adaptiveResizeImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $columns ]
-            Parameter #1 [ <required> $rows ]
-            Parameter #2 [ <optional> $bestfit ]
-            Parameter #3 [ <optional> $legacy ]
+            Parameter #0 [ <required> int $columns ]
+            Parameter #1 [ <required> int $rows ]
+            Parameter #2 [ <optional> bool $bestfit = false ]
+            Parameter #3 [ <optional> bool $legacy = false ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method sketchImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $radius ]
-            Parameter #1 [ <required> $sigma ]
-            Parameter #2 [ <required> $angle ]
+            Parameter #0 [ <required> float $radius ]
+            Parameter #1 [ <required> float $sigma ]
+            Parameter #2 [ <required> float $angle ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method shadeImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $gray ]
-            Parameter #1 [ <required> $azimuth ]
-            Parameter #2 [ <required> $elevation ]
+            Parameter #0 [ <required> bool $gray ]
+            Parameter #1 [ <required> float $azimuth ]
+            Parameter #2 [ <required> float $elevation ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getSizeOffset ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method setSizeOffset ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $columns ]
-            Parameter #1 [ <required> $rows ]
-            Parameter #2 [ <required> $offset ]
+            Parameter #0 [ <required> int $columns ]
+            Parameter #1 [ <required> int $rows ]
+            Parameter #2 [ <required> int $offset ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method adaptiveBlurImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $radius ]
-            Parameter #1 [ <required> $sigma ]
-            Parameter #2 [ <optional> $channel ]
+            Parameter #0 [ <required> float $radius ]
+            Parameter #1 [ <required> float $sigma ]
+            Parameter #2 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method contrastStretchImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $black_point ]
-            Parameter #1 [ <required> $white_point ]
-            Parameter #2 [ <optional> $channel ]
+            Parameter #0 [ <required> float $black_point ]
+            Parameter #1 [ <required> float $white_point ]
+            Parameter #2 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method adaptiveSharpenImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $radius ]
-            Parameter #1 [ <required> $sigma ]
-            Parameter #2 [ <optional> $channel ]
+            Parameter #0 [ <required> float $radius ]
+            Parameter #1 [ <required> float $sigma ]
+            Parameter #2 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method randomThresholdImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $low ]
-            Parameter #1 [ <required> $high ]
-            Parameter #2 [ <optional> $channel ]
+            Parameter #0 [ <required> float $low ]
+            Parameter #1 [ <required> float $high ]
+            Parameter #2 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method roundCornersImage ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $x_rounding ]
-            Parameter #1 [ <required> $y_rounding ]
-            Parameter #2 [ <optional> $stroke_width ]
-            Parameter #3 [ <optional> $displace ]
-            Parameter #4 [ <optional> $size_correction ]
+            Parameter #0 [ <required> float $x_rounding ]
+            Parameter #1 [ <required> float $y_rounding ]
+            Parameter #2 [ <optional> float $stroke_width = 10 ]
+            Parameter #3 [ <optional> float $displace = 5 ]
+            Parameter #4 [ <optional> float $size_correction = -6 ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method roundCorners ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $x_rounding ]
-            Parameter #1 [ <required> $y_rounding ]
-            Parameter #2 [ <optional> $stroke_width ]
-            Parameter #3 [ <optional> $displace ]
-            Parameter #4 [ <optional> $size_correction ]
+            Parameter #0 [ <required> float $x_rounding ]
+            Parameter #1 [ <required> float $y_rounding ]
+            Parameter #2 [ <optional> float $stroke_width = 10 ]
+            Parameter #3 [ <optional> float $displace = 5 ]
+            Parameter #4 [ <optional> float $size_correction = -6 ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setIteratorIndex ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $index ]
+            Parameter #0 [ <required> int $index ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getIteratorIndex ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method setImageAlpha ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $alpha ]
+            Parameter #0 [ <required> float $alpha ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method polaroidImage ] {
 
           - Parameters [2] {
             Parameter #0 [ <required> ImagickDraw $settings ]
-            Parameter #1 [ <required> $angle ]
+            Parameter #1 [ <required> float $angle ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getImageProperty ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $name ]
+            Parameter #0 [ <required> string $name ]
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method setImageProperty ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $name ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $name ]
+            Parameter #1 [ <required> string $value ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method deleteImageProperty ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $name ]
+            Parameter #0 [ <required> string $name ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method identifyFormat ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $format ]
+            Parameter #0 [ <required> string $format ]
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method setImageInterpolateMethod ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $method ]
+            Parameter #0 [ <required> int $method ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getImageInterpolateMethod ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method linearStretchImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $black_point ]
-            Parameter #1 [ <required> $white_point ]
+            Parameter #0 [ <required> float $black_point ]
+            Parameter #1 [ <required> float $white_point ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getImageLength ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method extentImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $width ]
-            Parameter #1 [ <required> $height ]
-            Parameter #2 [ <required> $x ]
-            Parameter #3 [ <required> $y ]
+            Parameter #0 [ <required> int $width ]
+            Parameter #1 [ <required> int $height ]
+            Parameter #2 [ <required> int $x ]
+            Parameter #3 [ <required> int $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getImageOrientation ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method setImageOrientation ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $orientation ]
+            Parameter #0 [ <required> int $orientation ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method clutImage ] {
 
           - Parameters [2] {
             Parameter #0 [ <required> Imagick $lookup_table ]
-            Parameter #1 [ <optional> $channel ]
+            Parameter #1 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getImageProperties ] {
 
           - Parameters [2] {
-            Parameter #0 [ <optional> $pattern ]
-            Parameter #1 [ <optional> $include_values ]
+            Parameter #0 [ <optional> string $pattern = "*" ]
+            Parameter #1 [ <optional> bool $include_values = true ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getImageProfiles ] {
 
           - Parameters [2] {
-            Parameter #0 [ <optional> $pattern ]
-            Parameter #1 [ <optional> $include_values ]
+            Parameter #0 [ <optional> string $pattern = "*" ]
+            Parameter #1 [ <optional> bool $include_values = true ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method distortImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $distortion ]
-            Parameter #1 [ <required> $arguments ]
-            Parameter #2 [ <required> $bestfit ]
+            Parameter #0 [ <required> int $distortion ]
+            Parameter #1 [ <required> array $arguments ]
+            Parameter #2 [ <required> bool $bestfit ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method writeImageFile ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $filehandle ]
-            Parameter #1 [ <optional> $format ]
+            Parameter #0 [ <required> mixed $filehandle ]
+            Parameter #1 [ <optional> ?string $format = null ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method writeImagesFile ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $filehandle ]
-            Parameter #1 [ <optional> $format ]
+            Parameter #0 [ <required> mixed $filehandle ]
+            Parameter #1 [ <optional> ?string $format = null ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method resetImagePage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $page ]
+            Parameter #0 [ <required> string $page ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method animateImages ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $x_server ]
+            Parameter #0 [ <required> string $x_server ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setFont ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $font ]
+            Parameter #0 [ <required> string $font ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getFont ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method setPointSize ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $point_size ]
+            Parameter #0 [ <required> float $point_size ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getPointSize ] {
 
           - Parameters [0] {
           }
+          - Return [ float ]
         }
 
         Method [ <internal:imagick> public method mergeImageLayers ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $layermethod ]
+            Parameter #0 [ <required> int $layermethod ]
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method setImageAlphaChannel ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $alphachannel ]
+            Parameter #0 [ <required> int $alphachannel ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method floodfillPaintImage ] {
 
           - Parameters [7] {
-            Parameter #0 [ <required> $fill_color ]
-            Parameter #1 [ <required> $fuzz ]
-            Parameter #2 [ <required> $border_color ]
-            Parameter #3 [ <required> $x ]
-            Parameter #4 [ <required> $y ]
-            Parameter #5 [ <required> $invert ]
-            Parameter #6 [ <optional> $channel ]
+            Parameter #0 [ <required> ImagickPixel|string $fill_color ]
+            Parameter #1 [ <required> float $fuzz ]
+            Parameter #2 [ <required> ImagickPixel|string $border_color ]
+            Parameter #3 [ <required> int $x ]
+            Parameter #4 [ <required> int $y ]
+            Parameter #5 [ <required> bool $invert ]
+            Parameter #6 [ <optional> ?int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method opaquePaintImage ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $target_color ]
-            Parameter #1 [ <required> $fill_color ]
-            Parameter #2 [ <required> $fuzz ]
-            Parameter #3 [ <required> $invert ]
-            Parameter #4 [ <optional> $channel ]
+            Parameter #0 [ <required> ImagickPixel|string $target_color ]
+            Parameter #1 [ <required> ImagickPixel|string $fill_color ]
+            Parameter #2 [ <required> float $fuzz ]
+            Parameter #3 [ <required> bool $invert ]
+            Parameter #4 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method transparentPaintImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $target_color ]
-            Parameter #1 [ <required> $alpha ]
-            Parameter #2 [ <required> $fuzz ]
-            Parameter #3 [ <required> $invert ]
+            Parameter #0 [ <required> ImagickPixel|string $target_color ]
+            Parameter #1 [ <required> float $alpha ]
+            Parameter #2 [ <required> float $fuzz ]
+            Parameter #3 [ <required> bool $invert ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method liquidRescaleImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $width ]
-            Parameter #1 [ <required> $height ]
-            Parameter #2 [ <required> $delta_x ]
-            Parameter #3 [ <required> $rigidity ]
+            Parameter #0 [ <required> int $width ]
+            Parameter #1 [ <required> int $height ]
+            Parameter #2 [ <required> float $delta_x ]
+            Parameter #3 [ <required> float $rigidity ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method encipherImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $passphrase ]
+            Parameter #0 [ <required> string $passphrase ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method decipherImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $passphrase ]
+            Parameter #0 [ <required> string $passphrase ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setGravity ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $gravity ]
+            Parameter #0 [ <required> int $gravity ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getGravity ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageChannelRange ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $channel ]
+            Parameter #0 [ <required> int $channel ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getImageAlphaChannel ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getImageChannelDistortions ] {
 
           - Parameters [3] {
             Parameter #0 [ <required> Imagick $reference_image ]
-            Parameter #1 [ <required> $metric ]
-            Parameter #2 [ <optional> $channel ]
+            Parameter #1 [ <required> int $metric ]
+            Parameter #2 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ float ]
         }
 
         Method [ <internal:imagick> public method setImageGravity ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $gravity ]
+            Parameter #0 [ <required> int $gravity ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getImageGravity ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method importImagePixels ] {
 
           - Parameters [7] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
-            Parameter #2 [ <required> $width ]
-            Parameter #3 [ <required> $height ]
-            Parameter #4 [ <required> $map ]
-            Parameter #5 [ <required> $pixelstorage ]
-            Parameter #6 [ <required> $pixels ]
+            Parameter #0 [ <required> int $x ]
+            Parameter #1 [ <required> int $y ]
+            Parameter #2 [ <required> int $width ]
+            Parameter #3 [ <required> int $height ]
+            Parameter #4 [ <required> string $map ]
+            Parameter #5 [ <required> int $pixelstorage ]
+            Parameter #6 [ <required> array $pixels ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method deskewImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $threshold ]
+            Parameter #0 [ <required> float $threshold ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method segmentImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $colorspace ]
-            Parameter #1 [ <required> $cluster_threshold ]
-            Parameter #2 [ <required> $smooth_threshold ]
-            Parameter #3 [ <optional> $verbose ]
+            Parameter #0 [ <required> int $colorspace ]
+            Parameter #1 [ <required> float $cluster_threshold ]
+            Parameter #2 [ <required> float $smooth_threshold ]
+            Parameter #3 [ <optional> bool $verbose = false ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method sparseColorImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $sparsecolormethod ]
-            Parameter #1 [ <required> $arguments ]
-            Parameter #2 [ <optional> $channel ]
+            Parameter #0 [ <required> int $sparsecolormethod ]
+            Parameter #1 [ <required> array $arguments ]
+            Parameter #2 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method remapImage ] {
 
           - Parameters [2] {
             Parameter #0 [ <required> Imagick $replacement ]
-            Parameter #1 [ <required> $dither_method ]
+            Parameter #1 [ <required> int $dither_method ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method houghLineImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $width ]
-            Parameter #1 [ <required> $height ]
-            Parameter #2 [ <required> $threshold ]
+            Parameter #0 [ <required> int $width ]
+            Parameter #1 [ <required> int $height ]
+            Parameter #2 [ <required> float $threshold ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method exportImagePixels ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
-            Parameter #2 [ <required> $width ]
-            Parameter #3 [ <required> $height ]
-            Parameter #4 [ <required> $map ]
-            Parameter #5 [ <required> $pixelstorage ]
+            Parameter #0 [ <required> int $x ]
+            Parameter #1 [ <required> int $y ]
+            Parameter #2 [ <required> int $width ]
+            Parameter #3 [ <required> int $height ]
+            Parameter #4 [ <required> string $map ]
+            Parameter #5 [ <required> int $pixelstorage ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getImageChannelKurtosis ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $channel ]
+            Parameter #0 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method functionImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $function ]
-            Parameter #1 [ <required> $parameters ]
-            Parameter #2 [ <optional> $channel ]
+            Parameter #0 [ <required> int $function ]
+            Parameter #1 [ <required> array $parameters ]
+            Parameter #2 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method transformImageColorspace ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $colorspace ]
+            Parameter #0 [ <required> int $colorspace ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method haldClutImage ] {
 
           - Parameters [2] {
             Parameter #0 [ <required> Imagick $clut ]
-            Parameter #1 [ <optional> $channel ]
+            Parameter #1 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method autoLevelImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $channel ]
+            Parameter #0 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method blueShiftImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $factor ]
+            Parameter #0 [ <optional> float $factor = 1.5 ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getImageArtifact ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $artifact ]
+            Parameter #0 [ <required> string $artifact ]
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method setImageArtifact ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $artifact ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $artifact ]
+            Parameter #1 [ <required> string $value ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method deleteImageArtifact ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $artifact ]
+            Parameter #0 [ <required> string $artifact ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getColorspace ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method setColorspace ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $colorspace ]
+            Parameter #0 [ <required> int $colorspace ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method clampImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $channel ]
+            Parameter #0 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method smushImages ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $stack ]
-            Parameter #1 [ <required> $offset ]
+            Parameter #0 [ <required> bool $stack ]
+            Parameter #1 [ <required> int $offset ]
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick, ctor> public method __construct ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $files ]
+            Parameter #0 [ <optional> array|string|int|float|null $files = null ]
           }
         }
 
@@ -1753,264 +2028,302 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick, prototype Countable> public method count ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $mode ]
+            Parameter #0 [ <optional> int $mode = 0 ]
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getPixelIterator ] {
 
           - Parameters [0] {
           }
+          - Return [ ImagickPixelIterator ]
         }
 
         Method [ <internal:imagick> public method getPixelRegionIterator ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
-            Parameter #2 [ <required> $columns ]
-            Parameter #3 [ <required> $rows ]
+            Parameter #0 [ <required> int $x ]
+            Parameter #1 [ <required> int $y ]
+            Parameter #2 [ <required> int $columns ]
+            Parameter #3 [ <required> int $rows ]
           }
+          - Return [ ImagickPixelIterator ]
         }
 
         Method [ <internal:imagick> public method readImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $filename ]
+            Parameter #0 [ <required> string $filename ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method readImages ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $filenames ]
+            Parameter #0 [ <required> array $filenames ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method readImageBlob ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $image ]
-            Parameter #1 [ <optional> $filename ]
+            Parameter #0 [ <required> string $image ]
+            Parameter #1 [ <optional> ?string $filename = null ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageFormat ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $format ]
+            Parameter #0 [ <required> string $format ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method scaleImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $columns ]
-            Parameter #1 [ <required> $rows ]
-            Parameter #2 [ <optional> $bestfit ]
-            Parameter #3 [ <optional> $legacy ]
+            Parameter #0 [ <required> int $columns ]
+            Parameter #1 [ <required> int $rows ]
+            Parameter #2 [ <optional> bool $bestfit = false ]
+            Parameter #3 [ <optional> bool $legacy = false ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method writeImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $filename ]
+            Parameter #0 [ <optional> ?string $filename = null ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method writeImages ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $filename ]
-            Parameter #1 [ <required> $adjoin ]
+            Parameter #0 [ <required> string $filename ]
+            Parameter #1 [ <required> bool $adjoin ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method blurImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $radius ]
-            Parameter #1 [ <required> $sigma ]
-            Parameter #2 [ <optional> $channel ]
+            Parameter #0 [ <required> float $radius ]
+            Parameter #1 [ <required> float $sigma ]
+            Parameter #2 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method thumbnailImage ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $columns ]
-            Parameter #1 [ <required> $rows ]
-            Parameter #2 [ <optional> $bestfit ]
-            Parameter #3 [ <optional> $fill ]
-            Parameter #4 [ <optional> $legacy ]
+            Parameter #0 [ <required> ?int $columns ]
+            Parameter #1 [ <required> ?int $rows ]
+            Parameter #2 [ <optional> bool $bestfit = false ]
+            Parameter #3 [ <optional> bool $fill = false ]
+            Parameter #4 [ <optional> bool $legacy = false ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method cropThumbnailImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $width ]
-            Parameter #1 [ <required> $height ]
-            Parameter #2 [ <optional> $legacy ]
+            Parameter #0 [ <required> int $width ]
+            Parameter #1 [ <required> int $height ]
+            Parameter #2 [ <optional> bool $legacy = false ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getImageFilename ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method setImageFilename ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $filename ]
+            Parameter #0 [ <required> string $filename ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getImageFormat ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method getImageMimeType ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method removeImage ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method destroy ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method clear ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method clone ] {
 
           - Parameters [0] {
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method getImageSize ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageBlob ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method getImagesBlob ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method setFirstIterator ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setLastIterator ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method resetIterator ] {
 
           - Parameters [0] {
           }
+          - Return [ void ]
         }
 
         Method [ <internal:imagick> public method previousImage ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method nextImage ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method hasPreviousImage ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method hasNextImage ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageIndex ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $index ]
+            Parameter #0 [ <required> int $index ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getImageIndex ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method commentImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $comment ]
+            Parameter #0 [ <required> string $comment ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method cropImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $width ]
-            Parameter #1 [ <required> $height ]
-            Parameter #2 [ <required> $x ]
-            Parameter #3 [ <required> $y ]
+            Parameter #0 [ <required> int $width ]
+            Parameter #1 [ <required> int $height ]
+            Parameter #2 [ <required> int $x ]
+            Parameter #3 [ <required> int $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method labelImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $label ]
+            Parameter #0 [ <required> string $label ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getImageGeometry ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method drawImage ] {
@@ -2018,487 +2331,549 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
           - Parameters [1] {
             Parameter #0 [ <required> ImagickDraw $drawing ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageCompressionQuality ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $quality ]
+            Parameter #0 [ <required> int $quality ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getImageCompressionQuality ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method setImageCompression ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $compression ]
+            Parameter #0 [ <required> int $compression ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getImageCompression ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method annotateImage ] {
 
           - Parameters [5] {
             Parameter #0 [ <required> ImagickDraw $settings ]
-            Parameter #1 [ <required> $x ]
-            Parameter #2 [ <required> $y ]
-            Parameter #3 [ <required> $angle ]
-            Parameter #4 [ <required> $text ]
+            Parameter #1 [ <required> float $x ]
+            Parameter #2 [ <required> float $y ]
+            Parameter #3 [ <required> float $angle ]
+            Parameter #4 [ <required> string $text ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method compositeImage ] {
 
           - Parameters [5] {
             Parameter #0 [ <required> Imagick $composite_image ]
-            Parameter #1 [ <required> $composite ]
-            Parameter #2 [ <required> $x ]
-            Parameter #3 [ <required> $y ]
-            Parameter #4 [ <optional> $channel ]
+            Parameter #1 [ <required> int $composite ]
+            Parameter #2 [ <required> int $x ]
+            Parameter #3 [ <required> int $y ]
+            Parameter #4 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method modulateImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $brightness ]
-            Parameter #1 [ <required> $saturation ]
-            Parameter #2 [ <required> $hue ]
+            Parameter #0 [ <required> float $brightness ]
+            Parameter #1 [ <required> float $saturation ]
+            Parameter #2 [ <required> float $hue ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getImageColors ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method montageImage ] {
 
           - Parameters [5] {
             Parameter #0 [ <required> ImagickDraw $settings ]
-            Parameter #1 [ <required> $tile_geometry ]
-            Parameter #2 [ <required> $thumbnail_geometry ]
-            Parameter #3 [ <required> $monatgemode ]
-            Parameter #4 [ <required> $frame ]
+            Parameter #1 [ <required> string $tile_geometry ]
+            Parameter #2 [ <required> string $thumbnail_geometry ]
+            Parameter #3 [ <required> int $monatgemode ]
+            Parameter #4 [ <required> string $frame ]
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method identifyImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $append_raw_output ]
+            Parameter #0 [ <optional> bool $append_raw_output = false ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method thresholdImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $threshold ]
-            Parameter #1 [ <optional> $channel ]
+            Parameter #0 [ <required> float $threshold ]
+            Parameter #1 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method adaptiveThresholdImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $width ]
-            Parameter #1 [ <required> $height ]
-            Parameter #2 [ <required> $offset ]
+            Parameter #0 [ <required> int $width ]
+            Parameter #1 [ <required> int $height ]
+            Parameter #2 [ <required> int $offset ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method blackThresholdImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $threshold_color ]
+            Parameter #0 [ <required> ImagickPixel|string $threshold_color ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method whiteThresholdImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $threshold_color ]
+            Parameter #0 [ <required> ImagickPixel|string $threshold_color ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method appendImages ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $stack ]
+            Parameter #0 [ <required> bool $stack ]
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method charcoalImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $radius ]
-            Parameter #1 [ <required> $sigma ]
+            Parameter #0 [ <required> float $radius ]
+            Parameter #1 [ <required> float $sigma ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method normalizeImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $channel ]
+            Parameter #0 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method oilPaintImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $radius ]
+            Parameter #0 [ <required> float $radius ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method posterizeImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $levels ]
-            Parameter #1 [ <required> $dither ]
+            Parameter #0 [ <required> int $levels ]
+            Parameter #1 [ <required> bool $dither ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method raiseImage ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $width ]
-            Parameter #1 [ <required> $height ]
-            Parameter #2 [ <required> $x ]
-            Parameter #3 [ <required> $y ]
-            Parameter #4 [ <required> $raise ]
+            Parameter #0 [ <required> int $width ]
+            Parameter #1 [ <required> int $height ]
+            Parameter #2 [ <required> int $x ]
+            Parameter #3 [ <required> int $y ]
+            Parameter #4 [ <required> bool $raise ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method resampleImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $x_resolution ]
-            Parameter #1 [ <required> $y_resolution ]
-            Parameter #2 [ <required> $filter ]
-            Parameter #3 [ <required> $blur ]
+            Parameter #0 [ <required> float $x_resolution ]
+            Parameter #1 [ <required> float $y_resolution ]
+            Parameter #2 [ <required> int $filter ]
+            Parameter #3 [ <required> float $blur ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method resizeImage ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $columns ]
-            Parameter #1 [ <required> $rows ]
-            Parameter #2 [ <required> $filter ]
-            Parameter #3 [ <required> $blur ]
-            Parameter #4 [ <optional> $bestfit ]
-            Parameter #5 [ <optional> $legacy ]
+            Parameter #0 [ <required> int $columns ]
+            Parameter #1 [ <required> int $rows ]
+            Parameter #2 [ <required> int $filter ]
+            Parameter #3 [ <required> float $blur ]
+            Parameter #4 [ <optional> bool $bestfit = false ]
+            Parameter #5 [ <optional> bool $legacy = false ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method rollImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
+            Parameter #0 [ <required> int $x ]
+            Parameter #1 [ <required> int $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method rotateImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $background_color ]
-            Parameter #1 [ <required> $degrees ]
+            Parameter #0 [ <required> ImagickPixel|string $background_color ]
+            Parameter #1 [ <required> float $degrees ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method sampleImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $columns ]
-            Parameter #1 [ <required> $rows ]
+            Parameter #0 [ <required> int $columns ]
+            Parameter #1 [ <required> int $rows ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method solarizeImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $threshold ]
+            Parameter #0 [ <required> int $threshold ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method shadowImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $opacity ]
-            Parameter #1 [ <required> $sigma ]
-            Parameter #2 [ <required> $x ]
-            Parameter #3 [ <required> $y ]
+            Parameter #0 [ <required> float $opacity ]
+            Parameter #1 [ <required> float $sigma ]
+            Parameter #2 [ <required> int $x ]
+            Parameter #3 [ <required> int $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageBackgroundColor ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $background_color ]
+            Parameter #0 [ <required> ImagickPixel|string $background_color ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageChannelMask ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $channel ]
+            Parameter #0 [ <required> int $channel ]
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method setImageCompose ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $compose ]
+            Parameter #0 [ <required> int $compose ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageDelay ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $delay ]
+            Parameter #0 [ <required> int $delay ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageDepth ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $depth ]
+            Parameter #0 [ <required> int $depth ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageGamma ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $gamma ]
+            Parameter #0 [ <required> float $gamma ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageIterations ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $iterations ]
+            Parameter #0 [ <required> int $iterations ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageMatteColor ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $matte_color ]
+            Parameter #0 [ <required> ImagickPixel|string $matte_color ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImagePage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $width ]
-            Parameter #1 [ <required> $height ]
-            Parameter #2 [ <required> $x ]
-            Parameter #3 [ <required> $y ]
+            Parameter #0 [ <required> int $width ]
+            Parameter #1 [ <required> int $height ]
+            Parameter #2 [ <required> int $x ]
+            Parameter #3 [ <required> int $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageProgressMonitor ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $filename ]
+            Parameter #0 [ <required> string $filename ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setProgressMonitor ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $callback ]
+            Parameter #0 [ <required> callable $callback ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageResolution ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x_resolution ]
-            Parameter #1 [ <required> $y_resolution ]
+            Parameter #0 [ <required> float $x_resolution ]
+            Parameter #1 [ <required> float $y_resolution ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageScene ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $scene ]
+            Parameter #0 [ <required> int $scene ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageTicksPerSecond ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $ticks_per_second ]
+            Parameter #0 [ <required> int $ticks_per_second ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageType ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $image_type ]
+            Parameter #0 [ <required> int $image_type ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageUnits ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $units ]
+            Parameter #0 [ <required> int $units ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method sharpenImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $radius ]
-            Parameter #1 [ <required> $sigma ]
-            Parameter #2 [ <optional> $channel ]
+            Parameter #0 [ <required> float $radius ]
+            Parameter #1 [ <required> float $sigma ]
+            Parameter #2 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method shaveImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $columns ]
-            Parameter #1 [ <required> $rows ]
+            Parameter #0 [ <required> int $columns ]
+            Parameter #1 [ <required> int $rows ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method shearImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $background_color ]
-            Parameter #1 [ <required> $x_shear ]
-            Parameter #2 [ <required> $y_shear ]
+            Parameter #0 [ <required> ImagickPixel|string $background_color ]
+            Parameter #1 [ <required> float $x_shear ]
+            Parameter #2 [ <required> float $y_shear ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method spliceImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $width ]
-            Parameter #1 [ <required> $height ]
-            Parameter #2 [ <required> $x ]
-            Parameter #3 [ <required> $y ]
+            Parameter #0 [ <required> int $width ]
+            Parameter #1 [ <required> int $height ]
+            Parameter #2 [ <required> int $x ]
+            Parameter #3 [ <required> int $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pingImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $filename ]
+            Parameter #0 [ <required> string $filename ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method readImageFile ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $filehandle ]
-            Parameter #1 [ <optional> $filename ]
+            Parameter #0 [ <required> mixed $filehandle ]
+            Parameter #1 [ <optional> ?string $filename = null ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method displayImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $servername ]
+            Parameter #0 [ <required> string $servername ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method displayImages ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $servername ]
+            Parameter #0 [ <required> string $servername ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method spreadImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $radius ]
+            Parameter #0 [ <required> float $radius ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method swirlImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $degrees ]
+            Parameter #0 [ <required> float $degrees ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method stripImage ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method queryFontMetrics ] {
 
           - Parameters [3] {
             Parameter #0 [ <required> ImagickDraw $settings ]
-            Parameter #1 [ <required> $text ]
-            Parameter #2 [ <optional> $multiline ]
+            Parameter #1 [ <required> string $text ]
+            Parameter #2 [ <optional> ?bool $multiline = null ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method steganoImage ] {
 
           - Parameters [2] {
             Parameter #0 [ <required> Imagick $watermark ]
-            Parameter #1 [ <required> $offset ]
+            Parameter #1 [ <required> int $offset ]
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method addNoiseImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $noise ]
-            Parameter #1 [ <optional> $channel ]
+            Parameter #0 [ <required> int $noise ]
+            Parameter #1 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method addNoiseImageWithAttenuate ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $noise ]
-            Parameter #1 [ <required> $attenuate ]
-            Parameter #2 [ <optional> $channel ]
+            Parameter #0 [ <required> int $noise ]
+            Parameter #1 [ <required> float $attenuate ]
+            Parameter #2 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method motionBlurImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $radius ]
-            Parameter #1 [ <required> $sigma ]
-            Parameter #2 [ <required> $angle ]
-            Parameter #3 [ <optional> $channel ]
+            Parameter #0 [ <required> float $radius ]
+            Parameter #1 [ <required> float $sigma ]
+            Parameter #2 [ <required> float $angle ]
+            Parameter #3 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method morphImages ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $number_frames ]
+            Parameter #0 [ <required> int $number_frames ]
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method minifyImage ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method affineTransformImage ] {
@@ -2506,711 +2881,809 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
           - Parameters [1] {
             Parameter #0 [ <required> ImagickDraw $settings ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method averageImages ] {
 
           - Parameters [0] {
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method borderImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $border_color ]
-            Parameter #1 [ <required> $width ]
-            Parameter #2 [ <required> $height ]
+            Parameter #0 [ <required> ImagickPixel|string $border_color ]
+            Parameter #1 [ <required> int $width ]
+            Parameter #2 [ <required> int $height ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method borderImageWithComposite ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $border_color ]
-            Parameter #1 [ <required> $width ]
-            Parameter #2 [ <required> $height ]
-            Parameter #3 [ <required> $composite ]
+            Parameter #0 [ <required> ImagickPixel|string $border_color ]
+            Parameter #1 [ <required> int $width ]
+            Parameter #2 [ <required> int $height ]
+            Parameter #3 [ <required> int $composite ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method chopImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $width ]
-            Parameter #1 [ <required> $height ]
-            Parameter #2 [ <required> $x ]
-            Parameter #3 [ <required> $y ]
+            Parameter #0 [ <required> int $width ]
+            Parameter #1 [ <required> int $height ]
+            Parameter #2 [ <required> int $x ]
+            Parameter #3 [ <required> int $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method clipImage ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method clipPathImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $pathname ]
-            Parameter #1 [ <required> $inside ]
+            Parameter #0 [ <required> string $pathname ]
+            Parameter #1 [ <required> bool $inside ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method clipImagePath ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $pathname ]
-            Parameter #1 [ <required> $inside ]
+            Parameter #0 [ <required> string $pathname ]
+            Parameter #1 [ <required> bool $inside ]
           }
+          - Return [ void ]
         }
 
         Method [ <internal:imagick> public method coalesceImages ] {
 
           - Parameters [0] {
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method colorizeImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $colorize_color ]
-            Parameter #1 [ <required> $opacity_color ]
-            Parameter #2 [ <optional> $legacy ]
+            Parameter #0 [ <required> ImagickPixel|string $colorize_color ]
+            Parameter #1 [ <required> ImagickPixel|string|false $opacity_color ]
+            Parameter #2 [ <optional> ?bool $legacy = false ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method compareImageChannels ] {
 
           - Parameters [3] {
             Parameter #0 [ <required> Imagick $reference ]
-            Parameter #1 [ <required> $channel ]
-            Parameter #2 [ <required> $metric ]
+            Parameter #1 [ <required> int $channel ]
+            Parameter #2 [ <required> int $metric ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method compareImages ] {
 
           - Parameters [2] {
             Parameter #0 [ <required> Imagick $reference ]
-            Parameter #1 [ <required> $metric ]
+            Parameter #1 [ <required> int $metric ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method contrastImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $sharpen ]
+            Parameter #0 [ <required> bool $sharpen ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method combineImages ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $colorspace ]
+            Parameter #0 [ <required> int $colorspace ]
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method convolveImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $kernel ]
-            Parameter #1 [ <optional> $channel ]
+            Parameter #0 [ <required> array $kernel ]
+            Parameter #1 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method cycleColormapImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $displace ]
+            Parameter #0 [ <required> int $displace ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method deconstructImages ] {
 
           - Parameters [0] {
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method despeckleImage ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method edgeImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $radius ]
+            Parameter #0 [ <required> float $radius ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method embossImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $radius ]
-            Parameter #1 [ <required> $sigma ]
+            Parameter #0 [ <required> float $radius ]
+            Parameter #1 [ <required> float $sigma ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method enhanceImage ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method equalizeImage ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method evaluateImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $evaluate ]
-            Parameter #1 [ <required> $constant ]
-            Parameter #2 [ <optional> $channel ]
+            Parameter #0 [ <required> int $evaluate ]
+            Parameter #1 [ <required> float $constant ]
+            Parameter #2 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method evaluateImages ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $evaluate ]
+            Parameter #0 [ <required> int $evaluate ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method flattenImages ] {
 
           - Parameters [0] {
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method flipImage ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method flopImage ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method forwardFourierTransformImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $magnitude ]
+            Parameter #0 [ <required> bool $magnitude ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method frameImage ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $matte_color ]
-            Parameter #1 [ <required> $width ]
-            Parameter #2 [ <required> $height ]
-            Parameter #3 [ <required> $inner_bevel ]
-            Parameter #4 [ <required> $outer_bevel ]
+            Parameter #0 [ <required> ImagickPixel|string $matte_color ]
+            Parameter #1 [ <required> int $width ]
+            Parameter #2 [ <required> int $height ]
+            Parameter #3 [ <required> int $inner_bevel ]
+            Parameter #4 [ <required> int $outer_bevel ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method frameImageWithComposite ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $matte_color ]
-            Parameter #1 [ <required> $width ]
-            Parameter #2 [ <required> $height ]
-            Parameter #3 [ <required> $inner_bevel ]
-            Parameter #4 [ <required> $outer_bevel ]
-            Parameter #5 [ <required> $composite ]
+            Parameter #0 [ <required> ImagickPixel|string $matte_color ]
+            Parameter #1 [ <required> int $width ]
+            Parameter #2 [ <required> int $height ]
+            Parameter #3 [ <required> int $inner_bevel ]
+            Parameter #4 [ <required> int $outer_bevel ]
+            Parameter #5 [ <required> int $composite ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method fxImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $expression ]
-            Parameter #1 [ <optional> $channel ]
+            Parameter #0 [ <required> string $expression ]
+            Parameter #1 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method gammaImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $gamma ]
-            Parameter #1 [ <optional> $channel ]
+            Parameter #0 [ <required> float $gamma ]
+            Parameter #1 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method gaussianBlurImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $radius ]
-            Parameter #1 [ <required> $sigma ]
-            Parameter #2 [ <optional> $channel ]
+            Parameter #0 [ <required> float $radius ]
+            Parameter #1 [ <required> float $sigma ]
+            Parameter #2 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getImageBackgroundColor ] {
 
           - Parameters [0] {
           }
+          - Return [ ImagickPixel ]
         }
 
         Method [ <internal:imagick> public method getImageBluePrimary ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getImageBorderColor ] {
 
           - Parameters [0] {
           }
+          - Return [ ImagickPixel ]
         }
 
         Method [ <internal:imagick> public method getImageChannelDepth ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $channel ]
+            Parameter #0 [ <required> int $channel ]
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageChannelDistortion ] {
 
           - Parameters [3] {
             Parameter #0 [ <required> Imagick $reference ]
-            Parameter #1 [ <required> $channel ]
-            Parameter #2 [ <required> $metric ]
+            Parameter #1 [ <required> int $channel ]
+            Parameter #2 [ <required> int $metric ]
           }
+          - Return [ float ]
         }
 
         Method [ <internal:imagick> public method getImageChannelMean ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $channel ]
+            Parameter #0 [ <required> int $channel ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getImageChannelStatistics ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getImageColormapColor ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $index ]
+            Parameter #0 [ <required> int $index ]
           }
+          - Return [ ImagickPixel ]
         }
 
         Method [ <internal:imagick> public method getImageColorspace ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageCompose ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageDelay ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageDepth ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageDistortion ] {
 
           - Parameters [2] {
             Parameter #0 [ <required> Imagick $reference ]
-            Parameter #1 [ <required> $metric ]
+            Parameter #1 [ <required> int $metric ]
           }
+          - Return [ float ]
         }
 
         Method [ <internal:imagick> public method getImageDispose ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageGamma ] {
 
           - Parameters [0] {
           }
+          - Return [ float ]
         }
 
         Method [ <internal:imagick> public method getImageGreenPrimary ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getImageHeight ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageHistogram ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getImageInterlaceScheme ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageIterations ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImagePage ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getImagePixelColor ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
+            Parameter #0 [ <required> int $x ]
+            Parameter #1 [ <required> int $y ]
           }
+          - Return [ ImagickPixel ]
         }
 
         Method [ <internal:imagick> public method setImagePixelColor ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
-            Parameter #2 [ <required> $color ]
+            Parameter #0 [ <required> int $x ]
+            Parameter #1 [ <required> int $y ]
+            Parameter #2 [ <required> ImagickPixel|string $color ]
           }
+          - Return [ ImagickPixel ]
         }
 
         Method [ <internal:imagick> public method getImageProfile ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $name ]
+            Parameter #0 [ <required> string $name ]
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method getImageRedPrimary ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getImageRenderingIntent ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageResolution ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getImageScene ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageSignature ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method getImageTicksPerSecond ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageType ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageUnits ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageVirtualPixelMethod ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageWhitePoint ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getImageWidth ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getNumberImages ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageTotalInkDensity ] {
 
           - Parameters [0] {
           }
+          - Return [ float ]
         }
 
         Method [ <internal:imagick> public method getImageRegion ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $width ]
-            Parameter #1 [ <required> $height ]
-            Parameter #2 [ <required> $x ]
-            Parameter #3 [ <required> $y ]
+            Parameter #0 [ <required> int $width ]
+            Parameter #1 [ <required> int $height ]
+            Parameter #2 [ <required> int $x ]
+            Parameter #3 [ <required> int $y ]
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method implodeImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $radius ]
+            Parameter #0 [ <required> float $radius ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method inverseFourierTransformImage ] {
 
           - Parameters [2] {
             Parameter #0 [ <required> Imagick $complement ]
-            Parameter #1 [ <required> $magnitude ]
+            Parameter #1 [ <required> bool $magnitude ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method levelImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $black_point ]
-            Parameter #1 [ <required> $gamma ]
-            Parameter #2 [ <required> $white_point ]
-            Parameter #3 [ <optional> $channel ]
+            Parameter #0 [ <required> float $black_point ]
+            Parameter #1 [ <required> float $gamma ]
+            Parameter #2 [ <required> float $white_point ]
+            Parameter #3 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method magnifyImage ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method negateImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $gray ]
-            Parameter #1 [ <optional> $channel ]
+            Parameter #0 [ <required> bool $gray ]
+            Parameter #1 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method previewImages ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $preview ]
+            Parameter #0 [ <required> int $preview ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method profileImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $name ]
-            Parameter #1 [ <required> $profile ]
+            Parameter #0 [ <required> string $name ]
+            Parameter #1 [ <required> ?string $profile ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method quantizeImage ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $number_colors ]
-            Parameter #1 [ <required> $colorspace ]
-            Parameter #2 [ <required> $tree_depth ]
-            Parameter #3 [ <required> $dither ]
-            Parameter #4 [ <required> $measure_error ]
+            Parameter #0 [ <required> int $number_colors ]
+            Parameter #1 [ <required> int $colorspace ]
+            Parameter #2 [ <required> int $tree_depth ]
+            Parameter #3 [ <required> bool $dither ]
+            Parameter #4 [ <required> bool $measure_error ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method quantizeImages ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $number_colors ]
-            Parameter #1 [ <required> $colorspace ]
-            Parameter #2 [ <required> $tree_depth ]
-            Parameter #3 [ <required> $dither ]
-            Parameter #4 [ <required> $measure_error ]
+            Parameter #0 [ <required> int $number_colors ]
+            Parameter #1 [ <required> int $colorspace ]
+            Parameter #2 [ <required> int $tree_depth ]
+            Parameter #3 [ <required> bool $dither ]
+            Parameter #4 [ <required> bool $measure_error ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method removeImageProfile ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $name ]
+            Parameter #0 [ <required> string $name ]
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method separateImageChannel ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $channel ]
+            Parameter #0 [ <required> int $channel ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method sepiaToneImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $threshold ]
+            Parameter #0 [ <required> float $threshold ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageBluePrimary ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
+            Parameter #0 [ <required> float $x ]
+            Parameter #1 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageBorderColor ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $border_color ]
+            Parameter #0 [ <required> ImagickPixel|string $border_color ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageChannelDepth ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $channel ]
-            Parameter #1 [ <required> $depth ]
+            Parameter #0 [ <required> int $channel ]
+            Parameter #1 [ <required> int $depth ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageColormapColor ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $index ]
-            Parameter #1 [ <required> $color ]
+            Parameter #0 [ <required> int $index ]
+            Parameter #1 [ <required> ImagickPixel|string $color ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageColorspace ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $colorspace ]
+            Parameter #0 [ <required> int $colorspace ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageDispose ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $dispose ]
+            Parameter #0 [ <required> int $dispose ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageExtent ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $columns ]
-            Parameter #1 [ <required> $rows ]
+            Parameter #0 [ <required> int $columns ]
+            Parameter #1 [ <required> int $rows ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageGreenPrimary ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
+            Parameter #0 [ <required> float $x ]
+            Parameter #1 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageInterlaceScheme ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $interlace ]
+            Parameter #0 [ <required> int $interlace ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageProfile ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $name ]
-            Parameter #1 [ <required> $profile ]
+            Parameter #0 [ <required> string $name ]
+            Parameter #1 [ <required> string $profile ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageRedPrimary ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
+            Parameter #0 [ <required> float $x ]
+            Parameter #1 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageRenderingIntent ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $rendering_intent ]
+            Parameter #0 [ <required> int $rendering_intent ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageVirtualPixelMethod ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $method ]
+            Parameter #0 [ <required> int $method ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImageWhitePoint ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
+            Parameter #0 [ <required> float $x ]
+            Parameter #1 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method sigmoidalContrastImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $sharpen ]
-            Parameter #1 [ <required> $alpha ]
-            Parameter #2 [ <required> $beta ]
-            Parameter #3 [ <optional> $channel ]
+            Parameter #0 [ <required> bool $sharpen ]
+            Parameter #1 [ <required> float $alpha ]
+            Parameter #2 [ <required> float $beta ]
+            Parameter #3 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method stereoImage ] {
@@ -3218,6 +3691,7 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
           - Parameters [1] {
             Parameter #0 [ <required> Imagick $offset_image ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method textureImage ] {
@@ -3225,32 +3699,36 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
           - Parameters [1] {
             Parameter #0 [ <required> Imagick $texture ]
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method tintImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $tint_color ]
-            Parameter #1 [ <required> $opacity_color ]
-            Parameter #2 [ <optional> $legacy ]
+            Parameter #0 [ <required> ImagickPixel|string $tint_color ]
+            Parameter #1 [ <required> ImagickPixel|string $opacity_color ]
+            Parameter #2 [ <optional> bool $legacy = false ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method unsharpMaskImage ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $radius ]
-            Parameter #1 [ <required> $sigma ]
-            Parameter #2 [ <required> $amount ]
-            Parameter #3 [ <required> $threshold ]
-            Parameter #4 [ <optional> $channel ]
+            Parameter #0 [ <required> float $radius ]
+            Parameter #1 [ <required> float $sigma ]
+            Parameter #2 [ <required> float $amount ]
+            Parameter #3 [ <required> float $threshold ]
+            Parameter #4 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getImage ] {
 
           - Parameters [0] {
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method addImage ] {
@@ -3258,6 +3736,7 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
           - Parameters [1] {
             Parameter #0 [ <required> Imagick $image ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setImage ] {
@@ -3265,176 +3744,201 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
           - Parameters [1] {
             Parameter #0 [ <required> Imagick $image ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method newImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $columns ]
-            Parameter #1 [ <required> $rows ]
-            Parameter #2 [ <required> $background_color ]
-            Parameter #3 [ <optional> $format ]
+            Parameter #0 [ <required> int $columns ]
+            Parameter #1 [ <required> int $rows ]
+            Parameter #2 [ <required> ImagickPixel|string $background_color ]
+            Parameter #3 [ <optional> string $format = null ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method newPseudoImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $columns ]
-            Parameter #1 [ <required> $rows ]
-            Parameter #2 [ <required> $pseudo_format ]
+            Parameter #0 [ <required> int $columns ]
+            Parameter #1 [ <required> int $rows ]
+            Parameter #2 [ <required> string $pseudo_format ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getCompression ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getCompressionQuality ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getFilename ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method getFormat ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method getInterlaceScheme ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getOption ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $key ]
+            Parameter #0 [ <required> string $key ]
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method getPage ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getSamplingFactors ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getSize ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method setBackgroundColor ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $background_color ]
+            Parameter #0 [ <required> ImagickPixel|string $background_color ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setCompression ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $compression ]
+            Parameter #0 [ <required> int $compression ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setCompressionQuality ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $quality ]
+            Parameter #0 [ <required> int $quality ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setFilename ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $filename ]
+            Parameter #0 [ <required> string $filename ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setFormat ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $format ]
+            Parameter #0 [ <required> string $format ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setInterlaceScheme ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $interlace ]
+            Parameter #0 [ <required> int $interlace ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setOption ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $key ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> string $key ]
+            Parameter #1 [ <required> string $value ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setPage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $width ]
-            Parameter #1 [ <required> $height ]
-            Parameter #2 [ <required> $x ]
-            Parameter #3 [ <required> $y ]
+            Parameter #0 [ <required> int $width ]
+            Parameter #1 [ <required> int $height ]
+            Parameter #2 [ <required> int $x ]
+            Parameter #3 [ <required> int $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setResolution ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x_resolution ]
-            Parameter #1 [ <required> $y_resolution ]
+            Parameter #0 [ <required> float $x_resolution ]
+            Parameter #1 [ <required> float $y_resolution ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setSamplingFactors ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $factors ]
+            Parameter #0 [ <required> array $factors ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setSize ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $columns ]
-            Parameter #1 [ <required> $rows ]
+            Parameter #0 [ <required> int $columns ]
+            Parameter #1 [ <required> int $rows ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setType ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $imgtype ]
+            Parameter #0 [ <required> int $imgtype ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick, prototype Iterator> public method key ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick, prototype Iterator> public method next ] {
@@ -3453,306 +3957,344 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick, prototype Iterator> public method current ] {
 
           - Parameters [0] {
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method brightnessContrastImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $brightness ]
-            Parameter #1 [ <required> $contrast ]
-            Parameter #2 [ <optional> $channel ]
+            Parameter #0 [ <required> float $brightness ]
+            Parameter #1 [ <required> float $contrast ]
+            Parameter #2 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method colorMatrixImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $color_matrix ]
+            Parameter #0 [ <required> array $color_matrix ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method selectiveBlurImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $radius ]
-            Parameter #1 [ <required> $sigma ]
-            Parameter #2 [ <required> $threshold ]
-            Parameter #3 [ <optional> $channel ]
+            Parameter #0 [ <required> float $radius ]
+            Parameter #1 [ <required> float $sigma ]
+            Parameter #2 [ <required> float $threshold ]
+            Parameter #3 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method rotationalBlurImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $angle ]
-            Parameter #1 [ <optional> $channel ]
+            Parameter #0 [ <required> float $angle ]
+            Parameter #1 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method statisticImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $type ]
-            Parameter #1 [ <required> $width ]
-            Parameter #2 [ <required> $height ]
-            Parameter #3 [ <optional> $channel ]
+            Parameter #0 [ <required> int $type ]
+            Parameter #1 [ <required> int $width ]
+            Parameter #2 [ <required> int $height ]
+            Parameter #3 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method subimageMatch ] {
 
           - Parameters [5] {
             Parameter #0 [ <required> Imagick $image ]
-            Parameter #1 [ <optional> &$offset ]
-            Parameter #2 [ <optional> &$similarity ]
-            Parameter #3 [ <optional> $threshold ]
-            Parameter #4 [ <optional> $metric ]
+            Parameter #1 [ <optional> ?array &$offset = null ]
+            Parameter #2 [ <optional> ?float &$similarity = null ]
+            Parameter #3 [ <optional> float $threshold = 0.0 ]
+            Parameter #4 [ <optional> int $metric = 0 ]
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method similarityImage ] {
 
           - Parameters [5] {
             Parameter #0 [ <required> Imagick $image ]
-            Parameter #1 [ <optional> &$offset ]
-            Parameter #2 [ <optional> &$similarity ]
-            Parameter #3 [ <optional> $threshold ]
-            Parameter #4 [ <optional> $metric ]
+            Parameter #1 [ <optional> ?array &$offset = null ]
+            Parameter #2 [ <optional> ?float &$similarity = null ]
+            Parameter #3 [ <optional> float $threshold = 0.0 ]
+            Parameter #4 [ <optional> int $metric = 0 ]
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method morphology ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $morphology ]
-            Parameter #1 [ <required> $iterations ]
+            Parameter #0 [ <required> int $morphology ]
+            Parameter #1 [ <required> int $iterations ]
             Parameter #2 [ <required> ImagickKernel $kernel ]
-            Parameter #3 [ <optional> $channel ]
+            Parameter #3 [ <optional> int $channel = Imagick::CHANNEL_DEFAULT ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setAntialias ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $antialias ]
+            Parameter #0 [ <required> bool $antialias ]
           }
+          - Return [ void ]
         }
 
         Method [ <internal:imagick> public method getAntialias ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method colorDecisionListImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $color_correction_collection ]
+            Parameter #0 [ <required> string $color_correction_collection ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method optimizeImageTransparency ] {
 
           - Parameters [0] {
           }
+          - Return [ void ]
         }
 
         Method [ <internal:imagick> public method autoGammaImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $channel ]
+            Parameter #0 [ <optional> ?int $channel = Imagick::CHANNEL_ALL ]
           }
+          - Return [ void ]
         }
 
         Method [ <internal:imagick> public method autoOrient ] {
 
           - Parameters [0] {
           }
+          - Return [ void ]
         }
 
         Method [ <internal:imagick> public method autoOrientate ] {
 
           - Parameters [0] {
           }
+          - Return [ void ]
         }
 
         Method [ <internal:imagick> public method compositeImageGravity ] {
 
           - Parameters [3] {
             Parameter #0 [ <required> Imagick $image ]
-            Parameter #1 [ <required> $composite_constant ]
-            Parameter #2 [ <required> $gravity ]
+            Parameter #1 [ <required> int $composite_constant ]
+            Parameter #2 [ <required> int $gravity ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method localContrastImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $radius ]
-            Parameter #1 [ <required> $strength ]
+            Parameter #0 [ <required> float $radius ]
+            Parameter #1 [ <required> float $strength ]
           }
+          - Return [ void ]
         }
 
         Method [ <internal:imagick> public method identifyImageType ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getImageMask ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $pixelmask ]
+            Parameter #0 [ <required> int $pixelmask ]
           }
+          - Return [ ?Imagick ]
         }
 
         Method [ <internal:imagick> public method setImageMask ] {
 
           - Parameters [2] {
             Parameter #0 [ <required> Imagick $clip_mask ]
-            Parameter #1 [ <required> $pixelmask ]
+            Parameter #1 [ <required> int $pixelmask ]
           }
+          - Return [ void ]
         }
 
         Method [ <internal:imagick> public method cannyEdgeImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $radius ]
-            Parameter #1 [ <required> $sigma ]
-            Parameter #2 [ <required> $lower_percent ]
-            Parameter #3 [ <required> $upper_percent ]
+            Parameter #0 [ <required> float $radius ]
+            Parameter #1 [ <required> float $sigma ]
+            Parameter #2 [ <required> float $lower_percent ]
+            Parameter #3 [ <required> float $upper_percent ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method waveletDenoiseImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $threshold ]
-            Parameter #1 [ <required> $softness ]
+            Parameter #0 [ <required> float $threshold ]
+            Parameter #1 [ <required> float $softness ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method meanShiftImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $width ]
-            Parameter #1 [ <required> $height ]
-            Parameter #2 [ <required> $color_distance ]
+            Parameter #0 [ <required> int $width ]
+            Parameter #1 [ <required> int $height ]
+            Parameter #2 [ <required> float $color_distance ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method kmeansImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $number_colors ]
-            Parameter #1 [ <required> $max_iterations ]
-            Parameter #2 [ <required> $tolerance ]
+            Parameter #0 [ <required> int $number_colors ]
+            Parameter #1 [ <required> int $max_iterations ]
+            Parameter #2 [ <required> float $tolerance ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method rangeThresholdImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $low_black ]
-            Parameter #1 [ <required> $low_white ]
-            Parameter #2 [ <required> $high_white ]
-            Parameter #3 [ <required> $high_black ]
+            Parameter #0 [ <required> float $low_black ]
+            Parameter #1 [ <required> float $low_white ]
+            Parameter #2 [ <required> float $high_white ]
+            Parameter #3 [ <required> float $high_black ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method autoThresholdImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $auto_threshold_method ]
+            Parameter #0 [ <required> int $auto_threshold_method ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method bilateralBlurImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $radius ]
-            Parameter #1 [ <required> $sigma ]
-            Parameter #2 [ <required> $intensity_sigma ]
-            Parameter #3 [ <required> $spatial_sigma ]
+            Parameter #0 [ <required> float $radius ]
+            Parameter #1 [ <required> float $sigma ]
+            Parameter #2 [ <required> float $intensity_sigma ]
+            Parameter #3 [ <required> float $spatial_sigma ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method claheImage ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $width ]
-            Parameter #1 [ <required> $height ]
-            Parameter #2 [ <required> $number_bins ]
-            Parameter #3 [ <required> $clip_limit ]
+            Parameter #0 [ <required> int $width ]
+            Parameter #1 [ <required> int $height ]
+            Parameter #2 [ <required> int $number_bins ]
+            Parameter #3 [ <required> float $clip_limit ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method channelFxImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $expression ]
+            Parameter #0 [ <required> string $expression ]
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method colorThresholdImage ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $start_color ]
-            Parameter #1 [ <required> $stop_color ]
+            Parameter #0 [ <required> ImagickPixel|string $start_color ]
+            Parameter #1 [ <required> ImagickPixel|string $stop_color ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method complexImages ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $complex_operator ]
+            Parameter #0 [ <required> int $complex_operator ]
           }
+          - Return [ Imagick ]
         }
 
         Method [ <internal:imagick> public method interpolativeResizeImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $columns ]
-            Parameter #1 [ <required> $rows ]
-            Parameter #2 [ <required> $interpolate ]
+            Parameter #0 [ <required> int $columns ]
+            Parameter #1 [ <required> int $rows ]
+            Parameter #2 [ <required> int $interpolate ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method levelImageColors ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $black_color ]
-            Parameter #1 [ <required> $white_color ]
-            Parameter #2 [ <required> $invert ]
+            Parameter #0 [ <required> ImagickPixel|string $black_color ]
+            Parameter #1 [ <required> ImagickPixel|string $white_color ]
+            Parameter #2 [ <required> bool $invert ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method levelizeImage ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $black_point ]
-            Parameter #1 [ <required> $gamma ]
-            Parameter #2 [ <required> $white_point ]
+            Parameter #0 [ <required> float $black_point ]
+            Parameter #1 [ <required> float $gamma ]
+            Parameter #2 [ <required> float $white_point ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method orderedDitherImage ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $dither_format ]
+            Parameter #0 [ <required> string $dither_format ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method whiteBalanceImage ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
       }
     }
@@ -3776,45 +4318,52 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getTextKerning ] {
 
           - Parameters [0] {
           }
+          - Return [ float ]
         }
 
         Method [ <internal:imagick> public method setTextKerning ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $kerning ]
+            Parameter #0 [ <required> float $kerning ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getTextInterwordSpacing ] {
 
           - Parameters [0] {
           }
+          - Return [ float ]
         }
 
         Method [ <internal:imagick> public method setTextInterwordSpacing ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $spacing ]
+            Parameter #0 [ <required> float $spacing ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getTextInterlineSpacing ] {
 
           - Parameters [0] {
           }
+          - Return [ float ]
         }
 
         Method [ <internal:imagick> public method setTextInterlineSpacing ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $spacing ]
+            Parameter #0 [ <required> float $spacing ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick, ctor> public method __construct ] {
@@ -3826,924 +4375,1050 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
         Method [ <internal:imagick> public method setFillColor ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $fill_color ]
+            Parameter #0 [ <required> ImagickPixel|string $fill_color ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setFillAlpha ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $alpha ]
+            Parameter #0 [ <required> float $alpha ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setResolution ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $resolution_x ]
-            Parameter #1 [ <required> $resolution_y ]
+            Parameter #0 [ <required> float $resolution_x ]
+            Parameter #1 [ <required> float $resolution_y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setStrokeColor ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $color ]
+            Parameter #0 [ <required> ImagickPixel|string $color ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setStrokeAlpha ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $alpha ]
+            Parameter #0 [ <required> float $alpha ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setStrokeWidth ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $width ]
+            Parameter #0 [ <required> float $width ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method clear ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method circle ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $origin_x ]
-            Parameter #1 [ <required> $origin_y ]
-            Parameter #2 [ <required> $perimeter_x ]
-            Parameter #3 [ <required> $perimeter_y ]
+            Parameter #0 [ <required> float $origin_x ]
+            Parameter #1 [ <required> float $origin_y ]
+            Parameter #2 [ <required> float $perimeter_x ]
+            Parameter #3 [ <required> float $perimeter_y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method annotation ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
-            Parameter #2 [ <required> $text ]
+            Parameter #0 [ <required> float $x ]
+            Parameter #1 [ <required> float $y ]
+            Parameter #2 [ <required> string $text ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setTextAntialias ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $antialias ]
+            Parameter #0 [ <required> bool $antialias ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setTextEncoding ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $encoding ]
+            Parameter #0 [ <required> string $encoding ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setFont ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $font_name ]
+            Parameter #0 [ <required> string $font_name ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setFontFamily ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $font_family ]
+            Parameter #0 [ <required> string $font_family ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setFontSize ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $point_size ]
+            Parameter #0 [ <required> float $point_size ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setFontStyle ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $style ]
+            Parameter #0 [ <required> int $style ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setFontWeight ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $weight ]
+            Parameter #0 [ <required> int $weight ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getFont ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method getFontFamily ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method getFontSize ] {
 
           - Parameters [0] {
           }
+          - Return [ float ]
         }
 
         Method [ <internal:imagick> public method getFontStyle ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getFontWeight ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method destroy ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method rectangle ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $top_left_x ]
-            Parameter #1 [ <required> $top_left_y ]
-            Parameter #2 [ <required> $bottom_right_x ]
-            Parameter #3 [ <required> $bottom_right_y ]
+            Parameter #0 [ <required> float $top_left_x ]
+            Parameter #1 [ <required> float $top_left_y ]
+            Parameter #2 [ <required> float $bottom_right_x ]
+            Parameter #3 [ <required> float $bottom_right_y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method roundRectangle ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $top_left_x ]
-            Parameter #1 [ <required> $top_left_y ]
-            Parameter #2 [ <required> $bottom_right_x ]
-            Parameter #3 [ <required> $bottom_right_y ]
-            Parameter #4 [ <required> $rounding_x ]
-            Parameter #5 [ <required> $rounding_y ]
+            Parameter #0 [ <required> float $top_left_x ]
+            Parameter #1 [ <required> float $top_left_y ]
+            Parameter #2 [ <required> float $bottom_right_x ]
+            Parameter #3 [ <required> float $bottom_right_y ]
+            Parameter #4 [ <required> float $rounding_x ]
+            Parameter #5 [ <required> float $rounding_y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method ellipse ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $origin_x ]
-            Parameter #1 [ <required> $origin_y ]
-            Parameter #2 [ <required> $radius_x ]
-            Parameter #3 [ <required> $radius_y ]
-            Parameter #4 [ <required> $angle_start ]
-            Parameter #5 [ <required> $angle_end ]
+            Parameter #0 [ <required> float $origin_x ]
+            Parameter #1 [ <required> float $origin_y ]
+            Parameter #2 [ <required> float $radius_x ]
+            Parameter #3 [ <required> float $radius_y ]
+            Parameter #4 [ <required> float $angle_start ]
+            Parameter #5 [ <required> float $angle_end ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method skewX ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $degrees ]
+            Parameter #0 [ <required> float $degrees ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method skewY ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $degrees ]
+            Parameter #0 [ <required> float $degrees ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method translate ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
+            Parameter #0 [ <required> float $x ]
+            Parameter #1 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method line ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $start_x ]
-            Parameter #1 [ <required> $start_y ]
-            Parameter #2 [ <required> $end_x ]
-            Parameter #3 [ <required> $end_y ]
+            Parameter #0 [ <required> float $start_x ]
+            Parameter #1 [ <required> float $start_y ]
+            Parameter #2 [ <required> float $end_x ]
+            Parameter #3 [ <required> float $end_y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method arc ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $start_x ]
-            Parameter #1 [ <required> $start_y ]
-            Parameter #2 [ <required> $end_x ]
-            Parameter #3 [ <required> $end_y ]
-            Parameter #4 [ <required> $start_angle ]
-            Parameter #5 [ <required> $end_angle ]
+            Parameter #0 [ <required> float $start_x ]
+            Parameter #1 [ <required> float $start_y ]
+            Parameter #2 [ <required> float $end_x ]
+            Parameter #3 [ <required> float $end_y ]
+            Parameter #4 [ <required> float $start_angle ]
+            Parameter #5 [ <required> float $end_angle ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method alpha ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
-            Parameter #2 [ <required> $paint ]
+            Parameter #0 [ <required> float $x ]
+            Parameter #1 [ <required> float $y ]
+            Parameter #2 [ <required> int $paint ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method polygon ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $coordinates ]
+            Parameter #0 [ <required> array $coordinates ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method point ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
+            Parameter #0 [ <required> float $x ]
+            Parameter #1 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getTextDecoration ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getTextEncoding ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method getFontStretch ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method setFontStretch ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $stretch ]
+            Parameter #0 [ <required> int $stretch ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setStrokeAntialias ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $enabled ]
+            Parameter #0 [ <required> bool $enabled ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setTextAlignment ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $align ]
+            Parameter #0 [ <required> int $align ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setTextDecoration ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $decoration ]
+            Parameter #0 [ <required> int $decoration ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setTextUnderColor ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $under_color ]
+            Parameter #0 [ <required> ImagickPixel|string $under_color ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setViewbox ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $left_x ]
-            Parameter #1 [ <required> $top_y ]
-            Parameter #2 [ <required> $right_x ]
-            Parameter #3 [ <required> $bottom_y ]
+            Parameter #0 [ <required> int $left_x ]
+            Parameter #1 [ <required> int $top_y ]
+            Parameter #2 [ <required> int $right_x ]
+            Parameter #3 [ <required> int $bottom_y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method clone ] {
 
           - Parameters [0] {
           }
+          - Return [ ImagickDraw ]
         }
 
         Method [ <internal:imagick> public method affine ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $affine ]
+            Parameter #0 [ <required> array $affine ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method bezier ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $coordinates ]
+            Parameter #0 [ <required> array $coordinates ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method composite ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $composite ]
-            Parameter #1 [ <required> $x ]
-            Parameter #2 [ <required> $y ]
-            Parameter #3 [ <required> $width ]
-            Parameter #4 [ <required> $height ]
+            Parameter #0 [ <required> int $composite ]
+            Parameter #1 [ <required> float $x ]
+            Parameter #2 [ <required> float $y ]
+            Parameter #3 [ <required> float $width ]
+            Parameter #4 [ <required> float $height ]
             Parameter #5 [ <required> Imagick $image ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method color ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
-            Parameter #2 [ <required> $paint ]
+            Parameter #0 [ <required> float $x ]
+            Parameter #1 [ <required> float $y ]
+            Parameter #2 [ <required> int $paint ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method comment ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $comment ]
+            Parameter #0 [ <required> string $comment ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getClipPath ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method getClipRule ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getClipUnits ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getFillColor ] {
 
           - Parameters [0] {
           }
+          - Return [ ImagickPixel ]
         }
 
         Method [ <internal:imagick> public method getFillOpacity ] {
 
           - Parameters [0] {
           }
+          - Return [ float ]
         }
 
         Method [ <internal:imagick> public method getFillRule ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getGravity ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getStrokeAntialias ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getStrokeColor ] {
 
           - Parameters [0] {
           }
+          - Return [ ImagickPixel ]
         }
 
         Method [ <internal:imagick> public method getStrokeDashArray ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getStrokeDashOffset ] {
 
           - Parameters [0] {
           }
+          - Return [ float ]
         }
 
         Method [ <internal:imagick> public method getStrokeLineCap ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getStrokeLineJoin ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getStrokeMiterLimit ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getStrokeOpacity ] {
 
           - Parameters [0] {
           }
+          - Return [ float ]
         }
 
         Method [ <internal:imagick> public method getStrokeWidth ] {
 
           - Parameters [0] {
           }
+          - Return [ float ]
         }
 
         Method [ <internal:imagick> public method getTextAlignment ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getTextAntialias ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getVectorGraphics ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method getTextUnderColor ] {
 
           - Parameters [0] {
           }
+          - Return [ ImagickPixel ]
         }
 
         Method [ <internal:imagick> public method pathClose ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathCurveToAbsolute ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $x1 ]
-            Parameter #1 [ <required> $y1 ]
-            Parameter #2 [ <required> $x2 ]
-            Parameter #3 [ <required> $y2 ]
-            Parameter #4 [ <required> $x ]
-            Parameter #5 [ <required> $y ]
+            Parameter #0 [ <required> float $x1 ]
+            Parameter #1 [ <required> float $y1 ]
+            Parameter #2 [ <required> float $x2 ]
+            Parameter #3 [ <required> float $y2 ]
+            Parameter #4 [ <required> float $x ]
+            Parameter #5 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathCurveToRelative ] {
 
           - Parameters [6] {
-            Parameter #0 [ <required> $x1 ]
-            Parameter #1 [ <required> $y1 ]
-            Parameter #2 [ <required> $x2 ]
-            Parameter #3 [ <required> $y2 ]
-            Parameter #4 [ <required> $x ]
-            Parameter #5 [ <required> $y ]
+            Parameter #0 [ <required> float $x1 ]
+            Parameter #1 [ <required> float $y1 ]
+            Parameter #2 [ <required> float $x2 ]
+            Parameter #3 [ <required> float $y2 ]
+            Parameter #4 [ <required> float $x ]
+            Parameter #5 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathCurveToQuadraticBezierAbsolute ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $x1 ]
-            Parameter #1 [ <required> $y1 ]
-            Parameter #2 [ <required> $x_end ]
-            Parameter #3 [ <required> $y ]
+            Parameter #0 [ <required> float $x1 ]
+            Parameter #1 [ <required> float $y1 ]
+            Parameter #2 [ <required> float $x_end ]
+            Parameter #3 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathCurveToQuadraticBezierRelative ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $x1 ]
-            Parameter #1 [ <required> $y1 ]
-            Parameter #2 [ <required> $x_end ]
-            Parameter #3 [ <required> $y ]
+            Parameter #0 [ <required> float $x1 ]
+            Parameter #1 [ <required> float $y1 ]
+            Parameter #2 [ <required> float $x_end ]
+            Parameter #3 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathCurveToQuadraticBezierSmoothAbsolute ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
+            Parameter #0 [ <required> float $x ]
+            Parameter #1 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathCurveToQuadraticBezierSmoothRelative ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
+            Parameter #0 [ <required> float $x ]
+            Parameter #1 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathCurveToSmoothAbsolute ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $x2 ]
-            Parameter #1 [ <required> $y2 ]
-            Parameter #2 [ <required> $x ]
-            Parameter #3 [ <required> $y ]
+            Parameter #0 [ <required> float $x2 ]
+            Parameter #1 [ <required> float $y2 ]
+            Parameter #2 [ <required> float $x ]
+            Parameter #3 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathCurveToSmoothRelative ] {
 
           - Parameters [4] {
-            Parameter #0 [ <required> $x2 ]
-            Parameter #1 [ <required> $y2 ]
-            Parameter #2 [ <required> $x ]
-            Parameter #3 [ <required> $y ]
+            Parameter #0 [ <required> float $x2 ]
+            Parameter #1 [ <required> float $y2 ]
+            Parameter #2 [ <required> float $x ]
+            Parameter #3 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathEllipticArcAbsolute ] {
 
           - Parameters [7] {
-            Parameter #0 [ <required> $rx ]
-            Parameter #1 [ <required> $ry ]
-            Parameter #2 [ <required> $x_axis_rotation ]
-            Parameter #3 [ <required> $large_arc ]
-            Parameter #4 [ <required> $sweep ]
-            Parameter #5 [ <required> $x ]
-            Parameter #6 [ <required> $y ]
+            Parameter #0 [ <required> float $rx ]
+            Parameter #1 [ <required> float $ry ]
+            Parameter #2 [ <required> float $x_axis_rotation ]
+            Parameter #3 [ <required> bool $large_arc ]
+            Parameter #4 [ <required> bool $sweep ]
+            Parameter #5 [ <required> float $x ]
+            Parameter #6 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathEllipticArcRelative ] {
 
           - Parameters [7] {
-            Parameter #0 [ <required> $rx ]
-            Parameter #1 [ <required> $ry ]
-            Parameter #2 [ <required> $x_axis_rotation ]
-            Parameter #3 [ <required> $large_arc ]
-            Parameter #4 [ <required> $sweep ]
-            Parameter #5 [ <required> $x ]
-            Parameter #6 [ <required> $y ]
+            Parameter #0 [ <required> float $rx ]
+            Parameter #1 [ <required> float $ry ]
+            Parameter #2 [ <required> float $x_axis_rotation ]
+            Parameter #3 [ <required> bool $large_arc ]
+            Parameter #4 [ <required> bool $sweep ]
+            Parameter #5 [ <required> float $x ]
+            Parameter #6 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathFinish ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathLineToAbsolute ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
+            Parameter #0 [ <required> float $x ]
+            Parameter #1 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathLineToRelative ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
+            Parameter #0 [ <required> float $x ]
+            Parameter #1 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathLineToHorizontalAbsolute ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $x ]
+            Parameter #0 [ <required> float $x ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathLineToHorizontalRelative ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $x ]
+            Parameter #0 [ <required> float $x ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathLineToVerticalAbsolute ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $y ]
+            Parameter #0 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathLineToVerticalRelative ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $y ]
+            Parameter #0 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathMoveToAbsolute ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
+            Parameter #0 [ <required> float $x ]
+            Parameter #1 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathMoveToRelative ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
+            Parameter #0 [ <required> float $x ]
+            Parameter #1 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pathStart ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method polyline ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $coordinates ]
+            Parameter #0 [ <required> array $coordinates ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method popClipPath ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method popDefs ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method popPattern ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pushClipPath ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $clip_mask_id ]
+            Parameter #0 [ <required> string $clip_mask_id ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pushDefs ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pushPattern ] {
 
           - Parameters [5] {
-            Parameter #0 [ <required> $pattern_id ]
-            Parameter #1 [ <required> $x ]
-            Parameter #2 [ <required> $y ]
-            Parameter #3 [ <required> $width ]
-            Parameter #4 [ <required> $height ]
+            Parameter #0 [ <required> string $pattern_id ]
+            Parameter #1 [ <required> float $x ]
+            Parameter #2 [ <required> float $y ]
+            Parameter #3 [ <required> float $width ]
+            Parameter #4 [ <required> float $height ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method render ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method rotate ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $degrees ]
+            Parameter #0 [ <required> float $degrees ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method scale ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
+            Parameter #0 [ <required> float $x ]
+            Parameter #1 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setClipPath ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $clip_mask ]
+            Parameter #0 [ <required> string $clip_mask ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setClipRule ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $fillrule ]
+            Parameter #0 [ <required> int $fillrule ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setClipUnits ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $pathunits ]
+            Parameter #0 [ <required> int $pathunits ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setFillOpacity ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $opacity ]
+            Parameter #0 [ <required> float $opacity ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setFillPatternUrl ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $fill_url ]
+            Parameter #0 [ <required> string $fill_url ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setFillRule ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $fillrule ]
+            Parameter #0 [ <required> int $fillrule ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setGravity ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $gravity ]
+            Parameter #0 [ <required> int $gravity ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setStrokePatternUrl ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $stroke_url ]
+            Parameter #0 [ <required> string $stroke_url ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setStrokeDashOffset ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $dash_offset ]
+            Parameter #0 [ <required> float $dash_offset ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setStrokeLineCap ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $linecap ]
+            Parameter #0 [ <required> int $linecap ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setStrokeLineJoin ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $linejoin ]
+            Parameter #0 [ <required> int $linejoin ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setStrokeMiterLimit ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $miterlimit ]
+            Parameter #0 [ <required> int $miterlimit ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setStrokeOpacity ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $opacity ]
+            Parameter #0 [ <required> float $opacity ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setVectorGraphics ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $xml ]
+            Parameter #0 [ <required> string $xml ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method pop ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method push ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setStrokeDashArray ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $dashes ]
+            Parameter #0 [ <required> array $dashes ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getOpacity ] {
 
           - Parameters [0] {
           }
+          - Return [ float ]
         }
 
         Method [ <internal:imagick> public method setOpacity ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $opacity ]
+            Parameter #0 [ <required> float $opacity ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getFontResolution ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method setFontResolution ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $x ]
-            Parameter #1 [ <required> $y ]
+            Parameter #0 [ <required> float $x ]
+            Parameter #1 [ <required> float $y ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getBorderColor ] {
 
           - Parameters [0] {
           }
+          - Return [ ImagickPixel ]
         }
 
         Method [ <internal:imagick> public method setBorderColor ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $color ]
+            Parameter #0 [ <required> ImagickPixel|string $color ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setDensity ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $density ]
+            Parameter #0 [ <required> string $density ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getDensity ] {
 
           - Parameters [0] {
           }
+          - Return [ ?string ]
         }
 
         Method [ <internal:imagick> public method getTextDirection ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method setTextDirection ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $direction ]
+            Parameter #0 [ <required> int $direction ]
           }
+          - Return [ bool ]
         }
       }
     }
@@ -4762,17 +5437,19 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
           - Parameters [1] {
             Parameter #0 [ <required> Imagick $imagick ]
           }
+          - Return [ ImagickPixelIterator ]
         }
 
         Method [ <internal:imagick> static public method getPixelRegionIterator ] {
 
           - Parameters [5] {
             Parameter #0 [ <required> Imagick $imagick ]
-            Parameter #1 [ <required> $x ]
-            Parameter #2 [ <required> $y ]
-            Parameter #3 [ <required> $columns ]
-            Parameter #4 [ <required> $rows ]
+            Parameter #1 [ <required> int $x ]
+            Parameter #2 [ <required> int $y ]
+            Parameter #3 [ <required> int $columns ]
+            Parameter #4 [ <required> int $rows ]
           }
+          - Return [ ImagickPixelIterator ]
         }
       }
 
@@ -4791,42 +5468,49 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method destroy ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getCurrentIteratorRow ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getIteratorRow ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getNextIteratorRow ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getPreviousIteratorRow ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick, prototype Iterator> public method key ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick, prototype Iterator> public method next ] {
@@ -4845,6 +5529,7 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method newPixelIterator ] {
@@ -4852,54 +5537,62 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
           - Parameters [1] {
             Parameter #0 [ <required> Imagick $imagick ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method newPixelRegionIterator ] {
 
           - Parameters [5] {
             Parameter #0 [ <required> Imagick $imagick ]
-            Parameter #1 [ <required> $x ]
-            Parameter #2 [ <required> $y ]
-            Parameter #3 [ <required> $columns ]
-            Parameter #4 [ <required> $rows ]
+            Parameter #1 [ <required> int $x ]
+            Parameter #2 [ <required> int $y ]
+            Parameter #3 [ <required> int $columns ]
+            Parameter #4 [ <required> int $rows ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method resetIterator ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setIteratorFirstRow ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setIteratorLastRow ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setIteratorRow ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $row ]
+            Parameter #0 [ <required> int $row ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method syncIterator ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick, prototype Iterator> public method valid ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
       }
     }
@@ -4922,7 +5615,7 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
         Method [ <internal:imagick, ctor> public method __construct ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $color ]
+            Parameter #0 [ <optional> ?string $color = null ]
           }
         }
 
@@ -4930,133 +5623,152 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method destroy ] {
 
           - Parameters [0] {
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method getColor ] {
 
           - Parameters [1] {
-            Parameter #0 [ <optional> $normalized ]
+            Parameter #0 [ <optional> int $normalized = 0 ]
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getColorAsString ] {
 
           - Parameters [0] {
           }
+          - Return [ string ]
         }
 
         Method [ <internal:imagick> public method getColorCount ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method getColorQuantum ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getColorValue ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $color ]
+            Parameter #0 [ <required> int $color ]
           }
+          - Return [ float ]
         }
 
         Method [ <internal:imagick> public method getColorValueQuantum ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $color ]
+            Parameter #0 [ <required> int $color ]
           }
+          - Return [ float ]
         }
 
         Method [ <internal:imagick> public method getHSL ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method getIndex ] {
 
           - Parameters [0] {
           }
+          - Return [ int ]
         }
 
         Method [ <internal:imagick> public method isPixelSimilar ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $color ]
-            Parameter #1 [ <required> $fuzz ]
+            Parameter #0 [ <required> ImagickPixel|string $color ]
+            Parameter #1 [ <required> float $fuzz ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method isPixelSimilarQuantum ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $color ]
-            Parameter #1 [ <required> $fuzz_quantum_range_scaled_by_square_root_of_three ]
+            Parameter #0 [ <required> ImagickPixel|string $color ]
+            Parameter #1 [ <required> float $fuzz_quantum_range_scaled_by_square_root_of_three ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method isSimilar ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $color ]
-            Parameter #1 [ <required> $fuzz_quantum_range_scaled_by_square_root_of_three ]
+            Parameter #0 [ <required> ImagickPixel|string $color ]
+            Parameter #1 [ <required> float $fuzz_quantum_range_scaled_by_square_root_of_three ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setColor ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $color ]
+            Parameter #0 [ <required> string $color ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setColorCount ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $color_count ]
+            Parameter #0 [ <required> int $color_count ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setColorValue ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $color ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> int $color ]
+            Parameter #1 [ <required> float $value ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setColorValueQuantum ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $color ]
-            Parameter #1 [ <required> $value ]
+            Parameter #0 [ <required> int $color ]
+            Parameter #1 [ <required> float $value ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setHSL ] {
 
           - Parameters [3] {
-            Parameter #0 [ <required> $hue ]
-            Parameter #1 [ <required> $saturation ]
-            Parameter #2 [ <required> $luminosity ]
+            Parameter #0 [ <required> float $hue ]
+            Parameter #1 [ <required> float $saturation ]
+            Parameter #2 [ <required> float $luminosity ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setIndex ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $index ]
+            Parameter #0 [ <required> float $index ]
           }
+          - Return [ bool ]
         }
 
         Method [ <internal:imagick> public method setColorFromPixel ] {
@@ -5064,6 +5776,7 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
           - Parameters [1] {
             Parameter #0 [ <required> ImagickPixel $pixel ]
           }
+          - Return [ bool ]
         }
       }
     }
@@ -5080,17 +5793,19 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
         Method [ <internal:imagick> static public method fromBuiltin ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $kernel ]
-            Parameter #1 [ <required> $shape ]
+            Parameter #0 [ <required> int $kernel ]
+            Parameter #1 [ <required> string $shape ]
           }
+          - Return [ ImagickKernel ]
         }
 
         Method [ <internal:imagick> static public method fromMatrix ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $matrix ]
-            Parameter #1 [ <required> $origin ]
+            Parameter #0 [ <required> array $matrix ]
+            Parameter #1 [ <required> ?array $origin ]
           }
+          - Return [ ImagickKernel ]
         }
       }
 
@@ -5103,33 +5818,38 @@ Extension [ <persistent> extension #79 imagick version 3.6.0 ] {
           - Parameters [1] {
             Parameter #0 [ <required> ImagickKernel $kernel ]
           }
+          - Return [ void ]
         }
 
         Method [ <internal:imagick> public method addUnityKernel ] {
 
           - Parameters [1] {
-            Parameter #0 [ <required> $scale ]
+            Parameter #0 [ <required> float $scale ]
           }
+          - Return [ void ]
         }
 
         Method [ <internal:imagick> public method getMatrix ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
 
         Method [ <internal:imagick> public method scale ] {
 
           - Parameters [2] {
-            Parameter #0 [ <required> $scale ]
-            Parameter #1 [ <optional> $normalize_kernel ]
+            Parameter #0 [ <required> float $scale ]
+            Parameter #1 [ <optional> ?int $normalize_kernel = null ]
           }
+          - Return [ void ]
         }
 
         Method [ <internal:imagick> public method separate ] {
 
           - Parameters [0] {
           }
+          - Return [ array ]
         }
       }
     }
-- 
cgit