paperback 0.0.4 → 0.0.5

data/sorbet/rbi/gems/chunky_png@1.4.0.rbi

@@ -0,0 +1,4498 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `chunky_png` gem.
+# Please instead update this file by running `bin/tapioca gem chunky_png`.
+
+# ChunkyPNG - the pure ruby library to access PNG files.
+#
+# The ChunkyPNG module defines some constants that are used in the
+# PNG specification, specifies some exception classes, and serves as
+# a namespace for all the other modules and classes in this library.
+#
+# {ChunkyPNG::Image}::      class to represent PNG images, including metadata.
+# {ChunkyPNG::Canvas}::     class to represent the image's canvas.
+# {ChunkyPNG::Color}::      module to work with color values.
+# {ChunkyPNG::Palette}::    represents the palette of colors used on a {ChunkyPNG::Canvas}.
+# {ChunkyPNG::Datastream}:: represents the internal structure of a PNG {ChunkyPNG::Image}.
+# {ChunkyPNG::Color}::      represents one chunk of data within a {ChunkyPNG::Datastream}.
+# {ChunkyPNG::Point}::      geometry helper class representing a 2-dimensional point.
+# {ChunkyPNG::Dimension}::  geometry helper class representing a dimension (i.e. width x height).
+# {ChunkyPNG::Vector}::     geometry helper class representing a series of points.
+#
+# @author Willem van Bergen
+#
+# source://chunky_png//lib/chunky_png.rb#25
+module ChunkyPNG
+  class << self
+    # Factory method to return a color value, based on the arguments given.
+    #
+    # @overload Color
+    # @overload Color
+    # @overload Color
+    # @overload Color
+    # @overload Color
+    # @raise [ArgumentError] if the arguments weren't understood as a color.
+    # @return [Integer] The determined color value as RGBA integer.
+    # @see ChunkyPNG::Color
+    # @see ChunkyPNG::Color.parse
+    #
+    # source://chunky_png//lib/chunky_png/color.rb#33
+    def Color(*args); end
+
+    # Creates a {ChunkyPNG::Dimension} instance using arguments that can be interpreted
+    # as width and height.
+    #
+    # @overload Dimension
+    # @overload Dimension
+    # @overload Dimension
+    # @overload Dimension
+    # @raise [ArgumentError] If the argument(s) given where not understood as a dimension.
+    # @return [ChunkyPNG::Dimension] The dimension created by this factory method.
+    # @see ChunkyPNG::Dimension
+    #
+    # source://chunky_png//lib/chunky_png/dimension.rb#31
+    def Dimension(*args); end
+
+    # Factory method to create {ChunkyPNG::Point} instances.
+    #
+    # This method tries to be as flexible as possible with regards to the given input: besides
+    # explicit coordinates, this method also accepts arrays, hashes, strings, {ChunkyPNG::Dimension}
+    # instances and anything that responds to <tt>:x</tt> and <tt>:y</tt>.
+    #
+    # @overload Point
+    # @overload Point
+    # @overload Point
+    # @overload Point
+    # @raise [ArgumentError] if the arguments weren't understood.
+    # @return [ChunkyPNG::Point]
+    # @see ChunkyPNG::Point
+    #
+    # source://chunky_png//lib/chunky_png/point.rb#32
+    def Point(*args); end
+
+    # Factory method for {ChunkyPNG::Vector} instances.
+    #
+    # @overload Vector
+    # @overload Vector
+    # @overload Vector
+    # @raise [ArgumentError] If the given arguments could not be understood as a vector.
+    # @return [ChunkyPNG::Vector] The vector created by this factory method.
+    # @see ChunkyPNG::Vector
+    #
+    # source://chunky_png//lib/chunky_png/vector.rb#20
+    def Vector(*args); end
+
+    private
+
+    # source://chunky_png//lib/chunky_png/dimension.rb#40
+    def build_dimension_from_object(source); end
+
+    # source://chunky_png//lib/chunky_png/point.rb#41
+    def build_point_from_object(source); end
+  end
+end
+
+# Indicates that the PNG image uses grayscale colors, i.e. only a
+# single teint channel.
+#
+# @private
+#
+# source://chunky_png//lib/chunky_png.rb#33
+ChunkyPNG::COLOR_GRAYSCALE = T.let(T.unsafe(nil), Integer)
+
+# Indicates that the PNG image uses grayscale colors with opacity, i.e.
+# a teint channel with an alpha channel.
+#
+# @private
+#
+# source://chunky_png//lib/chunky_png.rb#48
+ChunkyPNG::COLOR_GRAYSCALE_ALPHA = T.let(T.unsafe(nil), Integer)
+
+# Indicates that the PNG image uses indexed colors, where the values
+# point to colors defined on a palette.
+#
+# @private
+#
+# source://chunky_png//lib/chunky_png.rb#43
+ChunkyPNG::COLOR_INDEXED = T.let(T.unsafe(nil), Integer)
+
+# Indicates that the PNG image uses true color, composed of a red
+# green and blue channel.
+#
+# @private
+#
+# source://chunky_png//lib/chunky_png.rb#38
+ChunkyPNG::COLOR_TRUECOLOR = T.let(T.unsafe(nil), Integer)
+
+# Indicates that the PNG image uses true color with opacity, composed of
+# a red, green and blue channel, and an alpha value.
+#
+# @private
+#
+# source://chunky_png//lib/chunky_png.rb#53
+ChunkyPNG::COLOR_TRUECOLOR_ALPHA = T.let(T.unsafe(nil), Integer)
+
+# Indicates that the PNG chunk content is compressed
+# flag used in iTXt chunk
+#
+# @private
+#
+# source://chunky_png//lib/chunky_png.rb#68
+ChunkyPNG::COMPRESSED_CONTENT = T.let(T.unsafe(nil), Integer)
+
+# Indicates that the PNG specification's default compression
+# method is used (Zlib/Deflate)
+#
+# @private
+#
+# source://chunky_png//lib/chunky_png.rb#58
+ChunkyPNG::COMPRESSION_DEFAULT = T.let(T.unsafe(nil), Integer)
+
+# Exception that is raised if the CRC check for a block fails
+#
+# source://chunky_png//lib/chunky_png.rb#123
+class ChunkyPNG::CRCMismatch < ::ChunkyPNG::Exception; end
+
+# The ChunkyPNG::Canvas class represents a raster image as a matrix of
+# pixels.
+#
+# This class supports loading a Canvas from a PNG datastream, and creating a
+# {ChunkyPNG::Datastream PNG datastream} based on this matrix. ChunkyPNG
+# only supports 8-bit color depth, otherwise all of the PNG format's
+# variations are supported for both reading and writing.
+#
+# This class offers per-pixel access to the matrix by using x,y coordinates.
+# It uses a palette (see {ChunkyPNG::Palette}) to keep track of the
+# different colors used in this matrix.
+#
+# The pixels in the canvas are stored as 4-byte fixnum, representing 32-bit
+# RGBA colors (8 bit per channel). The module {ChunkyPNG::Color} is provided
+# to work more easily with these number as color values.
+#
+# The module {ChunkyPNG::Canvas::Operations} is imported for operations on
+# the whole canvas, like cropping and alpha compositing. Simple drawing
+# functions are imported from the {ChunkyPNG::Canvas::Drawing} module.
+#
+# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#4
+class ChunkyPNG::Canvas
+  include ::ChunkyPNG::Canvas::PNGEncoding
+  include ::ChunkyPNG::Canvas::StreamExporting
+  include ::ChunkyPNG::Canvas::DataUrlExporting
+  include ::ChunkyPNG::Canvas::Operations
+  include ::ChunkyPNG::Canvas::Drawing
+  include ::ChunkyPNG::Canvas::Resampling
+  include ::ChunkyPNG::Canvas::Masking
+  extend ::ChunkyPNG::Canvas::PNGDecoding
+  extend ::ChunkyPNG::Canvas::Adam7Interlacing
+  extend ::ChunkyPNG::Canvas::StreamImporting
+  extend ::ChunkyPNG::Canvas::DataUrlImporting
+
+  # Initializes a new Canvas instance.
+  #
+  # @overload initialize
+  # @overload initialize
+  # @return [Canvas] a new instance of Canvas
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#79
+  def initialize(width, height, initial = T.unsafe(nil)); end
+
+  # Equality check to compare this canvas with other matrices.
+  #
+  # @param other The object to compare this Matrix to.
+  # @return [true, false] True if the size and pixel values of the other
+  #   canvas are exactly the same as this canvas's size and pixel values.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#277
+  def ==(other); end
+
+  # Returns a single pixel's color value from this canvas.
+  #
+  # @param x [Integer] The x-coordinate of the pixel (column)
+  # @param y [Integer] The y-coordinate of the pixel (row)
+  # @raise [ChunkyPNG::OutOfBounds] when the coordinates are outside of the
+  #   image's dimensions.
+  # @return [Integer] The current color value at the provided coordinates.
+  # @see #get_pixel
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#174
+  def [](x, y); end
+
+  # Replaces a single pixel in this canvas.
+  #
+  # @param x [Integer] The x-coordinate of the pixel (column)
+  # @param y [Integer] The y-coordinate of the pixel (row)
+  # @param color [Integer] The new color for the provided coordinates.
+  # @raise [ChunkyPNG::OutOfBounds] when the coordinates are outside of the
+  #   image's dimensions.
+  # @return [Integer] The new color value for this pixel, i.e.
+  #   <tt>color</tt>.
+  # @see #set_pixel
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#135
+  def []=(x, y, color); end
+
+  # Returns the area of this canvas in number of pixels.
+  #
+  # @return [Integer] The number of pixels in this canvas
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#122
+  def area; end
+
+  # Returns an extracted column as vector of pixels.
+  #
+  # @param x [Integer] The 0-based column index.
+  # @return [Array<Integer>] The vector of pixels in the requested column.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#200
+  def column(x); end
+
+  # Returns the dimension (width x height) for this canvas.
+  #
+  # @return [ChunkyPNG::Dimension] A dimension instance with the width and
+  #   height set for this canvas.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#116
+  def dimension; end
+
+  # Equality check to compare this canvas with other matrices.
+  #
+  # @param other The object to compare this Matrix to.
+  # @return [true, false] True if the size and pixel values of the other
+  #   canvas are exactly the same as this canvas's size and pixel values.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#277
+  def eql?(other); end
+
+  # Returns a single pixel from this canvas, without checking bounds. The
+  # return value for this method is undefined if the coordinates are out of
+  # bounds.
+  #
+  # @param x [Integer] The x-coordinate of the pixel (column)
+  # @param y [Integer] The y-coordinate of the pixel (row)
+  # @return [Integer] The current pixel at the provided coordinates.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#185
+  def get_pixel(x, y); end
+
+  # @return [Integer] The number of rows in this canvas
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#55
+  def height; end
+
+  # Checks whether the given coordinates are in the range of the canvas
+  #
+  # @param point_like [ChunkyPNG::Point, Array, Hash, String] The point to
+  #   check.
+  # @return [true, false] True if the x and y coordinates of the point are
+  #   within the limits of this canvas.
+  # @see ChunkyPNG.Point
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#233
+  def include?(*point_like); end
+
+  # Checks whether the given coordinates are in the range of the canvas
+  #
+  # @param point_like [ChunkyPNG::Point, Array, Hash, String] The point to
+  #   check.
+  # @return [true, false] True if the x and y coordinates of the point are
+  #   within the limits of this canvas.
+  # @see ChunkyPNG.Point
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#233
+  def include_point?(*point_like); end
+
+  # Checks whether the given x-coordinate is in the range of the canvas
+  #
+  # @param x [Integer] The y-coordinate of the pixel (column)
+  # @return [true, false] True if the x-coordinate is in the range of this
+  #   canvas.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#262
+  def include_x?(x); end
+
+  # Checks whether the given x- and y-coordinate are in the range of the
+  # canvas
+  #
+  # @param x [Integer] The x-coordinate of the pixel (column)
+  # @param y [Integer] The y-coordinate of the pixel (row)
+  # @return [true, false] True if the x- and y-coordinate is in the range of
+  #   this canvas.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#246
+  def include_xy?(x, y); end
+
+  # Checks whether the given y-coordinate is in the range of the canvas
+  #
+  # @param y [Integer] The y-coordinate of the pixel (row)
+  # @return [true, false] True if the y-coordinate is in the range of this
+  #   canvas.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#254
+  def include_y?(y); end
+
+  # Alternative implementation of the inspect method.
+  #
+  # @private
+  # @return [String] A nicely formatted string representation of this canvas.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#299
+  def inspect; end
+
+  # Returns the palette used for this canvas.
+  #
+  # @return [ChunkyPNG::Palette] A palette which contains all the colors that
+  #   are being used for this image.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#269
+  def palette; end
+
+  # @return [Array<ChunkyPNG::Color>] The list of pixels in this canvas.
+  #   This array always should have +width * height+ elements.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#59
+  def pixels; end
+
+  # Replaces a column of pixels on this canvas.
+  #
+  # @param x [Integer] The 0-based column index.
+  # @param vector [Array<Integer>] The vector of pixels to replace the column
+  #   with.
+  # @return [void]
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#220
+  def replace_column!(x, vector); end
+
+  # Replaces a row of pixels on this canvas.
+  #
+  # @param y [Integer] The 0-based row index.
+  # @param vector [Array<Integer>] The vector of pixels to replace the row
+  #   with.
+  # @return [void]
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#210
+  def replace_row!(y, vector); end
+
+  # Returns an extracted row as vector of pixels
+  #
+  # @param y [Integer] The 0-based row index
+  # @return [Array<Integer>] The vector of pixels in the requested row
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#192
+  def row(y); end
+
+  # Replaces a single pixel in this canvas, without bounds checking.
+  #
+  # This method return value and effects are undefined for coordinates
+  # out of bounds of the canvas.
+  #
+  # @param x [Integer] The x-coordinate of the pixel (column)
+  # @param y [Integer] The y-coordinate of the pixel (row)
+  # @param color [Integer] The new color for the provided coordinates.
+  # @return [Integer] The new color value for this pixel, i.e.
+  #   <tt>color</tt>.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#150
+  def set_pixel(x, y, color); end
+
+  # Replaces a single pixel in this canvas, with bounds checking. It will do
+  # noting if the provided coordinates are out of bounds.
+  #
+  # @param x [Integer] The x-coordinate of the pixel (column)
+  # @param y [Integer] The y-coordinate of the pixel (row)
+  # @param color [Integer] The new color value for the provided coordinates.
+  # @return [Integer] The new color value for this pixel, i.e.
+  #   <tt>color</tt>, or <tt>nil</tt> if the coordinates are out of bounds.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#162
+  def set_pixel_if_within_bounds(x, y, color); end
+
+  # Creates an ChunkyPNG::Image object from this canvas.
+  #
+  # @return [ChunkyPNG::Image] This canvas wrapped in an Image instance.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#292
+  def to_image; end
+
+  # @return [Integer] The number of columns in this canvas
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#52
+  def width; end
+
+  protected
+
+  # Throws an exception if the vector_length does not match this canvas'
+  # height.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#344
+  def assert_height!(vector_length); end
+
+  # Throws an exception if the matrix width and height does not match this canvas' dimensions.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#363
+  def assert_size!(matrix_width, matrix_height); end
+
+  # Throws an exception if the vector_length does not match this canvas'
+  # width.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#354
+  def assert_width!(vector_length); end
+
+  # Throws an exception if the x-coordinate is out of bounds.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#319
+  def assert_x!(x); end
+
+  # Throws an exception if the x- or y-coordinate is out of bounds.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#335
+  def assert_xy!(x, y); end
+
+  # Throws an exception if the y-coordinate is out of bounds.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#327
+  def assert_y!(y); end
+
+  # Replaces the image, given a new width, new height, and a new pixel array.
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#310
+  def replace_canvas!(new_width, new_height, new_pixels); end
+
+  private
+
+  # Initializes a new Canvas instances when being cloned.
+  #
+  # @param other [ChunkyPNG::Canvas] The canvas to duplicate
+  # @private
+  # @return [void]
+  #
+  # source://chunky_png//lib/chunky_png/canvas.rb#97
+  def initialize_copy(other); end
+
+  class << self
+    # Creates a new canvas instance by duplicating another instance.
+    #
+    # @param canvas [ChunkyPNG::Canvas] The canvas to duplicate
+    # @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
+    #
+    # source://chunky_png//lib/chunky_png/canvas.rb#105
+    def from_canvas(canvas); end
+  end
+end
+
+# Methods for decoding and encoding Adam7 interlacing.
+#
+# Adam7 interlacing extracts 7 pass images out of a single image, that can be encoded to a
+# stream separately so the image can be built up progressively. The module is included into
+# ChunkyPNG canvas and is used to extract the pass images from the original image, or to
+# reconstruct an original image from separate pass images.
+#
+# source://chunky_png//lib/chunky_png/canvas/adam7_interlacing.rb#11
+module ChunkyPNG::Canvas::Adam7Interlacing
+  # Extracts a pass from a complete image
+  #
+  # @param pass [Integer] The pass number, should be in 0..6.
+  # @param canvas [ChunkyPNG::Canvas] The image that is being deconstructed.
+  # @return [ChunkyPNG::Canvas] The extracted pass image.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/adam7_interlacing.rb#63
+  def adam7_extract_pass(pass, canvas); end
+
+  # Merges a pass image into a total image that is being constructed.
+  #
+  # @param pass [Integer] The pass number, should be in 0..6.
+  # @param canvas [ChunkyPNG::Canvas] The image that is being constructed.
+  # @param subcanvas [ChunkyPNG::Canvas] The pass image that should be merged
+  #
+  # source://chunky_png//lib/chunky_png/canvas/adam7_interlacing.rb#48
+  def adam7_merge_pass(pass, canvas, subcanvas); end
+
+  # Returns an array with the x-shift, x-offset, y-shift and y-offset for the requested pass.
+  #
+  # @param pass [Integer] The pass number, should be in 0..6.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/adam7_interlacing.rb#14
+  def adam7_multiplier_offset(pass); end
+
+  # Returns the pixel dimensions of the requested pass.
+  #
+  # @param pass [Integer] The pass number, should be in 0..6.
+  # @param original_width [Integer] The width of the original image.
+  # @param original_height [Integer] The height of the original image.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/adam7_interlacing.rb#27
+  def adam7_pass_size(pass, original_width, original_height); end
+
+  # Returns an array of the dimension of all the pass images.
+  #
+  # @param original_width [Integer] The width of the original image.
+  # @param original_height [Integer] The height of the original image.
+  # @return [Array<Array<Integer>>] Returns an array with 7 pairs of dimensions.
+  # @see #adam7_pass_size
+  #
+  # source://chunky_png//lib/chunky_png/canvas/adam7_interlacing.rb#40
+  def adam7_pass_sizes(original_width, original_height); end
+end
+
+# Methods to export a canvas to a PNG data URL.
+#
+# source://chunky_png//lib/chunky_png/canvas/data_url_exporting.rb#6
+module ChunkyPNG::Canvas::DataUrlExporting
+  # Exports the canvas as a data url (e.g. data:image/png;base64,<data>) that can
+  # easily be used inline in CSS or HTML.
+  #
+  # @return [String] The canvas formatted as a data URL string.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/data_url_exporting.rb#10
+  def to_data_url; end
+end
+
+# Methods to import a canvas from a PNG data URL.
+#
+# source://chunky_png//lib/chunky_png/canvas/data_url_importing.rb#6
+module ChunkyPNG::Canvas::DataUrlImporting
+  # Imports a canvas from a PNG data URL.
+  #
+  # @param string [String] The data URL string to load from.
+  # @raise ChunkyPNG::SignatureMismatch if the provides string is not a properly
+  #   formatted PNG data URL (i.e. it should start with "data:image/png;base64,")
+  # @return [Canvas] The imported canvas.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/data_url_importing.rb#12
+  def from_data_url(string); end
+end
+
+# Module that adds some primitive drawing methods to {ChunkyPNG::Canvas}.
+#
+# All of these methods change the current canvas instance and do not create
+# a new one, even though the method names do not end with a bang.
+#
+# @note Drawing operations will not fail when something is drawn outside of
+#   the bounds of the canvas; these pixels will simply be ignored.
+# @see ChunkyPNG::Canvas
+#
+# source://chunky_png//lib/chunky_png/canvas/drawing.rb#13
+module ChunkyPNG::Canvas::Drawing
+  # Draws a Bezier curve
+  #
+  # @param points [Array, Point] A collection of control points
+  # @param stroke_color [Integer]
+  # @return [Chunky:PNG::Canvas] Itself, with the curve drawn
+  #
+  # source://chunky_png//lib/chunky_png/canvas/drawing.rb#39
+  def bezier_curve(points, stroke_color = T.unsafe(nil)); end
+
+  # Draws a circle on the canvas.
+  #
+  # @param x0 [Integer] The x-coordinate of the center of the circle.
+  # @param y0 [Integer] The y-coordinate of the center of the circle.
+  # @param radius [Integer] The radius of the circle from the center point.
+  # @param stroke_color [Integer] The color to use for the line.
+  # @param fill_color [Integer] The color to use that fills the circle.
+  # @return [ChunkyPNG::Canvas] Itself, with the circle drawn.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/drawing.rb#241
+  def circle(x0, y0, radius, stroke_color = T.unsafe(nil), fill_color = T.unsafe(nil)); end
+
+  # Composes a pixel on the canvas by alpha blending a color with its
+  # background color.
+  #
+  # @param x [Integer] The x-coordinate of the pixel to blend.
+  # @param y [Integer] The y-coordinate of the pixel to blend.
+  # @param color [Integer] The foreground color to blend with
+  # @return [Integer] The composed color.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/drawing.rb#21
+  def compose_pixel(x, y, color); end
+
+  # Composes a pixel on the canvas by alpha blending a color with its
+  # background color, without bounds checking.
+  #
+  # @param x [Integer] The x-coordinate of the pixel to blend.
+  # @param y [Integer] The y-coordinate of the pixel to blend.
+  # @param color [Integer] The foreground color to blend with
+  # @return [Integer] The composed color.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/drawing.rb#31
+  def compose_pixel_unsafe(x, y, color); end
+
+  # Draws an anti-aliased line using Xiaolin Wu's algorithm.
+  #
+  # @param x0 [Integer] The x-coordinate of the first control point.
+  # @param y0 [Integer] The y-coordinate of the first control point.
+  # @param x1 [Integer] The x-coordinate of the second control point.
+  # @param y1 [Integer] The y-coordinate of the second control point.
+  # @param stroke_color [Integer] The color to use for this line.
+  # @param inclusive [true, false] Whether to draw the last pixel. Set to
+  #   false when drawing multiple lines in a path.
+  # @return [ChunkyPNG::Canvas] Itself, with the line drawn.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/drawing.rb#94
+  def line(x0, y0, x1, y1, stroke_color, inclusive = T.unsafe(nil)); end
+
+  # Draws an anti-aliased line using Xiaolin Wu's algorithm.
+  #
+  # @param x0 [Integer] The x-coordinate of the first control point.
+  # @param y0 [Integer] The y-coordinate of the first control point.
+  # @param x1 [Integer] The x-coordinate of the second control point.
+  # @param y1 [Integer] The y-coordinate of the second control point.
+  # @param stroke_color [Integer] The color to use for this line.
+  # @param inclusive [true, false] Whether to draw the last pixel. Set to
+  #   false when drawing multiple lines in a path.
+  # @return [ChunkyPNG::Canvas] Itself, with the line drawn.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/drawing.rb#94
+  def line_xiaolin_wu(x0, y0, x1, y1, stroke_color, inclusive = T.unsafe(nil)); end
+
+  # Draws a polygon on the canvas using the stroke_color, filled using the
+  # fill_color if any.
+  #
+  # @param path [Array, String] The control point vector. Accepts everything
+  #   {ChunkyPNG.Vector} accepts.
+  # @param stroke_color [Integer] The stroke color to use for this polygon.
+  # @param fill_color [Integer] The fill color to use for this polygon.
+  # @return [ChunkyPNG::Canvas] Itself, with the polygon drawn.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/drawing.rb#166
+  def polygon(path, stroke_color = T.unsafe(nil), fill_color = T.unsafe(nil)); end
+
+  # Draws a rectangle on the canvas, using two control points.
+  #
+  # @param x0 [Integer] The x-coordinate of the first control point.
+  # @param y0 [Integer] The y-coordinate of the first control point.
+  # @param x1 [Integer] The x-coordinate of the second control point.
+  # @param y1 [Integer] The y-coordinate of the second control point.
+  # @param stroke_color [Integer] The line color to use for this rectangle.
+  # @param fill_color [Integer] The fill color to use for this rectangle.
+  # @return [ChunkyPNG::Canvas] Itself, with the rectangle drawn.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/drawing.rb#211
+  def rect(x0, y0, x1, y1, stroke_color = T.unsafe(nil), fill_color = T.unsafe(nil)); end
+
+  private
+
+  # Calculates the binomial coefficient for n over k.
+  #
+  # @param n [Integer] first parameter in coeffient (the number on top when
+  #   looking at the mathematic formula)
+  # @param k [Integer] k-element, second parameter in coeffient (the number
+  #   on the bottom when looking at the mathematic formula)
+  # @return [Integer] The binomial coeffcient of (n,k)
+  #
+  # source://chunky_png//lib/chunky_png/canvas/drawing.rb#311
+  def binomial_coefficient(n, k); end
+end
+
+# The ChunkyPNG::Canvas::Masking module defines methods to perform masking
+# and theming operations on a {ChunkyPNG::Canvas}. The module is included into the Canvas class so all
+# these methods are available on every canvas.
+#
+# @see ChunkyPNG::Canvas
+#
+# source://chunky_png//lib/chunky_png/canvas/masking.rb#10
+module ChunkyPNG::Canvas::Masking
+  # Changes the color of a mask image.
+  #
+  # This method works on a canvas extracted out of another image using the {#extract_mask} method.
+  # It can then be applied on the extracted base image. See {#change_theme_color!} to perform
+  # these operations in one go.
+  #
+  # @param new_color [Integer] The color to replace the original mask color with.
+  # @raise [ChunkyPNG::ExpectationFailed] when this canvas is not a mask image, i.e. its palette
+  #   has more than once color, disregarding transparency.
+  # @see #change_theme_color!
+  # @see #extract_mask
+  #
+  # source://chunky_png//lib/chunky_png/canvas/masking.rb#84
+  def change_mask_color!(new_color); end
+
+  # Creates a new image, based on the current image but with a new theme color.
+  #
+  # This method will replace one color in an image with another image. This is done by
+  # first extracting the pixels with a color close to the original theme color as a mask
+  # image, changing the color of this mask image and then apply it on the original image.
+  #
+  # Mask extraction works best when the theme colored pixels are clearly distinguishable
+  # from a background color (preferably white). You can set a tolerance level to influence
+  # the extraction process.
+  #
+  # @param old_theme_color [Integer] The original theme color in this image.
+  # @param new_theme_color [Integer] The color to replace the old theme color with.
+  # @param bg_color [Integer] The background color on which the theme colored pixels are placed.
+  # @param tolerance [Integer] The tolerance level to use when extracting the mask image. Five is
+  #   the default; increase this if the masked image does not extract all the required pixels,
+  #   decrease it if too many pixels get extracted.
+  # @return [ChunkyPNG::Canvas] Returns itself, but with the theme colored pixels changed.
+  # @see #change_theme_color!
+  # @see #change_mask_color!
+  #
+  # source://chunky_png//lib/chunky_png/canvas/masking.rb#30
+  def change_theme_color!(old_theme_color, new_theme_color, bg_color = T.unsafe(nil), tolerance = T.unsafe(nil)); end
+
+  # Creates a base image and a mask image from an original image that has a particular theme color.
+  # This can be used to easily change a theme color in an image.
+  #
+  # It will extract all the pixels that look like the theme color (with a tolerance level) and put
+  # these in a mask image. All the other pixels will be stored in a base image. Both images will be
+  # of the exact same size as the original image. The original image will be left untouched.
+  #
+  # The color of the mask image can be changed with {#change_mask_color!}. This new mask image can
+  # then be composed upon the base image to create an image with a new theme color. A call to
+  # {#change_theme_color!} will perform this in one go.
+  #
+  # @param mask_color [Integer] The current theme color.
+  # @param bg_color [Integer] The background color on which the theme colored pixels are applied.
+  # @param tolerance [Integer] The tolerance level to use when extracting the mask image. Five is
+  #   the default; increase this if the masked image does not extract all the required pixels,
+  #   decrease it if too many pixels get extracted.
+  # @return [Array<ChunkyPNG::Canvas, ChunkyPNG::Canvas>] An array with the base canvas and the mask
+  #   canvas as elements.
+  # @see #change_theme_color!
+  # @see #change_mask_color!
+  #
+  # source://chunky_png//lib/chunky_png/canvas/masking.rb#56
+  def extract_mask(mask_color, bg_color = T.unsafe(nil), tolerance = T.unsafe(nil)); end
+end
+
+# The ChunkyPNG::Canvas::Operations module defines methods to perform
+# operations on a {ChunkyPNG::Canvas}. The module is included into the
+# Canvas class so all these methods are available on every canvas.
+#
+# Note that some of these operations modify the canvas, while some
+# operations return a new canvas and leave the original intact.
+#
+# @see ChunkyPNG::Canvas
+#
+# source://chunky_png//lib/chunky_png/canvas/operations.rb#13
+module ChunkyPNG::Canvas::Operations
+  # Draws a border around the image.
+  #
+  # @param size [Integer] The size of the border.
+  # @param color [Integer] The color of the border.
+  # @return [ChunkyPNG::Canvas] Returns a bordered version of the image.
+  # @see #border!
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#366
+  def border(size, color = T.unsafe(nil)); end
+
+  # Draws a border around the image in place.
+  #
+  # @param size [Integer] The size of the border.
+  # @param color [Integer] The color of the border.
+  # @return [ChunkyPNG::Canvas] Returns itself with the border added.
+  # @see #border
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#376
+  def border!(size, color = T.unsafe(nil)); end
+
+  # Composes another image onto this image using alpha blending. This will
+  # return a new canvas and leave the original intact.
+  #
+  # If you simply want to replace pixels or when the other image does not
+  # have transparency, it is faster to use {#replace}.
+  #
+  # @note API changed since 1.0 - This method now no longer is in place,
+  #   but returns a new canvas and leaves the original intact. Use
+  #   {#compose!} if you want to compose on the canvas in place.
+  # @param other [ChunkyPNG::Canvas] The foreground canvas to compose on
+  #   the current canvas, using alpha compositing.
+  # @param offset_x [Integer] The x-offset to apply the new foreground on.
+  # @param offset_y [Integer] The y-offset to apply the new foreground on.
+  # @raise [ChunkyPNG::OutOfBounds] when the other canvas doesn't fit on
+  #   this one, given the offset and size of the other canvas.
+  # @return [ChunkyPNG::Canvas] Returns the new canvas, composed of the
+  #   other 2.
+  # @see #replace
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#90
+  def compose(other, offset_x = T.unsafe(nil), offset_y = T.unsafe(nil)); end
+
+  # Composes another image onto this image using alpha blending. This will
+  # modify the current canvas.
+  #
+  # If you simply want to replace pixels or when the other image does not
+  # have transparency, it is faster to use {#replace!}.
+  #
+  # @param other [ChunkyPNG::Canvas] The foreground canvas to compose on
+  #   the current canvas, using alpha compositing.
+  # @param offset_x [Integer] The x-offset to apply the new foreground on.
+  # @param offset_y [Integer] The y-offset to apply the new foreground on.
+  # @raise [ChunkyPNG::OutOfBounds] when the other canvas doesn't fit on
+  #   this one, given the offset and size of the other canvas.
+  # @return [ChunkyPNG::Canvas] Returns itself, but with the other canvas
+  #   composed onto it.
+  # @see #replace!
+  # @see #compose
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#56
+  def compose!(other, offset_x = T.unsafe(nil), offset_y = T.unsafe(nil)); end
+
+  # Crops an image, given the coordinates and size of the image that needs
+  # to be cut out. This will leave the original image intact and return a
+  # new, cropped image with pixels copied from the original image.
+  #
+  # @param x [Integer] The x-coordinate of the top left corner of the image
+  #   to be cropped.
+  # @param y [Integer] The y-coordinate of the top left corner of the image
+  #   to be cropped.
+  # @param crop_width [Integer] The width of the image to be cropped.
+  # @param crop_height [Integer] The height of the image to be cropped.
+  # @raise [ChunkyPNG::OutOfBounds] when the crop dimensions plus the given
+  #   coordinates are bigger then the original image.
+  # @return [ChunkyPNG::Canvas] Returns the newly created cropped image.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#155
+  def crop(x, y, crop_width, crop_height); end
+
+  # Crops an image, given the coordinates and size of the image that needs
+  # to be cut out.
+  #
+  # This will change the size and content of the current canvas. Use
+  # {#crop} if you want to have a new canvas returned instead, leaving the
+  # current canvas intact.
+  #
+  # @param x [Integer] The x-coordinate of the top left corner of the image
+  #   to be cropped.
+  # @param y [Integer] The y-coordinate of the top left corner of the image
+  #   to be cropped.
+  # @param crop_width [Integer] The width of the image to be cropped.
+  # @param crop_height [Integer] The height of the image to be cropped.
+  # @raise [ChunkyPNG::OutOfBounds] when the crop dimensions plus the given
+  #   coordinates are bigger then the original image.
+  # @return [ChunkyPNG::Canvas] Returns itself, but cropped.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#175
+  def crop!(x, y, crop_width, crop_height); end
+
+  # Flips the image horizontally, leaving the original intact.
+  #
+  # This will flip the image on its horizontal axis, e.g. pixels on the top
+  # will now be pixels on the bottom. Chaining this method twice will
+  # return the original canvas. This method will leave the original object
+  # intact and return a new canvas.
+  #
+  # @return [ChunkyPNG::Canvas] The flipped image
+  # @see #flip_horizontally!
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#205
+  def flip; end
+
+  # Flips the image horizontally in place.
+  #
+  # This will flip the image on its horizontal axis, e.g. pixels on the top
+  # will now be pixels on the bottom. Chaining this method twice will
+  # return the original canvas. This method will leave the original object
+  # intact and return a new canvas.
+  #
+  # @return [ChunkyPNG::Canvas] Itself, but flipped
+  # @see #flip_horizontally
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#218
+  def flip!; end
+
+  # Flips the image horizontally, leaving the original intact.
+  #
+  # This will flip the image on its horizontal axis, e.g. pixels on the top
+  # will now be pixels on the bottom. Chaining this method twice will
+  # return the original canvas. This method will leave the original object
+  # intact and return a new canvas.
+  #
+  # @return [ChunkyPNG::Canvas] The flipped image
+  # @see #flip_horizontally!
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#205
+  def flip_horizontally; end
+
+  # Flips the image horizontally in place.
+  #
+  # This will flip the image on its horizontal axis, e.g. pixels on the top
+  # will now be pixels on the bottom. Chaining this method twice will
+  # return the original canvas. This method will leave the original object
+  # intact and return a new canvas.
+  #
+  # @return [ChunkyPNG::Canvas] Itself, but flipped
+  # @see #flip_horizontally
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#218
+  def flip_horizontally!; end
+
+  # Flips the image vertically, leaving the original intact.
+  #
+  # This will flip the image on its vertical axis, e.g. pixels on the left
+  # will now be pixels on the right. Chaining this method twice will return
+  # the original canvas. This method will leave the original object intact
+  # and return a new canvas.
+  #
+  # @return [ChunkyPNG::Canvas] The flipped image
+  # @see #flip_vertically!
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#240
+  def flip_vertically; end
+
+  # Flips the image vertically in place.
+  #
+  # This will flip the image on its vertical axis, e.g. pixels on the left
+  # will now be pixels on the right. Chaining this method twice will return
+  # the original canvas. This method will leave the original object intact
+  # and return a new canvas.
+  #
+  # @return [ChunkyPNG::Canvas] Itself, but flipped
+  # @see #flip_vertically
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#253
+  def flip_vertically!; end
+
+  # Converts the canvas to grayscale, returning a new canvas.
+  #
+  # This method will not modify the canvas. To modift the current canvas,
+  # use {#grayscale!} instead.
+  #
+  # @return [ChunkyPNG::Canvas] A copy of the canvas, converted to
+  #   grayscale.
+  # @see #grayscale!
+  # @see ChunkyPNG::Color#to_grayscale
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#36
+  def grayscale; end
+
+  # Converts the canvas to grayscale.
+  #
+  # This method will modify the canvas. The obtain a new canvas and leave
+  # the current instance intact, use {#grayscale} instead.
+  #
+  # @return [ChunkyPNG::Canvas] Returns itself, converted to grayscale.
+  # @see #grayscale
+  # @see ChunkyPNG::Color#to_grayscale
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#22
+  def grayscale!; end
+
+  # Flips the image vertically, leaving the original intact.
+  #
+  # This will flip the image on its vertical axis, e.g. pixels on the left
+  # will now be pixels on the right. Chaining this method twice will return
+  # the original canvas. This method will leave the original object intact
+  # and return a new canvas.
+  #
+  # @return [ChunkyPNG::Canvas] The flipped image
+  # @see #flip_vertically!
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#240
+  def mirror; end
+
+  # Flips the image vertically in place.
+  #
+  # This will flip the image on its vertical axis, e.g. pixels on the left
+  # will now be pixels on the right. Chaining this method twice will return
+  # the original canvas. This method will leave the original object intact
+  # and return a new canvas.
+  #
+  # @return [ChunkyPNG::Canvas] Itself, but flipped
+  # @see #flip_vertically
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#253
+  def mirror!; end
+
+  # Replaces pixels on this image by pixels from another pixels, on a given
+  # offset. This method will modify the current canvas.
+  #
+  # This will completely replace the pixels of the background image. If you
+  # want to blend them with semi-transparent pixels from the foreground
+  # image, see {#compose!}.
+  #
+  # @note API changed since 1.0 - This method now no longer is in place,
+  #   but returns a new canvas and leaves the original intact. Use
+  #   {#replace!} if you want to replace pixels on the canvas in place.
+  # @param other [ChunkyPNG::Canvas] The foreground canvas to get the
+  #   pixels from.
+  # @param offset_x [Integer] The x-offset to apply the new foreground on.
+  # @param offset_y [Integer] The y-offset to apply the new foreground on.
+  # @raise [ChunkyPNG::OutOfBounds] when the other canvas doesn't fit on
+  #   this one, given the offset and size of the other canvas.
+  # @return [ChunkyPNG::Canvas] Returns a new, combined canvas.
+  # @see #compose
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#138
+  def replace(other, offset_x = T.unsafe(nil), offset_y = T.unsafe(nil)); end
+
+  # Replaces pixels on this image by pixels from another pixels, on a given
+  # offset. This method will modify the current canvas.
+  #
+  # This will completely replace the pixels of the background image. If you
+  # want to blend them with semi-transparent pixels from the foreground
+  # image, see {#compose!}.
+  #
+  # @param other [ChunkyPNG::Canvas] The foreground canvas to get the
+  #   pixels from.
+  # @param offset_x [Integer] The x-offset to apply the new foreground on.
+  # @param offset_y [Integer] The y-offset to apply the new foreground on.
+  # @raise [ChunkyPNG::OutOfBounds] when the other canvas doesn't fit on
+  #   this one, given the offset and size of the other canvas.
+  # @return [ChunkyPNG::Canvas] Returns itself, but with the other canvas
+  #   placed onto it.
+  # @see #compose!
+  # @see #replace
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#111
+  def replace!(other, offset_x = T.unsafe(nil), offset_y = T.unsafe(nil)); end
+
+  # Rotates the image 180 degrees.
+  #
+  # This method will leave the original object intact and return a new
+  # canvas.
+  #
+  # @return [ChunkyPNG::Canvas] The rotated image.
+  # @see #rotate_180!
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#322
+  def rotate_180; end
+
+  # Rotates the image 180 degrees in place.
+  #
+  # @return [ChunkyPNG::Canvas] Itself, but rotated 180 degrees.
+  # @see #rotate_180
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#330
+  def rotate_180!; end
+
+  # Returns a new canvas instance that is rotated 90 degrees clockwise.
+  #
+  # This method will return a new canvas and leaves the original intact.
+  #
+  # @return [ChunkyPNG::Canvas] A clockwise-rotated copy.
+  # @see #rotate_right! for the in place version.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#269
+  def rotate_clockwise; end
+
+  # Rotates the image 90 degrees clockwise in place.
+  #
+  # This method will change the current canvas.
+  #
+  # @return [ChunkyPNG::Canvas] Itself, but rotated clockwise.
+  # @see #rotate_right for a version that leaves the current canvas intact
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#279
+  def rotate_clockwise!; end
+
+  # Returns an image that is rotated 90 degrees counter-clockwise.
+  #
+  # This method will leave the original object intact and return a new
+  # canvas.
+  #
+  # @return [ChunkyPNG::Canvas] A rotated copy of itself.
+  # @see #rotate_left! for the in-place version.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#295
+  def rotate_counter_clockwise; end
+
+  # Rotates the image 90 degrees counter-clockwise in place.
+  #
+  # This method will change the original canvas. See {#rotate_left} for a
+  # version that leaves the canvas intact and returns a new rotated canvas
+  # instead.
+  #
+  # @return [ChunkyPNG::Canvas] Itself, but rotated.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#306
+  def rotate_counter_clockwise!; end
+
+  # Returns an image that is rotated 90 degrees counter-clockwise.
+  #
+  # This method will leave the original object intact and return a new
+  # canvas.
+  #
+  # @return [ChunkyPNG::Canvas] A rotated copy of itself.
+  # @see #rotate_left! for the in-place version.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#295
+  def rotate_left; end
+
+  # Rotates the image 90 degrees counter-clockwise in place.
+  #
+  # This method will change the original canvas. See {#rotate_left} for a
+  # version that leaves the canvas intact and returns a new rotated canvas
+  # instead.
+  #
+  # @return [ChunkyPNG::Canvas] Itself, but rotated.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#306
+  def rotate_left!; end
+
+  # Returns a new canvas instance that is rotated 90 degrees clockwise.
+  #
+  # This method will return a new canvas and leaves the original intact.
+  #
+  # @return [ChunkyPNG::Canvas] A clockwise-rotated copy.
+  # @see #rotate_right! for the in place version.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#269
+  def rotate_right; end
+
+  # Rotates the image 90 degrees clockwise in place.
+  #
+  # This method will change the current canvas.
+  #
+  # @return [ChunkyPNG::Canvas] Itself, but rotated clockwise.
+  # @see #rotate_right for a version that leaves the current canvas intact
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#279
+  def rotate_right!; end
+
+  # Trims the border around the image, presumed to be the color of the
+  # first pixel.
+  #
+  # @param border [Integer] The color to attempt to trim.
+  # @return [ChunkyPNG::Canvas] The trimmed image.
+  # @see #trim!
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#341
+  def trim(border = T.unsafe(nil)); end
+
+  # Trims the border around the image in place.
+  #
+  # @param border [Integer] The color to attempt to trim.
+  # @return [ChunkyPNG::Canvas] Returns itself, but with the border
+  #   trimmed.
+  # @see #trim
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#351
+  def trim!(border = T.unsafe(nil)); end
+
+  protected
+
+  # Checks whether another image has the correct dimension to be used for
+  # an operation on the current image, given an offset coordinate to work
+  # with.
+  #
+  # @param other [ChunkyPNG::Canvas] The other canvas
+  # @param offset_x [Integer] The x offset on which the other image will be
+  #   applied.
+  # @param offset_y [Integer] The y offset on which the other image will be
+  #   applied.
+  # @raise [ChunkyPNG::OutOfBounds] when the other image doesn't fit.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/operations.rb#395
+  def check_size_constraints!(other, offset_x, offset_y); end
+end
+
+# The PNGDecoding contains methods for decoding PNG datastreams to create a
+# Canvas object. The datastream can be provided as filename, string or IO
+# stream.
+#
+# Overview of the decoding process:
+#
+# * The optional PLTE and tRNS chunk are decoded for the color palette of
+#   the original image.
+# * The contents of the IDAT chunks is combined, and uncompressed using
+#   Inflate decompression to the image pixelstream.
+# * Based on the color mode, width and height of the original image, which
+#   is read from the PNG header (IHDR chunk), the amount of bytes
+#   per line is determined.
+# * For every line of pixels in the encoded image, the original byte values
+#   are restored by unapplying the milter method for that line.
+# * The read bytes are unfiltered given by the filter function specified by
+#   the first byte of the line.
+# * The unfiltered pixelstream are is into colored pixels, using the color mode.
+# * All lines combined to form the original image.
+#
+# For interlaced images, the original image was split into 7 subimages.
+# These images get decoded just like the process above (from step 3), and get
+# combined to form the original images.
+#
+# @see ChunkyPNG::Canvas::PNGEncoding
+# @see https://www.w3.org/TR/PNG/ The W3C PNG format specification
+#
+# source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#31
+module ChunkyPNG::Canvas::PNGDecoding
+  # Decodes a canvas from a PNG encoded pixelstream, using a given width, height,
+  # color mode and interlacing mode.
+  #
+  # @param stream [String] The pixelstream to read from.
+  # @param width [Integer] The width of the image.
+  # @param height [Integer] The height of the image.
+  # @param color_mode [Integer] The color mode of the encoded pixelstream.
+  # @param depth [Integer] The bit depth of the pixel samples.
+  # @param interlace [Integer] The interlace method of the encoded pixelstream.
+  # @param decoding_palette [ChunkyPNG::Palette] The palette to use to decode colors.
+  # @param transparent_color [Integer] The color that should be considered fully transparent.
+  # @raise [ChunkyPNG::ExpectationFailed]
+  # @return [ChunkyPNG::Canvas] The decoded Canvas instance.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#95
+  def decode_png_pixelstream(stream, width, height, color_mode, depth, interlace, decoding_palette, transparent_color); end
+
+  # Decodes a Canvas from a PNG encoded string.
+  #
+  # @param str [String] The string to read from.
+  # @return [ChunkyPNG::Canvas] The canvas decoded from the PNG encoded string.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#35
+  def from_blob(str); end
+
+  # Decodes the Canvas from a PNG datastream instance.
+  #
+  # @param ds [ChunkyPNG::Datastream] The datastream to decode.
+  # @return [ChunkyPNG::Canvas] The canvas decoded from the PNG datastream.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#60
+  def from_datastream(ds); end
+
+  # Decodes a Canvas from a PNG encoded file.
+  #
+  # @param filename [String] The file to read from.
+  # @return [ChunkyPNG::Canvas] The canvas decoded from the PNG file.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#44
+  def from_file(filename); end
+
+  # Decodes a Canvas from a PNG encoded stream.
+  #
+  # @param io [IO, #read] The stream to read from.
+  # @return [ChunkyPNG::Canvas] The canvas decoded from the PNG stream.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#51
+  def from_io(io); end
+
+  # Decodes a Canvas from a PNG encoded stream.
+  #
+  # @param io [IO, #read] The stream to read from.
+  # @return [ChunkyPNG::Canvas] The canvas decoded from the PNG stream.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#51
+  def from_stream(io); end
+
+  # Decodes a Canvas from a PNG encoded string.
+  #
+  # @param str [String] The string to read from.
+  # @return [ChunkyPNG::Canvas] The canvas decoded from the PNG encoded string.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#35
+  def from_string(str); end
+
+  protected
+
+  # Extract a bit from a byte on a given index.
+  #
+  # @param byte [Integer] The byte (0..255) value to extract a bit from.
+  # @param index [Integer] The index within the byte. This should be 0..7;
+  #   the value will be modded by 8 to enforce this.
+  # @return [Integer] Either 1 or 0.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#168
+  def decode_png_extract_1bit_value(byte, index); end
+
+  # Extract 2 consecutive bits from a byte.
+  #
+  # @param byte [Integer] The byte (0..255) value to extract a 2 bit value from.
+  # @param index [Integer] The index within the byte. This should be either 0, 1, 2, or 3;
+  #   the value will be modded by 4 to enforce this.
+  # @return [Integer] The extracted 2 bit value (0..3)
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#158
+  def decode_png_extract_2bit_value(byte, index); end
+
+  # Extract 4 consecutive bits from a byte.
+  #
+  # @param byte [Integer] The byte (0..255) value to extract a 4 bit value from.
+  # @param index [Integer] The index within the byte. This should be either 0 or 2;
+  #   the value will be modded by 2 to enforce this.
+  # @return [Integer] The extracted 4bit value (0..15)
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#149
+  def decode_png_extract_4bit_value(byte, index); end
+
+  # Decodes a single PNG image pass width a given width, height and color
+  # mode, to a Canvas, starting at the given position in the stream.
+  #
+  # A non-interlaced image only consists of one pass, while an Adam7
+  # image consists of 7 passes that must be combined after decoding.
+  #
+  # @param start_pos [Integer] The position in the pixel stream to start reading.
+  # @param decoding_palette [ChunkyPNG::Palette] The palette to use to decode colors.
+  # @param stream [String] The pixelstream to read from.
+  # @param width [Integer] The width of the image.
+  # @param height [Integer] The height of the image.
+  # @param color_mode [Integer] The color mode of the encoded pixelstream.
+  # @return [ChunkyPNG::Canvas] The decoded Canvas instance.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#383
+  def decode_png_image_pass(stream, width, height, color_mode, depth, start_pos, decoding_palette); end
+
+  # Decodes a scanline of a 16-bit, grayscale image into a row of pixels.
+  #
+  # @return [Array<Integer>] An array of decoded pixels.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#347
+  def decode_png_pixels_from_scanline_grayscale_16bit(stream, pos, width, _decoding_palette); end
+
+  # Decodes a scanline of a 1-bit, grayscale image into a row of pixels.
+  #
+  # @return [Array<Integer>] An array of decoded pixels.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#310
+  def decode_png_pixels_from_scanline_grayscale_1bit(stream, pos, width, _decoding_palette); end
+
+  # Decodes a scanline of a 2-bit, grayscale image into a row of pixels.
+  #
+  # @return [Array<Integer>] An array of decoded pixels.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#320
+  def decode_png_pixels_from_scanline_grayscale_2bit(stream, pos, width, _decoding_palette); end
+
+  # Decodes a scanline of a 4-bit, grayscale image into a row of pixels.
+  #
+  # @return [Array<Integer>] An array of decoded pixels.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#330
+  def decode_png_pixels_from_scanline_grayscale_4bit(stream, pos, width, _decoding_palette); end
+
+  # Decodes a scanline of an 8-bit, grayscale image into a row of pixels.
+  #
+  # @return [Array<Integer>] An array of decoded pixels.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#340
+  def decode_png_pixels_from_scanline_grayscale_8bit(stream, pos, width, _decoding_palette); end
+
+  # Decodes a scanline of a 16-bit, grayscale image with transparency into a row of pixels.
+  #
+  # @return [Array<Integer>] An array of decoded pixels.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#299
+  def decode_png_pixels_from_scanline_grayscale_alpha_16bit(stream, pos, width, _decoding_palette); end
+
+  # Decodes a scanline of an 8-bit, grayscale image with transparency into a row of pixels.
+  #
+  # @return [Array<Integer>] An array of decoded pixels.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#292
+  def decode_png_pixels_from_scanline_grayscale_alpha_8bit(stream, pos, width, _decoding_palette); end
+
+  # Decodes a scanline of a 1-bit, indexed image into a row of pixels.
+  #
+  # @param stream [String] The stream to decode from.
+  # @param pos [Integer] The position in the stream on which the scanline starts (including the filter byte).
+  # @param width [Integer] The width in pixels of the scanline.
+  # @param decoding_palette [ChunkyPNG::Palette] The palette to use to decode colors.
+  # @return [Array<Integer>] An array of decoded pixels.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#214
+  def decode_png_pixels_from_scanline_indexed_1bit(stream, pos, width, decoding_palette); end
+
+  # Decodes a scanline of a 2-bit, indexed image into a row of pixels.
+  #
+  # @return [Array<Integer>] An array of decoded pixels.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#224
+  def decode_png_pixels_from_scanline_indexed_2bit(stream, pos, width, decoding_palette); end
+
+  # Decodes a scanline of a 4-bit, indexed image into a row of pixels.
+  #
+  # @return [Array<Integer>] An array of decoded pixels.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#234
+  def decode_png_pixels_from_scanline_indexed_4bit(stream, pos, width, decoding_palette); end
+
+  # Decodes a scanline of a 8-bit, indexed image into a row of pixels.
+  #
+  # @return [Array<Integer>] An array of decoded pixels.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#244
+  def decode_png_pixels_from_scanline_indexed_8bit(stream, pos, width, decoding_palette); end
+
+  # Returns the method name to use to decode scanlines into pixels.
+  #
+  # @param color_mode [Integer] The color mode of the image.
+  # @param depth [Integer] The bit depth of the image.
+  # @raise [ChunkyPNG::NotSupported] when the color_mode and/or bit depth is not supported.
+  # @return [Symbol] The method name to use for decoding, to be called on the canvas class.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#357
+  def decode_png_pixels_from_scanline_method(color_mode, depth); end
+
+  # Decodes a scanline of a 16-bit, true color image into a row of pixels.
+  #
+  # @return [Array<Integer>] An array of decoded pixels.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#281
+  def decode_png_pixels_from_scanline_truecolor_16bit(stream, pos, width, _decoding_palette); end
+
+  # Decodes a scanline of an 8-bit, true color image into a row of pixels.
+  #
+  # @return [Array<Integer>] An array of decoded pixels.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#274
+  def decode_png_pixels_from_scanline_truecolor_8bit(stream, pos, width, _decoding_palette); end
+
+  # Decodes a scanline of a 16-bit, true color image with transparency into a row of pixels.
+  #
+  # @return [Array<Integer>] An array of decoded pixels.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#258
+  def decode_png_pixels_from_scanline_truecolor_alpha_16bit(stream, pos, width, _decoding_palette); end
+
+  # Decodes a scanline of an 8-bit, true color image with transparency into a row of pixels.
+  #
+  # @return [Array<Integer>] An array of decoded pixels.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#251
+  def decode_png_pixels_from_scanline_truecolor_alpha_8bit(stream, pos, width, _decoding_palette); end
+
+  # Resamples a 16 bit value to an 8 bit value. This will discard some color information.
+  #
+  # @param value [Integer] The 16 bit value to resample.
+  # @return [Integer] The 8 bit resampled value
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#176
+  def decode_png_resample_16bit_value(value); end
+
+  # Resamples a 1 bit value to an 8 bit value.
+  #
+  # @param value [Integer] The 1 bit value to resample.
+  # @return [Integer] The 8 bit resampled value
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#204
+  def decode_png_resample_1bit_value(value); end
+
+  # Resamples a 2 bit value to an 8 bit value.
+  #
+  # @param value [Integer] The 2 bit value to resample.
+  # @return [Integer] The 8 bit resampled value.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#197
+  def decode_png_resample_2bit_value(value); end
+
+  # Resamples a 4 bit value to an 8 bit value.
+  #
+  # @param value [Integer] The 4 bit value to resample.
+  # @return [Integer] The 8 bit resampled value.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#190
+  def decode_png_resample_4bit_value(value); end
+
+  # No-op - available for completeness sake only
+  #
+  # @param value [Integer] The 8 bit value to resample.
+  # @return [Integer] The 8 bit resampled value
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#183
+  def decode_png_resample_8bit_value(value); end
+
+  # Decodes a scanline if it was encoded using filtering.
+  #
+  # It will extract the filtering method from the first byte of the scanline, and uses the
+  # method to change the subsequent bytes to unfiltered values. This will modify the pixelstream.
+  #
+  # The bytes of the scanline can then be used to construct pixels, based on the color mode..
+  #
+  # @param stream [String] The pixelstream to undo the filtering in.
+  # @param pos [Integer] The starting position of the scanline to decode.
+  # @param prev_pos [Integer, nil] The starting position of the previously decoded scanline, or <tt>nil</tt>
+  #   if this is the first scanline of the image.
+  # @param line_length [Integer] The number of bytes in the scanline, discounting the filter method byte.
+  # @param pixel_size [Integer] The number of bytes used per pixel, based on the color mode.
+  # @return [void]
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#421
+  def decode_png_str_scanline(stream, pos, prev_pos, line_length, pixel_size); end
+
+  # Decodes a scanline in a pixelstream that was encoded using AVERAGE filtering.
+  # This will change the pixelstream to have unfiltered values.
+  #
+  # @return [void]
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#464
+  def decode_png_str_scanline_average(stream, pos, prev_pos, line_length, pixel_size); end
+
+  # Decodes a scanline in a pixelstream that was encoded using PAETH filtering.
+  # This will change the pixelstream to have unfiltered values.
+  #
+  # @return [void]
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#476
+  def decode_png_str_scanline_paeth(stream, pos, prev_pos, line_length, pixel_size); end
+
+  # Decodes a scanline in a pixelstream that was encoded using SUB filtering.
+  # This will change the pixelstream to have unfiltered values.
+  #
+  # @return [void]
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#443
+  def decode_png_str_scanline_sub(stream, pos, prev_pos, line_length, pixel_size); end
+
+  # Decodes a scanline that wasn't encoded using filtering. This is a no-op.
+  #
+  # @return [void]
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#435
+  def decode_png_str_scanline_sub_none(stream, pos, prev_pos, line_length, pixel_size); end
+
+  # Decodes a scanline in a pixelstream that was encoded using UP filtering.
+  # This will change the pixelstream to have unfiltered values.
+  #
+  # @return [void]
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#453
+  def decode_png_str_scanline_up(stream, pos, prev_pos, line_length, pixel_size); end
+
+  # Decodes a canvas from a Adam 7 interlaced PNG encoded pixelstream, using a
+  # given width, height and color mode.
+  #
+  # @param decoding_palette [ChunkyPNG::Palette] The palette to use to decode colors.
+  # @param stream [String] The pixelstream to read from.
+  # @param width [Integer] The width of the image.
+  # @param height [Integer] The height of the image.
+  # @param color_mode [Integer] The color mode of the encoded pixelstream.
+  # @param depth [Integer] The bit depth of the pixel samples.
+  # @return [ChunkyPNG::Canvas] The decoded Canvas instance.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#132
+  def decode_png_with_adam7_interlacing(stream, width, height, color_mode, depth, decoding_palette); end
+
+  # Decodes a canvas from a non-interlaced PNG encoded pixelstream, using a
+  # given width, height and color mode.
+  #
+  # @param decoding_palette [ChunkyPNG::Palette] The palette to use to decode colors.
+  # @param stream [String] The pixelstream to read from.
+  # @param width [Integer] The width of the image.
+  # @param height [Integer] The height of the image.
+  # @param color_mode [Integer] The color mode of the encoded pixelstream.
+  # @param depth [Integer] The bit depth of the pixel samples.
+  # @return [ChunkyPNG::Canvas] The decoded Canvas instance.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_decoding.rb#119
+  def decode_png_without_interlacing(stream, width, height, color_mode, depth, decoding_palette); end
+end
+
+# Methods for encoding a Canvas instance into a PNG datastream.
+#
+# Overview of the encoding process:
+#
+# * The image is split up in scanlines (i.e. rows of pixels);
+# * All pixels are encoded as a pixelstream, based on the color mode.
+# * All the pixel bytes in the pixelstream are adjusted using a filtering
+#   method if one is specified.
+# * Compress the resulting string using deflate compression.
+# * Split compressed data over one or more PNG chunks.
+# * These chunks should be embedded in a datastream with at least a IHDR and
+#   IEND chunk and possibly a PLTE chunk.
+#
+# For interlaced images, the initial image is first split into 7 subimages.
+# These images get encoded exactly as above, and the result gets combined
+# before the compression step.
+#
+# @see ChunkyPNG::Canvas::PNGDecoding
+# @see https://www.w3.org/TR/PNG/ The W3C PNG format specification
+#
+# source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#24
+module ChunkyPNG::Canvas::PNGEncoding
+  # The palette used for encoding the image.This is only in used for images
+  # that get encoded using indexed colors.
+  #
+  # @return [ChunkyPNG::Palette]
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#28
+  def encoding_palette; end
+
+  # The palette used for encoding the image.This is only in used for images
+  # that get encoded using indexed colors.
+  #
+  # @return [ChunkyPNG::Palette]
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#28
+  def encoding_palette=(_arg0); end
+
+  # Writes the canvas to a file, encoded as a PNG image.
+  #
+  # @param filename [String] The file to save the PNG image to.
+  # @param constraints [Hash, Symbol] The constraints to use when encoding the canvas.
+  #   This can either be a hash with different constraints, or a symbol which acts as a
+  #   preset for some constraints. If no constraints are given, ChunkyPNG will decide
+  #   for itself how to best create the PNG datastream.
+  #   Supported presets are <tt>:fast_rgba</tt> for quickly saving images with transparency,
+  #   <tt>:fast_rgb</tt> for quickly saving opaque images, and <tt>:best_compression</tt> to
+  #   obtain the smallest possible filesize.
+  # @return [void]
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#42
+  def save(filename, constraints = T.unsafe(nil)); end
+
+  # Encoded the canvas to a PNG formatted string.
+  #
+  # @param constraints [Hash, Symbol] The constraints to use when encoding the canvas.
+  #   This can either be a hash with different constraints, or a symbol which acts as a
+  #   preset for some constraints. If no constraints are given, ChunkyPNG will decide
+  #   for itself how to best create the PNG datastream.
+  #   Supported presets are <tt>:fast_rgba</tt> for quickly saving images with transparency,
+  #   <tt>:fast_rgb</tt> for quickly saving opaque images, and <tt>:best_compression</tt> to
+  #   obtain the smallest possible filesize.
+  # @return [String] The PNG encoded canvas as string.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#49
+  def to_blob(constraints = T.unsafe(nil)); end
+
+  # Converts this Canvas to a datastream, so that it can be saved as a PNG image.
+  #
+  # @option constraints
+  # @option constraints
+  # @option constraints
+  # @option constraints
+  # @param constraints [Hash, Symbol] The constraints to use when encoding the canvas.
+  #   This can either be a hash with different constraints, or a symbol which acts as a
+  #   preset for some constraints. If no constraints are given, ChunkyPNG will decide
+  #   for itself how to best create the PNG datastream.
+  #   Supported presets are <tt>:fast_rgba</tt> for quickly saving images with transparency,
+  #   <tt>:fast_rgb</tt> for quickly saving opaque images, and <tt>:best_compression</tt> to
+  #   obtain the smallest possible filesize.
+  # @return [ChunkyPNG::Datastream] The PNG datastream containing the encoded canvas.
+  # @see ChunkyPNG::Canvas::PNGEncoding#determine_png_encoding
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#74
+  def to_datastream(constraints = T.unsafe(nil)); end
+
+  # Encoded the canvas to a PNG formatted string.
+  #
+  # @return [String] The PNG encoded canvas as string.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#49
+  def to_s(constraints = T.unsafe(nil)); end
+
+  # Encoded the canvas to a PNG formatted string.
+  #
+  # @return [String] The PNG encoded canvas as string.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#49
+  def to_string(constraints = T.unsafe(nil)); end
+
+  # Writes the canvas to an IO stream, encoded as a PNG image.
+  #
+  # @param io [IO] The output stream to write to.
+  # @param constraints [Hash, Symbol] The constraints to use when encoding the canvas.
+  #   This can either be a hash with different constraints, or a symbol which acts as a
+  #   preset for some constraints. If no constraints are given, ChunkyPNG will decide
+  #   for itself how to best create the PNG datastream.
+  #   Supported presets are <tt>:fast_rgba</tt> for quickly saving images with transparency,
+  #   <tt>:fast_rgb</tt> for quickly saving opaque images, and <tt>:best_compression</tt> to
+  #   obtain the smallest possible filesize.
+  # @return [void]
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#34
+  def write(io, constraints = T.unsafe(nil)); end
+
+  protected
+
+  # Determines the best possible PNG encoding variables for this image, by analyzing
+  # the colors used for the image.
+  #
+  # You can provide constraints for the encoding variables by passing a hash with
+  # encoding variables to this method.
+  #
+  # @param constraints [Hash, Symbol] The constraints for the encoding. This can be a
+  #   Hash or a preset symbol.
+  # @return [Hash] A hash with encoding options for {ChunkyPNG::Canvas::PNGEncoding#to_datastream}
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#107
+  def determine_png_encoding(constraints = T.unsafe(nil)); end
+
+  # Encodes the canvas to a stream, in a given color mode.
+  #
+  # @param stream [String] The stream to write to.
+  # @param color_mode [Integer] The color mode to use for encoding.
+  # @param bit_depth [Integer] The bit depth of the image.
+  # @param filtering [Integer] The filtering method to use.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#206
+  def encode_png_image_pass_to_stream(stream, color_mode, bit_depth, filtering); end
+
+  # Encodes the canvas according to the PNG format specification with a given color
+  # mode and Adam7 interlacing.
+  #
+  # This method will split the original canvas in 7 smaller canvases and encode them
+  # one by one, concatenating the resulting strings.
+  #
+  # @param color_mode [Integer] The color mode to use for encoding.
+  # @param bit_depth [Integer] The bit depth of the image.
+  # @param filtering [Integer] The filtering method to use.
+  # @return [String] The PNG encoded canvas as string.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#191
+  def encode_png_image_with_interlacing(color_mode, bit_depth = T.unsafe(nil), filtering = T.unsafe(nil)); end
+
+  # Encodes the canvas according to the PNG format specification with a given color mode.
+  #
+  # @param color_mode [Integer] The color mode to use for encoding.
+  # @param bit_depth [Integer] The bit depth of the image.
+  # @param filtering [Integer] The filtering method to use.
+  # @return [String] The PNG encoded canvas as string.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#175
+  def encode_png_image_without_interlacing(color_mode, bit_depth = T.unsafe(nil), filtering = T.unsafe(nil)); end
+
+  # Encodes a line of pixels using 1-bit grayscale mode.
+  #
+  # @param pixels [Array<Integer>] A row of pixels of the original image.
+  # @return [String] The encoded scanline as binary string
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#307
+  def encode_png_pixels_to_scanline_grayscale_1bit(pixels); end
+
+  # Encodes a line of pixels using 2-bit grayscale mode.
+  #
+  # @param pixels [Array<Integer>] A row of pixels of the original image.
+  # @return [String] The encoded scanline as binary string
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#325
+  def encode_png_pixels_to_scanline_grayscale_2bit(pixels); end
+
+  # Encodes a line of pixels using 2-bit grayscale mode.
+  #
+  # @param pixels [Array<Integer>] A row of pixels of the original image.
+  # @return [String] The encoded scanline as binary string
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#339
+  def encode_png_pixels_to_scanline_grayscale_4bit(pixels); end
+
+  # Encodes a line of pixels using 8-bit grayscale mode.
+  #
+  # @param pixels [Array<Integer>] A row of pixels of the original image.
+  # @return [String] The encoded scanline as binary string
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#350
+  def encode_png_pixels_to_scanline_grayscale_8bit(pixels); end
+
+  # Encodes a line of pixels using 8-bit grayscale alpha mode.
+  #
+  # @param pixels [Array<Integer>] A row of pixels of the original image.
+  # @return [String] The encoded scanline as binary string
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#357
+  def encode_png_pixels_to_scanline_grayscale_alpha_8bit(pixels); end
+
+  # Encodes a line of pixels using 1-bit indexed mode.
+  #
+  # @param pixels [Array<Integer>] A row of pixels of the original image.
+  # @return [String] The encoded scanline as binary string
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#253
+  def encode_png_pixels_to_scanline_indexed_1bit(pixels); end
+
+  # Encodes a line of pixels using 2-bit indexed mode.
+  #
+  # @param pixels [Array<Integer>] A row of pixels of the original image.
+  # @return [String] The encoded scanline as binary string
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#273
+  def encode_png_pixels_to_scanline_indexed_2bit(pixels); end
+
+  # Encodes a line of pixels using 4-bit indexed mode.
+  #
+  # @param pixels [Array<Integer>] A row of pixels of the original image.
+  # @return [String] The encoded scanline as binary string
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#289
+  def encode_png_pixels_to_scanline_indexed_4bit(pixels); end
+
+  # Encodes a line of pixels using 8-bit indexed mode.
+  #
+  # @param pixels [Array<Integer>] A row of pixels of the original image.
+  # @return [String] The encoded scanline as binary string
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#300
+  def encode_png_pixels_to_scanline_indexed_8bit(pixels); end
+
+  # Returns the method name to use to decode scanlines into pixels.
+  #
+  # @param color_mode [Integer] The color mode of the image.
+  # @param depth [Integer] The bit depth of the image.
+  # @raise [ChunkyPNG::NotSupported] when the color_mode and/or bit depth is not supported.
+  # @return [Symbol] The method name to use for decoding, to be called on the canvas class.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#366
+  def encode_png_pixels_to_scanline_method(color_mode, depth); end
+
+  # Encodes a line of pixels using 8-bit truecolor mode.
+  #
+  # @param pixels [Array<Integer>] A row of pixels of the original image.
+  # @return [String] The encoded scanline as binary string
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#239
+  def encode_png_pixels_to_scanline_truecolor_8bit(pixels); end
+
+  # Encodes a line of pixels using 8-bit truecolor alpha mode.
+  #
+  # @param pixels [Array<Integer>] A row of pixels of the original image.
+  # @return [String] The encoded scanline as binary string
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#246
+  def encode_png_pixels_to_scanline_truecolor_alpha_8bit(pixels); end
+
+  # Encodes the canvas according to the PNG format specification with a given color
+  # mode, possibly with interlacing.
+  #
+  # @param color_mode [Integer] The color mode to use for encoding.
+  # @param bit_depth [Integer] The bit depth of the image.
+  # @param interlace [Integer] The interlacing method to use.
+  # @return [String] The PNG encoded canvas as string.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#157
+  def encode_png_pixelstream(color_mode = T.unsafe(nil), bit_depth = T.unsafe(nil), interlace = T.unsafe(nil), filtering = T.unsafe(nil)); end
+
+  # Encodes a scanline of a pixelstream using AVERAGE filtering. This will modify the stream.
+  #
+  # @param stream [String] The pixelstream to work on. This string will be modified.
+  # @param pos [Integer] The starting position of the scanline.
+  # @param prev_pos [Integer, nil] The starting position of the previous scanline. <tt>nil</tt> if
+  #   this is the first line.
+  # @param line_width [Integer] The number of bytes in this scanline, without counting the filtering
+  #   method byte.
+  # @param pixel_size [Integer] The number of bytes used per pixel.
+  # @return [void]
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#417
+  def encode_png_str_scanline_average(stream, pos, prev_pos, line_width, pixel_size); end
+
+  # Encodes a scanline of a pixelstream without filtering. This is a no-op.
+  #
+  # @param stream [String] The pixelstream to work on. This string will be modified.
+  # @param pos [Integer] The starting position of the scanline.
+  # @param prev_pos [Integer, nil] The starting position of the previous scanline. <tt>nil</tt> if
+  #   this is the first line.
+  # @param line_width [Integer] The number of bytes in this scanline, without counting the filtering
+  #   method byte.
+  # @param pixel_size [Integer] The number of bytes used per pixel.
+  # @return [void]
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#388
+  def encode_png_str_scanline_none(stream, pos, prev_pos, line_width, pixel_size); end
+
+  # Encodes a scanline of a pixelstream using PAETH filtering. This will modify the stream.
+  #
+  # @param stream [String] The pixelstream to work on. This string will be modified.
+  # @param pos [Integer] The starting position of the scanline.
+  # @param prev_pos [Integer, nil] The starting position of the previous scanline. <tt>nil</tt> if
+  #   this is the first line.
+  # @param line_width [Integer] The number of bytes in this scanline, without counting the filtering
+  #   method byte.
+  # @param pixel_size [Integer] The number of bytes used per pixel.
+  # @return [void]
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#429
+  def encode_png_str_scanline_paeth(stream, pos, prev_pos, line_width, pixel_size); end
+
+  # Encodes a scanline of a pixelstream using SUB filtering. This will modify the stream.
+  #
+  # @param stream [String] The pixelstream to work on. This string will be modified.
+  # @param pos [Integer] The starting position of the scanline.
+  # @param prev_pos [Integer, nil] The starting position of the previous scanline. <tt>nil</tt> if
+  #   this is the first line.
+  # @param line_width [Integer] The number of bytes in this scanline, without counting the filtering
+  #   method byte.
+  # @param pixel_size [Integer] The number of bytes used per pixel.
+  # @return [void]
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#395
+  def encode_png_str_scanline_sub(stream, pos, prev_pos, line_width, pixel_size); end
+
+  # Encodes a scanline of a pixelstream using UP filtering. This will modify the stream.
+  #
+  # @param stream [String] The pixelstream to work on. This string will be modified.
+  # @param pos [Integer] The starting position of the scanline.
+  # @param prev_pos [Integer, nil] The starting position of the previous scanline. <tt>nil</tt> if
+  #   this is the first line.
+  # @param line_width [Integer] The number of bytes in this scanline, without counting the filtering
+  #   method byte.
+  # @param pixel_size [Integer] The number of bytes used per pixel.
+  # @return [void]
+  #
+  # source://chunky_png//lib/chunky_png/canvas/png_encoding.rb#406
+  def encode_png_str_scanline_up(stream, pos, prev_pos, line_width, pixel_size); end
+end
+
+# The ChunkyPNG::Canvas::Resampling module defines methods to perform image resampling to
+# a {ChunkyPNG::Canvas}.
+#
+# Currently, only the nearest neighbor algorithm is implemented. Bilinear and cubic
+# algorithms may be added later on.
+#
+# @see ChunkyPNG::Canvas
+#
+# source://chunky_png//lib/chunky_png/canvas/resampling.rb#12
+module ChunkyPNG::Canvas::Resampling
+  # source://chunky_png//lib/chunky_png/canvas/resampling.rb#90
+  def resample(new_width, new_height); end
+
+  # source://chunky_png//lib/chunky_png/canvas/resampling.rb#134
+  def resample_bilinear(new_width, new_height); end
+
+  # Resamples the canvas with bilinear interpolation.
+  #
+  # @param new_width [Integer] The width of the resampled canvas.
+  # @param new_height [Integer] The height of the resampled canvas.
+  # @return [ChunkyPNG::Canvas] A new canvas instance with the resampled pixels.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/resampling.rb#98
+  def resample_bilinear!(new_width, new_height); end
+
+  # source://chunky_png//lib/chunky_png/canvas/resampling.rb#90
+  def resample_nearest_neighbor(new_width, new_height); end
+
+  # Resamples the canvas using nearest neighbor interpolation.
+  #
+  # @param new_width [Integer] The width of the resampled canvas.
+  # @param new_height [Integer] The height of the resampled canvas.
+  # @return [ChunkyPNG::Canvas] A new canvas instance with the resampled pixels.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/resampling.rb#74
+  def resample_nearest_neighbor!(new_width, new_height); end
+
+  # source://chunky_png//lib/chunky_png/canvas/resampling.rb#90
+  def resize(new_width, new_height); end
+
+  # Integer Interpolation between two values
+  #
+  # Used for generating indicies for interpolation (eg, nearest
+  # neighbour).
+  #
+  # @param width [Integer] The width of the source
+  # @param new_width [Integer] The width of the destination
+  # @return [Array<Integer>] An Array of Integer indicies
+  #
+  # source://chunky_png//lib/chunky_png/canvas/resampling.rb#21
+  def steps(width, new_width); end
+
+  # Fractional Interpolation between two values
+  #
+  # Used for generating values for interpolation (eg, bilinear).
+  # Produces both the indices and the interpolation factors (residues).
+  #
+  # @param width [Integer] The width of the source
+  # @param new_width [Integer] The width of the destination
+  # @return [Array<Integer>, Array<Integer>] Two arrays of indicies and residues
+  #
+  # source://chunky_png//lib/chunky_png/canvas/resampling.rb#38
+  def steps_residues(width, new_width); end
+end
+
+# Methods to save load a canvas from to stream, encoded in RGB, RGBA, BGR or ABGR format.
+#
+# source://chunky_png//lib/chunky_png/canvas/stream_exporting.rb#6
+module ChunkyPNG::Canvas::StreamExporting
+  # Creates an ABGR-formatted pixelstream with the pixel data from this canvas.
+  #
+  # Note that this format is fast but bloated, because no compression is used
+  # and the internal representation is left intact. To reconstruct the
+  # canvas, the width and height should be known.
+  #
+  # @return [String] The RGBA-formatted pixel data.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/stream_exporting.rb#53
+  def to_abgr_stream; end
+
+  # Creates a stream of the alpha channel of this canvas.
+  #
+  # @return [String] The 0-255 alpha values of all pixels packed as string
+  #
+  # source://chunky_png//lib/chunky_png/canvas/stream_exporting.rb#32
+  def to_alpha_channel_stream; end
+
+  # Creates a grayscale stream of this canvas.
+  #
+  # This method assume sthat this image is fully grayscale, i.e. R = G = B for
+  # every pixel. The alpha channel will not be included in the stream.
+  #
+  # @return [String] The 0-255 grayscale values of all pixels packed as string.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/stream_exporting.rb#42
+  def to_grayscale_stream; end
+
+  # Creates an RGB-formatted pixelstream with the pixel data from this canvas.
+  #
+  # Note that this format is fast but bloated, because no compression is used
+  # and the internal representation is almost left intact. To reconstruct
+  # the canvas, the width and height should be known.
+  #
+  # @return [String] The RGB-formatted pixel data.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/stream_exporting.rb#25
+  def to_rgb_stream; end
+
+  # Creates an RGB-formatted pixelstream with the pixel data from this canvas.
+  #
+  # Note that this format is fast but bloated, because no compression is used
+  # and the internal representation is left intact. To reconstruct the
+  # canvas, the width and height should be known.
+  #
+  # @return [String] The RGBA-formatted pixel data.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/stream_exporting.rb#14
+  def to_rgba_stream; end
+end
+
+# Methods to quickly load a canvas from a stream, encoded in RGB, RGBA, BGR or ABGR format.
+#
+# source://chunky_png//lib/chunky_png/canvas/stream_importing.rb#6
+module ChunkyPNG::Canvas::StreamImporting
+  # Creates a canvas by reading pixels from an ARGB formatted stream with a
+  # provided with and height.
+  #
+  # Every pixel should be represented by 4 bytes in the stream, in the correct
+  # ARGB order. This format is almost like the internal representation of a
+  # canvas object, so this kind of stream can be read extremely quickly.
+  #
+  # @param width [Integer] The width of the new canvas.
+  # @param height [Integer] The height of the new canvas.
+  # @param stream [#read, String] The stream to read the pixel data from.
+  # @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/stream_importing.rb#71
+  def from_abgr_stream(width, height, stream); end
+
+  # Creates a canvas by reading pixels from an BGR formatted stream with a
+  # provided with and height.
+  #
+  # Every pixel should be represented by 3 bytes in the stream, in the correct
+  # BGR order. This format closely resembles the internal representation of a
+  # canvas object, so this kind of stream can be read extremely quickly.
+  #
+  # @param width [Integer] The width of the new canvas.
+  # @param height [Integer] The height of the new canvas.
+  # @param stream [#read, String] The stream to read the pixel data from.
+  # @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/stream_importing.rb#53
+  def from_bgr_stream(width, height, stream); end
+
+  # Creates a canvas by reading pixels from an RGB formatted stream with a
+  # provided with and height.
+  #
+  # Every pixel should be represented by 3 bytes in the stream, in the correct
+  # RGB order. This format closely resembles the internal representation of a
+  # canvas object, so this kind of stream can be read extremely quickly.
+  #
+  # @param width [Integer] The width of the new canvas.
+  # @param height [Integer] The height of the new canvas.
+  # @param stream [#read, String] The stream to read the pixel data from.
+  # @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/stream_importing.rb#18
+  def from_rgb_stream(width, height, stream); end
+
+  # Creates a canvas by reading pixels from an RGBA formatted stream with a
+  # provided with and height.
+  #
+  # Every pixel should be represented by 4 bytes in the stream, in the correct
+  # RGBA order. This format is exactly like the internal representation of a
+  # canvas object, so this kind of stream can be read extremely quickly.
+  #
+  # @param width [Integer] The width of the new canvas.
+  # @param height [Integer] The height of the new canvas.
+  # @param stream [#read, String] The stream to read the pixel data from.
+  # @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
+  #
+  # source://chunky_png//lib/chunky_png/canvas/stream_importing.rb#37
+  def from_rgba_stream(width, height, stream); end
+end
+
+# A PNG datastream consists of multiple chunks. This module, and the classes
+# contained within, help with handling these chunks. It supports both reading
+# and writing chunks.
+#
+# All chunk types are instances of the {ChunkyPNG::Chunk::Base} class. For
+# some chunk types a specialized class is available, e.g. the IHDR chunk is
+# represented by the {ChunkyPNG::Chunk::Header} class. These specialized
+# classes help accessing the content of the chunk. All other chunks are
+# represented by the {ChunkyPNG::Chunk::Generic} class.
+#
+# @see ChunkyPNG::Datastream
+#
+# source://chunky_png//lib/chunky_png/chunk.rb#15
+module ChunkyPNG::Chunk
+  class << self
+    # Reads a chunk from an IO stream.
+    #
+    # @param io [IO, #read] The IO stream to read from.
+    # @return [ChunkyPNG::Chung::Base] The loaded chunk instance.
+    #
+    # source://chunky_png//lib/chunky_png/chunk.rb#20
+    def read(io); end
+
+    # Reads an exact number of bytes from an IO stream.
+    #
+    # @param io [IO, #read] The IO stream to read from.
+    # @param length [Integer] The IO exact number of bytes to read.
+    # @raise [ChunkyPNG::ExpectationFailed] If not exactly length
+    #   bytes could be read from the IO stream.
+    # @return [String] A binary string of exactly length bytes.
+    #
+    # source://chunky_png//lib/chunky_png/chunk.rb#36
+    def read_bytes(io, length); end
+
+    # Verifies the CRC of a chunk.
+    #
+    # @param type [String] The chunk's type.
+    # @param content [String] The chunk's content.
+    # @param found_crc [Integer] The chunk's found CRC value.
+    # @raise [ChunkyPNG::CRCMismatch] An exception is raised if
+    #   the found CRC value is not equal to the expected CRC value.
+    #
+    # source://chunky_png//lib/chunky_png/chunk.rb#48
+    def verify_crc!(type, content, found_crc); end
+  end
+end
+
+# The base chunk class is the superclass for every chunk type. It contains
+# methods to write the chunk to an output stream.
+#
+# A subclass should implement the +content+ method, which gets called when
+# the chunk gets written to a PNG datastream
+#
+# @abstract
+#
+# source://chunky_png//lib/chunky_png/chunk.rb#60
+class ChunkyPNG::Chunk::Base
+  # Initializes the chunk instance.
+  #
+  # @param type [String] The four character chunk type indicator.
+  # @param attributes [Hash] A hash of attributes to set on this chunk.
+  # @return [Base] a new instance of Base
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#69
+  def initialize(type, attributes = T.unsafe(nil)); end
+
+  # The four-character type indicator for the chunk. This field is used to
+  # find the correct class for a chunk when it is loaded from a PNG stream.
+  #
+  # @return [String]
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#64
+  def type; end
+
+  # The four-character type indicator for the chunk. This field is used to
+  # find the correct class for a chunk when it is loaded from a PNG stream.
+  #
+  # @return [String]
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#64
+  def type=(_arg0); end
+
+  # Writes the chunk to the IO stream.
+  #
+  # It will call the +content+ method to get the content for this chunk,
+  # and will calculate and append the checksum automatically.
+  #
+  # @param io [IO] The IO stream to write to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#88
+  def write(io); end
+
+  # Writes the chunk to the IO stream, using the provided content.
+  # The checksum will be calculated and appended to the stream.
+  #
+  # @param io [IO] The IO stream to write to.
+  # @param content [String] The content for this chunk.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#78
+  def write_with_crc(io, content); end
+end
+
+# Maps chunk types to classes, based on the four byte chunk type indicator
+# at the beginning of a chunk.
+#
+# If a chunk type is not specified in this hash, the Generic chunk type
+# will be used.
+#
+# @see ChunkyPNG::Chunk.read
+#
+# source://chunky_png//lib/chunky_png/chunk.rb#460
+ChunkyPNG::Chunk::CHUNK_TYPES = T.let(T.unsafe(nil), Hash)
+
+# The CompressedText (zTXt) chunk contains keyword/value metadata about the
+# PNG stream. In this chunk, the value is compressed using Deflate
+# compression.
+#
+# @see https://www.w3.org/TR/PNG/#11zTXt
+# @see ChunkyPNG::Chunk::CompressedText
+# @see ChunkyPNG::Chunk::InternationalText
+#
+# source://chunky_png//lib/chunky_png/chunk.rb#331
+class ChunkyPNG::Chunk::CompressedText < ::ChunkyPNG::Chunk::Base
+  # @return [CompressedText] a new instance of CompressedText
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#334
+  def initialize(keyword, value); end
+
+  # Creates the content to write to the stream, by concatenating the
+  # keyword with the deflated value, joined by a null character.
+  #
+  # @return The content that should be written to the datastream.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#349
+  def content; end
+
+  # Returns the value of attribute keyword.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#332
+  def keyword; end
+
+  # Sets the attribute keyword
+  #
+  # @param value the value to set the attribute keyword to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#332
+  def keyword=(_arg0); end
+
+  # Returns the value of attribute value.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#332
+  def value; end
+
+  # Sets the attribute value
+  #
+  # @param value the value to set the attribute value to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#332
+  def value=(_arg0); end
+
+  class << self
+    # @raise [ChunkyPNG::NotSupported]
+    #
+    # source://chunky_png//lib/chunky_png/chunk.rb#339
+    def read(type, content); end
+  end
+end
+
+# The End (IEND) chunk indicates the last chunk of a PNG stream. It does
+# not contain any data.
+#
+# @see https://www.w3.org/TR/PNG/#11IEND
+#
+# source://chunky_png//lib/chunky_png/chunk.rb#175
+class ChunkyPNG::Chunk::End < ::ChunkyPNG::Chunk::Base
+  # @return [End] a new instance of End
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#176
+  def initialize; end
+
+  # Returns an empty string, because this chunk should always be empty.
+  #
+  # @return [""] An empty string.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#194
+  def content; end
+
+  class << self
+    # Reads the END chunk. It will check if the content is empty.
+    #
+    # @param type [String] The four character chunk type indicator (=
+    #   "IEND").
+    # @param content [String] The content read from the chunk. Should be
+    #   empty.
+    # @raise [ChunkyPNG::ExpectationFailed] Raises an exception if the content was not empty.
+    # @return [ChunkyPNG::Chunk::End] The new End chunk instance.
+    #
+    # source://chunky_png//lib/chunky_png/chunk.rb#187
+    def read(type, content); end
+  end
+end
+
+# The Generic chunk type will read the content from the chunk as it,
+# and will write it back as it was read.
+#
+# source://chunky_png//lib/chunky_png/chunk.rb#97
+class ChunkyPNG::Chunk::Generic < ::ChunkyPNG::Chunk::Base
+  # @return [Generic] a new instance of Generic
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#100
+  def initialize(type, content = T.unsafe(nil)); end
+
+  # The attribute to store the content from the chunk, which gets
+  # written by the +write+ method.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#98
+  def content; end
+
+  # The attribute to store the content from the chunk, which gets
+  # written by the +write+ method.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#98
+  def content=(_arg0); end
+
+  class << self
+    # Creates an instance, given the chunk's type and content.
+    #
+    # @param type [String] The four character chunk type indicator.
+    # @param content [String] The content read from the chunk.
+    # @return [ChunkyPNG::Chunk::Generic] The new chunk instance.
+    #
+    # source://chunky_png//lib/chunky_png/chunk.rb#108
+    def read(type, content); end
+  end
+end
+
+# The header (IHDR) chunk is the first chunk of every PNG image, and
+# contains information about the image: i.e. its width, height, color
+# depth, color mode, compression method, filtering method and interlace
+# method.
+#
+# ChunkyPNG supports all values for these variables that are defined in the
+# PNG spec, except for color depth: Only 8-bit depth images are supported.
+# Note that it is still possible to access the chunk for such an image, but
+# ChunkyPNG will raise an exception if you try to access the pixel data.
+#
+# @see https://www.w3.org/TR/PNG/#11IHDR
+#
+# source://chunky_png//lib/chunky_png/chunk.rb#124
+class ChunkyPNG::Chunk::Header < ::ChunkyPNG::Chunk::Base
+  # @return [Header] a new instance of Header
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#127
+  def initialize(attrs = T.unsafe(nil)); end
+
+  # Returns the value of attribute color.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#125
+  def color; end
+
+  # Sets the attribute color
+  #
+  # @param value the value to set the attribute color to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#125
+  def color=(_arg0); end
+
+  # Returns the value of attribute compression.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#125
+  def compression; end
+
+  # Sets the attribute compression
+  #
+  # @param value the value to set the attribute compression to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#125
+  def compression=(_arg0); end
+
+  # Returns the content for this chunk when it gets written to a file, by
+  # packing the image information variables into the correct format.
+  #
+  # @return [String] The 13-byte content for the header chunk.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#158
+  def content; end
+
+  # Returns the value of attribute depth.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#125
+  def depth; end
+
+  # Sets the attribute depth
+  #
+  # @param value the value to set the attribute depth to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#125
+  def depth=(_arg0); end
+
+  # Returns the value of attribute filtering.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#125
+  def filtering; end
+
+  # Sets the attribute filtering
+  #
+  # @param value the value to set the attribute filtering to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#125
+  def filtering=(_arg0); end
+
+  # Returns the value of attribute height.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#125
+  def height; end
+
+  # Sets the attribute height
+  #
+  # @param value the value to set the attribute height to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#125
+  def height=(_arg0); end
+
+  # Returns the value of attribute interlace.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#125
+  def interlace; end
+
+  # Sets the attribute interlace
+  #
+  # @param value the value to set the attribute interlace to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#125
+  def interlace=(_arg0); end
+
+  # Returns the value of attribute width.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#125
+  def width; end
+
+  # Sets the attribute width
+  #
+  # @param value the value to set the attribute width to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#125
+  def width=(_arg0); end
+
+  class << self
+    # Reads the 13 bytes of content from the header chunk to set the image
+    # attributes.
+    #
+    # @param type [String] The four character chunk type indicator (= "IHDR").
+    # @param content [String] The 13 bytes of content read from the chunk.
+    # @return [ChunkyPNG::Chunk::End] The new Header chunk instance with the
+    #   variables set to the values according to the content.
+    #
+    # source://chunky_png//lib/chunky_png/chunk.rb#142
+    def read(type, content); end
+  end
+end
+
+# An image data (IDAT) chunk holds (part of) the compressed image pixel data.
+#
+# The data of an image can be split over multiple chunks, which will have to be combined
+# and inflated in order to decode an image. See {{.combine_chunks}} to combine chunks
+# to decode, and {{.split_in_chunks}} for encoding a pixeldata stream into IDAT chunks.
+#
+# @see https://www.w3.org/TR/PNG/#11IDAT
+#
+# source://chunky_png//lib/chunky_png/chunk.rb#271
+class ChunkyPNG::Chunk::ImageData < ::ChunkyPNG::Chunk::Generic
+  class << self
+    # Combines the list of IDAT chunks and inflates their contents to produce the
+    # pixeldata stream for the image.
+    #
+    # @return [String] The combined, inflated pixeldata as binary string
+    #
+    # source://chunky_png//lib/chunky_png/chunk.rb#272
+    def combine_chunks(data_chunks); end
+
+    # Splits and compresses a pixeldata stream into a list of IDAT chunks.
+    #
+    # @param data [String] The binary string of pixeldata
+    # @param level [Integer] The compression level to use.
+    # @param chunk_size [Integer] The maximum size of a chunk.
+    #
+    # source://chunky_png//lib/chunky_png/chunk.rb#286
+    def split_in_chunks(data, level = T.unsafe(nil), chunk_size = T.unsafe(nil)); end
+  end
+end
+
+# The InternationalText (iTXt) chunk contains keyword/value metadata about the PNG
+# stream, translated to a given locale.
+#
+# The metadata in this chunk can be encoded using UTF-8 characters.
+# Moreover, it is possible to define the language of the metadata, and give
+# a translation of the keyword name. Finally, it supports bot compressed
+# and uncompressed values.
+#
+# @see https://www.w3.org/TR/PNG/#11iTXt
+# @see ChunkyPNG::Chunk::Text
+# @see ChunkyPNG::Chunk::CompressedText
+#
+# source://chunky_png//lib/chunky_png/chunk.rb#407
+class ChunkyPNG::Chunk::InternationalText < ::ChunkyPNG::Chunk::Base
+  # @return [InternationalText] a new instance of InternationalText
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#410
+  def initialize(keyword, text, language_tag = T.unsafe(nil), translated_keyword = T.unsafe(nil), compressed = T.unsafe(nil), compression = T.unsafe(nil)); end
+
+  # Returns the value of attribute compressed.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#408
+  def compressed; end
+
+  # Sets the attribute compressed
+  #
+  # @param value the value to set the attribute compressed to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#408
+  def compressed=(_arg0); end
+
+  # Returns the value of attribute compression.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#408
+  def compression; end
+
+  # Sets the attribute compression
+  #
+  # @param value the value to set the attribute compression to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#408
+  def compression=(_arg0); end
+
+  # Assembles the content to write to the stream for this chunk.
+  #
+  # @return [String] The binary content that should be written to the datastream.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#445
+  def content; end
+
+  # Returns the value of attribute keyword.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#408
+  def keyword; end
+
+  # Sets the attribute keyword
+  #
+  # @param value the value to set the attribute keyword to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#408
+  def keyword=(_arg0); end
+
+  # Returns the value of attribute language_tag.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#408
+  def language_tag; end
+
+  # Sets the attribute language_tag
+  #
+  # @param value the value to set the attribute language_tag to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#408
+  def language_tag=(_arg0); end
+
+  # Returns the value of attribute text.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#408
+  def text; end
+
+  # Sets the attribute text
+  #
+  # @param value the value to set the attribute text to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#408
+  def text=(_arg0); end
+
+  # Returns the value of attribute translated_keyword.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#408
+  def translated_keyword; end
+
+  # Sets the attribute translated_keyword
+  #
+  # @param value the value to set the attribute translated_keyword to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#408
+  def translated_keyword=(_arg0); end
+
+  class << self
+    # Reads the iTXt chunk.
+    #
+    # @param type [String] The four character chunk type indicator (= "iTXt").
+    # @param content [String] The content read from the chunk.
+    # @raise [ChunkyPNG::InvalidUTF8] If the chunk contains data that is not UTF8-encoded text.
+    # @raise [ChunkyPNG::NotSupported] If the chunk refers to an unsupported compression method.
+    #   Currently uncompressed data and deflate are supported.
+    # @return [ChunkyPNG::Chunk::InternationalText] The new End chunk instance.
+    #
+    # source://chunky_png//lib/chunky_png/chunk.rb#427
+    def read(type, content); end
+  end
+end
+
+# The Palette (PLTE) chunk contains the image's palette, i.e. the
+# 8-bit RGB colors this image is using.
+#
+# @see https://www.w3.org/TR/PNG/#11PLTE
+# @see ChunkyPNG::Chunk::Transparency
+# @see ChunkyPNG::Palette
+#
+# source://chunky_png//lib/chunky_png/chunk.rb#205
+class ChunkyPNG::Chunk::Palette < ::ChunkyPNG::Chunk::Generic; end
+
+# The Physical (pHYs) chunk specifies the intended pixel size or aspect
+# ratio for display of the image.
+#
+# @see https://www.w3.org/TR/PNG/#11pHYs
+#
+# source://chunky_png//lib/chunky_png/chunk.rb#362
+class ChunkyPNG::Chunk::Physical < ::ChunkyPNG::Chunk::Base
+  # @raise [ArgumentError]
+  # @return [Physical] a new instance of Physical
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#365
+  def initialize(ppux, ppuy, unit = T.unsafe(nil)); end
+
+  # Assembles the content to write to the stream for this chunk.
+  #
+  # @return [String] The binary content that should be written to the datastream.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#389
+  def content; end
+
+  # @raise [ChunkyPNG::UnitsUnknown]
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#371
+  def dpix; end
+
+  # @raise [ChunkyPNG::UnitsUnknown]
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#376
+  def dpiy; end
+
+  # Returns the value of attribute ppux.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#363
+  def ppux; end
+
+  # Sets the attribute ppux
+  #
+  # @param value the value to set the attribute ppux to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#363
+  def ppux=(_arg0); end
+
+  # Returns the value of attribute ppuy.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#363
+  def ppuy; end
+
+  # Sets the attribute ppuy
+  #
+  # @param value the value to set the attribute ppuy to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#363
+  def ppuy=(_arg0); end
+
+  # Returns the value of attribute unit.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#363
+  def unit; end
+
+  # Sets the attribute unit
+  #
+  # @param value the value to set the attribute unit to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#363
+  def unit=(_arg0); end
+
+  class << self
+    # source://chunky_png//lib/chunky_png/chunk.rb#381
+    def read(type, content); end
+  end
+end
+
+# source://chunky_png//lib/chunky_png/chunk.rb#393
+ChunkyPNG::Chunk::Physical::INCHES_PER_METER = T.let(T.unsafe(nil), Float)
+
+# The Text (tEXt) chunk contains keyword/value metadata about the PNG
+# stream. In this chunk, the value is stored uncompressed.
+#
+# The tEXt chunk only supports Latin-1 encoded textual data. If you need
+# UTF-8 support, check out the InternationalText chunk type.
+#
+# @see https://www.w3.org/TR/PNG/#11tEXt
+# @see ChunkyPNG::Chunk::CompressedText
+# @see ChunkyPNG::Chunk::InternationalText
+#
+# source://chunky_png//lib/chunky_png/chunk.rb#302
+class ChunkyPNG::Chunk::Text < ::ChunkyPNG::Chunk::Base
+  # @return [Text] a new instance of Text
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#305
+  def initialize(keyword, value); end
+
+  # Creates the content to write to the stream, by concatenating the
+  # keyword with the value, joined by a null character.
+  #
+  # @return The content that should be written to the datastream.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#319
+  def content; end
+
+  # Returns the value of attribute keyword.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#303
+  def keyword; end
+
+  # Sets the attribute keyword
+  #
+  # @param value the value to set the attribute keyword to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#303
+  def keyword=(_arg0); end
+
+  # Returns the value of attribute value.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#303
+  def value; end
+
+  # Sets the attribute value
+  #
+  # @param value the value to set the attribute value to.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#303
+  def value=(_arg0); end
+
+  class << self
+    # source://chunky_png//lib/chunky_png/chunk.rb#310
+    def read(type, content); end
+  end
+end
+
+# A transparency (tRNS) chunk defines the transparency for an image.
+#
+# * For indexed images, it contains the alpha channel for the colors
+#   defined in the Palette (PLTE) chunk.
+# * For grayscale images, it contains the grayscale teint that should be
+#   considered fully transparent.
+# * For truecolor images, it contains the color that should be considered
+#   fully transparent.
+#
+# Images having a color mode that already includes an alpha channel, this
+# chunk should not be included.
+#
+# @see https://www.w3.org/TR/PNG/#11tRNS
+# @see ChunkyPNG::Chunk::Palette
+# @see ChunkyPNG::Palette
+#
+# source://chunky_png//lib/chunky_png/chunk.rb#230
+class ChunkyPNG::Chunk::Transparency < ::ChunkyPNG::Chunk::Generic
+  # Returns the grayscale entry to be replaced by transparent pixels.
+  #
+  # This method should only be used for images having color mode
+  # ChunkyPNG::COLOR_GRAYSCALE (0).
+  #
+  # @return [Integer] The (grayscale) color to replace with fully
+  #   transparent pixels.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#254
+  def grayscale_entry(bit_depth); end
+
+  # Returns the alpha channel for the palette of an indexed image.
+  #
+  # This method should only be used for images having color mode
+  # ChunkyPNG::COLOR_INDEXED (3).
+  #
+  # @return [Array<Integer>] Returns an array of alpha channel values
+  #   [0-255].
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#231
+  def palette_alpha_channel; end
+
+  # Returns the truecolor entry to be replaced by transparent pixels,
+  #
+  # This method should only be used for images having color mode
+  # ChunkyPNG::COLOR_TRUECOLOR (2).
+  #
+  # @return [Integer] The color to replace with fully transparent pixels.
+  #
+  # source://chunky_png//lib/chunky_png/chunk.rb#241
+  def truecolor_entry(bit_depth); end
+end
+
+# The Color module defines methods for handling colors. Within the ChunkyPNG
+# library, the concepts of pixels and colors are both used, and they are
+# both represented by a Integer.
+#
+# Pixels/colors are represented in RGBA components. Each of the four
+# components is stored with a depth of 8 bits (maximum value = 255 =
+# {ChunkyPNG::Color::MAX}). Together, these components are stored in a 4-byte
+# Integer.
+#
+# A color will always be represented using these 4 components in memory.
+# When the image is encoded, a more suitable representation can be used
+# (e.g. rgb, grayscale, palette-based), for which several conversion methods
+# are provided in this module.
+#
+# source://chunky_png//lib/chunky_png/color.rb#57
+module ChunkyPNG::Color
+  extend ::ChunkyPNG::Color
+
+  # Returns the alpha channel value for the color value.
+  #
+  # @param value [Integer] The color value.
+  # @return [Integer] A value between 0 and MAX.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#299
+  def a(value); end
+
+  # Checks whether an alpha channel value can successfully be composed
+  # given the resulting color, the mask color and a background color,
+  # all of which should be opaque.
+  #
+  # @param color [Integer] The color that was the result of compositing.
+  # @param mask [Integer] The opaque variant of the color that was being
+  #   composed
+  # @param bg [Integer] The background color on which the color was composed.
+  # @param tolerance [Integer] The decomposition tolerance level, a value
+  #   between 0 and 255.
+  # @return [Boolean] True if the alpha component can be decomposed
+  #   successfully.
+  # @see #decompose_alpha
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#503
+  def alpha_decomposable?(color, mask, bg, tolerance = T.unsafe(nil)); end
+
+  # Returns the blue-component from the color value.
+  #
+  # @param value [Integer] The color value.
+  # @return [Integer] A value between 0 and MAX.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#291
+  def b(value); end
+
+  # Blends the foreground and background color by taking the average of
+  # the components.
+  #
+  # @param fg [Integer] The foreground color.
+  # @param bg [Integer] The foreground color.
+  # @return [Integer] The blended color.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#406
+  def blend(fg, bg); end
+
+  # Composes two colors with an alpha channel using integer math.
+  #
+  # This version is faster than the version based on floating point math, so
+  # this compositing function is used by default.
+  #
+  # @param fg [Integer] The foreground color.
+  # @param bg [Integer] The background color.
+  # @return [Integer] The composited color.
+  # @see ChunkyPNG::Color#compose_precise
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#361
+  def compose(fg, bg); end
+
+  # Composes two colors with an alpha channel using floating point math.
+  #
+  # This method uses more precise floating point math, but this precision is
+  # lost when the result is converted back to an integer. Because it is
+  # slower than the version based on integer math, that version is preferred.
+  #
+  # @param fg [Integer] The foreground color.
+  # @param bg [Integer] The background color.
+  # @return [Integer] The composited color.
+  # @see ChunkyPNG::Color#compose_quick
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#383
+  def compose_precise(fg, bg); end
+
+  # Composes two colors with an alpha channel using integer math.
+  #
+  # This version is faster than the version based on floating point math, so
+  # this compositing function is used by default.
+  #
+  # @param fg [Integer] The foreground color.
+  # @param bg [Integer] The background color.
+  # @return [Integer] The composited color.
+  # @see ChunkyPNG::Color#compose_precise
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#361
+  def compose_quick(fg, bg); end
+
+  # Decomposes the alpha channel value given the resulting color, the mask
+  # color and a background color, all of which should be opaque.
+  #
+  # Make sure to call {#alpha_decomposable?} first to see if the alpha
+  # channel value can successfully decomposed with a given tolerance,
+  # otherwise the return value of this method is undefined.
+  #
+  # @param color [Integer] The color that was the result of compositing.
+  # @param mask [Integer] The opaque variant of the color that was being
+  #   composed
+  # @param bg [Integer] The background color on which the color was composed.
+  # @return [Integer] The best fitting alpha channel, a value between 0 and
+  #   255.
+  # @see #alpha_decomposable?
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#524
+  def decompose_alpha(color, mask, bg); end
+
+  # Decomposes an alpha channel for either the r, g or b color channel.
+  #
+  # @param channel [:r, :g, :b] The channel to decompose the alpha channel
+  #   from.
+  # @param color [Integer] The color that was the result of compositing.
+  # @param mask [Integer] The opaque variant of the color that was being
+  #   composed
+  # @param bg [Integer] The background color on which the color was composed.
+  # @return [Integer] The decomposed alpha value for the channel.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#537
+  def decompose_alpha_component(channel, color, mask, bg); end
+
+  # Decomposes the alpha channels for the r, g and b color channel.
+  #
+  # @param color [Integer] The color that was the result of compositing.
+  # @param mask [Integer] The opaque variant of the color that was being
+  #   composed
+  # @param bg [Integer] The background color on which the color was composed.
+  # @return [Array<Integer>] The decomposed alpha values for the r, g and b
+  #   channels.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#554
+  def decompose_alpha_components(color, mask, bg); end
+
+  # Decomposes a color, given a color, a mask color and a background color.
+  # The returned color will be a variant of the mask color, with the alpha
+  # channel set to the best fitting value. This basically is the reverse
+  # operation if alpha composition.
+  #
+  # If the color cannot be decomposed, this method will return the fully
+  # transparent variant of the mask color.
+  #
+  # @param color [Integer] The color that was the result of compositing.
+  # @param mask [Integer] The opaque variant of the color that was being
+  #   composed
+  # @param bg [Integer] The background color on which the color was composed.
+  # @param tolerance [Integer] The decomposition tolerance level, a value
+  #   between 0 and 255.
+  # @return [Integer] The decomposed color, a variant of the masked color
+  #   with the alpha channel set to an appropriate value.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#482
+  def decompose_color(color, mask, bg, tolerance = T.unsafe(nil)); end
+
+  # Compute the Euclidean distance between 2 colors in RGBA
+  #
+  # This method simply takes the Euclidean distance between the RGBA channels
+  # of 2 colors, which gives us a measure of how different the two colors
+  # are.
+  #
+  # Although it would be more perceptually accurate to calculate a proper
+  # Delta E in Lab colorspace, this method should serve many use-cases while
+  # avoiding the overhead of converting RGBA to Lab.
+  #
+  # @param pixel_after [Integer]
+  # @param pixel_before [Integer]
+  # @return [Float]
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#722
+  def euclidean_distance_rgba(pixel_after, pixel_before); end
+
+  # Lowers the intensity of a color, by lowering its alpha by a given factor.
+  #
+  # @param color [Integer] The color to adjust.
+  # @param factor [Integer] Fade factor as an integer between 0 and 255.
+  # @return [Integer] The faded color.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#461
+  def fade(color, factor); end
+
+  # Creates a color by converting it from a string in hex notation.
+  #
+  # It supports colors with (#rrggbbaa) or without (#rrggbb) alpha channel
+  # as well as the 3-digit short format (#rgb) for those without.
+  # Color strings may include the prefix "0x" or "#".
+  #
+  # @param hex_value [String] The color in hex notation.
+  # @param opacity [Integer] The opacity value for the color. Overrides any
+  #   opacity value given in the hex value if given.
+  # @raise [ArgumentError] if the value given is not a hex color notation.
+  # @return [Integer] The color value.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#167
+  def from_hex(hex_value, opacity = T.unsafe(nil)); end
+
+  # Creates a new color from an HSV triple.
+  #
+  # Create a new color using an HSV (sometimes also called HSB) triple. The
+  # words `value` and `brightness` are used interchangeably and synonymously
+  # in descriptions of this colorspace. This implementation follows the modern
+  # convention of 0 degrees hue indicating red.
+  #
+  # @param hue [Fixnum] The hue component (0-360)
+  # @param saturation [Fixnum] The saturation component (0-1)
+  # @param value [Fixnum] The value (brightness) component (0-1)
+  # @param alpha [Fixnum] Defaults to opaque (255).
+  # @raise [ArgumentError] if the hsv triple is invalid.
+  # @return [Integer] The newly constructed color value.
+  # @see https://en.wikipedia.org/wiki/HSL_and_HSV
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#194
+  def from_hsb(hue, saturation, value, alpha = T.unsafe(nil)); end
+
+  # Creates a new color from an HSL triple.
+  #
+  # This implementation follows the modern convention of 0 degrees hue
+  # indicating red.
+  #
+  # @param hue [Fixnum] The hue component (0-360)
+  # @param saturation [Fixnum] The saturation component (0-1)
+  # @param lightness [Fixnum] The lightness component (0-1)
+  # @param alpha [Fixnum] Defaults to opaque (255).
+  # @raise [ArgumentError] if the hsl triple is invalid.
+  # @return [Integer] The newly constructed color value.
+  # @see https://en.wikipedia.org/wiki/HSL_and_HSV
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#220
+  def from_hsl(hue, saturation, lightness, alpha = T.unsafe(nil)); end
+
+  # Creates a new color from an HSV triple.
+  #
+  # Create a new color using an HSV (sometimes also called HSB) triple. The
+  # words `value` and `brightness` are used interchangeably and synonymously
+  # in descriptions of this colorspace. This implementation follows the modern
+  # convention of 0 degrees hue indicating red.
+  #
+  # @param hue [Fixnum] The hue component (0-360)
+  # @param saturation [Fixnum] The saturation component (0-1)
+  # @param value [Fixnum] The value (brightness) component (0-1)
+  # @param alpha [Fixnum] Defaults to opaque (255).
+  # @raise [ArgumentError] if the hsv triple is invalid.
+  # @return [Integer] The newly constructed color value.
+  # @see https://en.wikipedia.org/wiki/HSL_and_HSV
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#194
+  def from_hsv(hue, saturation, value, alpha = T.unsafe(nil)); end
+
+  # Creates a color by unpacking an rgb triple from a string.
+  #
+  # @param stream [String] The string to load the color from. It should be
+  #   at least 3 + pos bytes long.
+  # @param pos [Integer] The position in the string to load the triple from.
+  # @return [Integer] The newly constructed color value.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#142
+  def from_rgb_stream(stream, pos = T.unsafe(nil)); end
+
+  # Creates a color by unpacking an rgba triple from a string
+  #
+  # @param stream [String] The string to load the color from. It should be
+  #   at least 4 + pos bytes long.
+  # @param pos [Integer] The position in the string to load the triple from.
+  # @return [Integer] The newly constructed color value.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#152
+  def from_rgba_stream(stream, pos = T.unsafe(nil)); end
+
+  # Returns true if this color is fully transparent.
+  #
+  # @param value [Integer] The color to test.
+  # @return [true, false] True if the alpha channel equals 0.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#330
+  def fully_transparent?(value); end
+
+  # Returns the green-component from the color value.
+  #
+  # @param value [Integer] The color value.
+  # @return [Integer] A value between 0 and MAX.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#283
+  def g(value); end
+
+  # Creates a new color using a grayscale teint.
+  #
+  # @param teint [Integer] The grayscale teint (0-255), will be used as r, g,
+  #   and b value.
+  # @return [Integer] The newly constructed color value.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#119
+  def grayscale(teint); end
+
+  # Returns true if this color is fully transparent.
+  #
+  # @param value [Integer] The color to test.
+  # @return [true, false] True if the r, g and b component are equal.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#322
+  def grayscale?(value); end
+
+  # Creates a new color using a grayscale teint and alpha value.
+  #
+  # @param teint [Integer] The grayscale teint (0-255), will be used as r, g,
+  #   and b value.
+  # @param a [Integer] The opacity (0-255)
+  # @return [Integer] The newly constructed color value.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#128
+  def grayscale_alpha(teint, a); end
+
+  # Calculates the grayscale teint of an RGB color.
+  #
+  # @param color [Integer] The color to convert.
+  # @return [Integer] The grayscale teint of the input color, 0-255.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#438
+  def grayscale_teint(color); end
+
+  # Gets a color value based on a HTML color name.
+  #
+  # The color name is flexible. E.g. <tt>'yellowgreen'</tt>, <tt>'Yellow
+  # green'</tt>, <tt>'YellowGreen'</tt>, <tt>'YELLOW_GREEN'</tt> and
+  # <tt>:yellow_green</tt> will all return the same color value.
+  #
+  # You can include a opacity level in the color name (e.g. <tt>'red @
+  # 0.5'</tt>) or give an explicit opacity value as second argument. If no
+  # opacity value is given, the color will be fully opaque.
+  #
+  # @param color_name [Symbol, String] The color name. It may include an
+  #   opacity specifier like <tt>@ 0.8</tt> to set the color's opacity.
+  # @param opacity [Integer] The opacity value for the color between 0 and
+  #   255. Overrides any opacity value given in the color name.
+  # @raise [ChunkyPNG::Exception] If the color name was not recognized.
+  # @return [Integer] The color value.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#909
+  def html_color(color_name, opacity = T.unsafe(nil)); end
+
+  # Multiplies two fractions using integer math, where the fractions are
+  # stored using an integer between 0 and 255. This method is used as a
+  # helper method for compositing colors using integer math.
+  #
+  # This is a quicker implementation of ((a * b) / 255.0).round.
+  #
+  # @param a [Integer] The first fraction.
+  # @param b [Integer] The second fraction.
+  # @return [Integer] The result of the multiplication.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#347
+  def int8_mult(a, b); end
+
+  # Interpolates the foreground and background colors by the given alpha
+  # value. This also blends the alpha channels themselves.
+  #
+  # A blending factor of 255 will give entirely the foreground,
+  # while a blending factor of 0 will give the background.
+  #
+  # @param fg [Integer] The foreground color.
+  # @param bg [Integer] The background color.
+  # @param alpha [Integer] The blending factor (fixed 8bit)
+  # @return [Integer] The interpolated color.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#420
+  def interpolate_quick(fg, bg, alpha); end
+
+  # Returns the opaque value of this color by removing the alpha channel.
+  #
+  # @param value [Integer] The color to transform.
+  # @return [Integer] The opaque color
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#314
+  def opaque!(value); end
+
+  # Returns true if this color is fully opaque.
+  #
+  # @param value [Integer] The color to test.
+  # @return [true, false] True if the alpha channel equals MAX.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#307
+  def opaque?(value); end
+
+  # Parses a color value given a numeric or string argument.
+  #
+  # It supports color numbers, colors in hex notation and named HTML colors.
+  #
+  # @param source [Integer, String] The color value.
+  # @return [Integer] The color value, with the opacity applied if one was
+  #   given.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#86
+  def parse(source); end
+
+  # Returns the number of bytes used for an image pass
+  #
+  # @param color_mode [Integer] The color mode in which the pixels are
+  #   stored.
+  # @param depth [Integer] The color depth of the pixels.
+  # @param width [Integer] The width of the image pass.
+  # @param height [Integer] The height of the image pass.
+  # @return [Integer] The number of bytes used per scanline in a datastream.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#984
+  def pass_bytesize(color_mode, depth, width, height); end
+
+  # Returns the size in bits of a pixel when it is stored using a given color
+  # mode.
+  #
+  # @param color_mode [Integer] The color mode in which the pixels are
+  #   stored.
+  # @param depth [Integer] The color depth of the pixels.
+  # @return [Integer] The number of bytes used per pixel in a datastream.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#963
+  def pixel_bitsize(color_mode, depth = T.unsafe(nil)); end
+
+  # Returns the size in bytes of a pixel when it is stored using a given
+  # color mode.
+  #
+  # @param color_mode [Integer] The color mode in which the pixels are
+  #   stored.
+  # @return [Integer] The number of bytes used per pixel in a datastream.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#951
+  def pixel_bytesize(color_mode, depth = T.unsafe(nil)); end
+
+  # Returns the red-component from the color value.
+  #
+  # @param value [Integer] The color value.
+  # @return [Integer] A value between 0 and MAX.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#275
+  def r(value); end
+
+  # Creates a new color using an r, g, b triple.
+  #
+  # @param r [Integer] The r-component (0-255)
+  # @param g [Integer] The g-component (0-255)
+  # @param b [Integer] The b-component (0-255)
+  # @return [Integer] The newly constructed color value.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#111
+  def rgb(r, g, b); end
+
+  # Creates a new color using an r, g, b triple and an alpha value.
+  #
+  # @param r [Integer] The r-component (0-255)
+  # @param g [Integer] The g-component (0-255)
+  # @param b [Integer] The b-component (0-255)
+  # @param a [Integer] The opacity (0-255)
+  # @return [Integer] The newly constructed color value.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#102
+  def rgba(r, g, b, a); end
+
+  # Returns the number of sample values per pixel.
+  #
+  # @param color_mode [Integer] The color mode being used.
+  # @return [Integer] The number of sample values per pixel.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#934
+  def samples_per_pixel(color_mode); end
+
+  # Returns the number of bytes used per scanline.
+  #
+  # @param color_mode [Integer] The color mode in which the pixels are
+  #   stored.
+  # @param depth [Integer] The color depth of the pixels.
+  # @param width [Integer] The number of pixels per scanline.
+  # @return [Integer] The number of bytes used per scanline in a datastream.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#973
+  def scanline_bytesize(color_mode, depth, width); end
+
+  # Converts a color to a fiting grayscale value. It will conserve the alpha
+  # channel.
+  #
+  # This method will return a full color value, with the R, G, and B value
+  # set to the grayscale teint calcuated from the input color's R, G and B
+  # values.
+  #
+  # @param color [Integer] The color to convert.
+  # @return [Integer] The input color, converted to the best fitting
+  #   grayscale.
+  # @see #grayscale_teint
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#453
+  def to_grayscale(color); end
+
+  # Returns an array with the grayscale teint and alpha channel values for
+  # this color.
+  #
+  # This method expects the color to be grayscale, i.e. r, g, and b value to
+  # be equal and uses only the B channel. If you need to convert a color to
+  # grayscale first, see {#to_grayscale}.
+  #
+  # @param color [Integer] The grayscale color to convert.
+  # @return [Array<Integer>] An array with 2 Integer elements.
+  # @see #to_grayscale
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#701
+  def to_grayscale_alpha_bytes(color); end
+
+  # Returns an array with the grayscale teint value for this color.
+  #
+  # This method expects the r, g, and b value to be equal, and the alpha
+  # channel will be discarded.
+  #
+  # @param color [Integer] The grayscale color to convert.
+  # @return [Array<Integer>] An array with 1 Integer element.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#687
+  def to_grayscale_bytes(color); end
+
+  # Returns a string representing this color using hex notation (i.e.
+  # #rrggbbaa).
+  #
+  # @param color [Integer] The color to convert.
+  # @param include_alpha [Boolean]
+  # @return [String] The color in hex notation, starting with a pound sign.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#572
+  def to_hex(color, include_alpha = T.unsafe(nil)); end
+
+  # Returns an array with the separate HSV components of a color.
+  #
+  # Because ChunkyPNG internally handles colors as Integers for performance
+  # reasons, some rounding  occurs when importing or exporting HSV colors
+  # whose coordinates are float-based.  Because of this rounding, #to_hsv and
+  # #from_hsv may not be perfect inverses.
+  #
+  # This implementation follows the modern convention of 0 degrees hue
+  # indicating red.
+  #
+  # @param color [Integer] The ChunkyPNG color to convert.
+  # @param include_alpha [Boolean] Flag indicates whether a fourth element
+  #   representing alpha channel should be included in the returned array.
+  # @return [Array[0]] The hue of the color (0-360)
+  # @return [Array[1]] The saturation of the color (0-1)
+  # @return [Array[2]] The value of the color (0-1)
+  # @return [Array[3]] Optional fourth element for alpha, included if
+  #   include_alpha=true (0-255)
+  # @see https://en.wikipedia.org/wiki/HSL_and_HSV
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#595
+  def to_hsb(color, include_alpha = T.unsafe(nil)); end
+
+  # Returns an array with the separate HSL components of a color.
+  #
+  # Because ChunkyPNG internally handles colors as Integers for performance
+  # reasons, some rounding  occurs when importing or exporting HSL colors
+  # whose coordinates are float-based.  Because of this rounding, #to_hsl and
+  # #from_hsl may not be perfect inverses.
+  #
+  # This implementation follows the modern convention of 0 degrees hue indicating red.
+  #
+  # @param color [Integer] The ChunkyPNG color to convert.
+  # @param include_alpha [Boolean] Flag indicates whether a fourth element
+  #   representing alpha channel should be included in the returned array.
+  # @return [Array<Fixnum>[0]] The hue of the color (0-360)
+  # @return [Array<Fixnum>[1]] The saturation of the color (0-1)
+  # @return [Array<Fixnum>[2]] The lightness of the color (0-1)
+  # @return [Array<Fixnum>[3]] Optional fourth element for alpha, included if
+  #   include_alpha=true (0-255)
+  # @see https://en.wikipedia.org/wiki/HSL_and_HSV
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#624
+  def to_hsl(color, include_alpha = T.unsafe(nil)); end
+
+  # Returns an array with the separate HSV components of a color.
+  #
+  # Because ChunkyPNG internally handles colors as Integers for performance
+  # reasons, some rounding  occurs when importing or exporting HSV colors
+  # whose coordinates are float-based.  Because of this rounding, #to_hsv and
+  # #from_hsv may not be perfect inverses.
+  #
+  # This implementation follows the modern convention of 0 degrees hue
+  # indicating red.
+  #
+  # @param color [Integer] The ChunkyPNG color to convert.
+  # @param include_alpha [Boolean] Flag indicates whether a fourth element
+  #   representing alpha channel should be included in the returned array.
+  # @return [Array[0]] The hue of the color (0-360)
+  # @return [Array[1]] The saturation of the color (0-1)
+  # @return [Array[2]] The value of the color (0-1)
+  # @return [Array[3]] Optional fourth element for alpha, included if
+  #   include_alpha=true (0-255)
+  # @see https://en.wikipedia.org/wiki/HSL_and_HSV
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#595
+  def to_hsv(color, include_alpha = T.unsafe(nil)); end
+
+  # Returns an array with the separate RGBA values for this color.
+  #
+  # @param color [Integer] The color to convert.
+  # @return [Array<Integer>] An array with 4 Integer elements.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#667
+  def to_truecolor_alpha_bytes(color); end
+
+  # Returns an array with the separate RGB values for this color. The alpha
+  # channel will be discarded.
+  #
+  # @param color [Integer] The color to convert.
+  # @return [Array<Integer>] An array with 3 Integer elements.
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#676
+  def to_truecolor_bytes(color); end
+
+  private
+
+  # Convert one HSL or HSV triple and associated chroma to a scaled rgb triple
+  #
+  # This method encapsulates the shared mathematical operations needed to
+  # convert coordinates from a cylindrical colorspace such as HSL or HSV into
+  # coordinates of the RGB colorspace.
+  #
+  # Even though chroma values are derived from the other three coordinates,
+  # the formula for calculating chroma differs for each colorspace.  Since it
+  # is calculated differently for each colorspace, it must be passed in as
+  # a parameter.
+  #
+  # @param hue [Fixnum] The hue-component (0-360)
+  # @param saturation [Fixnum] The saturation-component (0-1)
+  # @param y_component [Fixnum] The y_component can represent either lightness
+  #   or brightness/value (0-1) depending on which scheme (HSV/HSL) is being used.
+  # @param chroma [Fixnum] The associated chroma value.
+  # @private
+  # @return [Array<Fixnum>] A scaled r,g,b triple. Scheme-dependent
+  #   adjustments are still needed to reach the true r,g,b values.
+  # @see https://en.wikipedia.org/wiki/HSL_and_HSV
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#252
+  def cylindrical_to_cubic(hue, saturation, y_component, chroma); end
+
+  # This method encapsulates the logic needed to extract hue and chroma from
+  # a ChunkPNG color. This logic is shared by the cylindrical HSV/HSB and HSL
+  # color space models.
+  #
+  # @param color [Integer] A ChunkyPNG color.
+  # @private
+  # @return [Fixnum] hue The hue of the color (0-360)
+  # @return [Fixnum] chroma The chroma of the color (0-1)
+  # @return [Fixnum] max The magnitude of the largest scaled rgb component (0-1)
+  # @return [Fixnum] min The magnitude of the smallest scaled rgb component (0-1)
+  #
+  # source://chunky_png//lib/chunky_png/color.rb#643
+  def hue_and_chroma(color); end
+end
+
+# @return [Integer] Black pixel/color
+#
+# source://chunky_png//lib/chunky_png/color.rb#919
+ChunkyPNG::Color::BLACK = T.let(T.unsafe(nil), Integer)
+
+# @private
+# @return [Regexp] The regexp to parse 3-digit hex color values.
+#
+# source://chunky_png//lib/chunky_png/color.rb#65
+ChunkyPNG::Color::HEX3_COLOR_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# @private
+# @return [Regexp] The regexp to parse 6- and 8-digit hex color values.
+#
+# source://chunky_png//lib/chunky_png/color.rb#69
+ChunkyPNG::Color::HEX6_COLOR_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# @private
+# @return [Regexp] The regexp to parse named color values.
+#
+# source://chunky_png//lib/chunky_png/color.rb#73
+ChunkyPNG::Color::HTML_COLOR_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# @return [Integer] The maximum value of each color component.
+#
+# source://chunky_png//lib/chunky_png/color.rb#61
+ChunkyPNG::Color::MAX = T.let(T.unsafe(nil), Integer)
+
+# Could be simplified as MAX * 2, but this format mirrors the math in
+# {#euclidean_distance_rgba}
+#
+# @return [Float] The maximum Euclidean distance of two RGBA colors.
+#
+# source://chunky_png//lib/chunky_png/color.rb#736
+ChunkyPNG::Color::MAX_EUCLIDEAN_DISTANCE_RGBA = T.let(T.unsafe(nil), Float)
+
+# @return [Hash<Symbol, Integer>] All the predefined color names in HTML.
+#
+# source://chunky_png//lib/chunky_png/color.rb#743
+ChunkyPNG::Color::PREDEFINED_COLORS = T.let(T.unsafe(nil), Hash)
+
+# @return [Integer] Fully transparent pixel/color
+#
+# source://chunky_png//lib/chunky_png/color.rb#925
+ChunkyPNG::Color::TRANSPARENT = T.let(T.unsafe(nil), Integer)
+
+# @return [Integer] White pixel/color
+#
+# source://chunky_png//lib/chunky_png/color.rb#922
+ChunkyPNG::Color::WHITE = T.let(T.unsafe(nil), Integer)
+
+# The Datastream class represents a PNG formatted datastream. It supports
+# both reading from and writing to strings, streams and files.
+#
+# A PNG datastream begins with the PNG signature, and then contains multiple
+# chunks, starting with a header (IHDR) chunk and finishing with an end
+# (IEND) chunk.
+#
+# @see ChunkyPNG::Chunk
+#
+# source://chunky_png//lib/chunky_png/datastream.rb#12
+class ChunkyPNG::Datastream
+  # Initializes a new Datastream instance.
+  #
+  # @return [Datastream] a new instance of Datastream
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#45
+  def initialize; end
+
+  # Returns an enumerator instance for this datastream's chunks.
+  #
+  # @return [Enumerable::Enumerator] An enumerator for the :each_chunk method.
+  # @see ChunkyPNG::Datastream#each_chunk
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#137
+  def chunks; end
+
+  # The chunks that together compose the images pixel data.
+  #
+  # @return [Array<ChunkyPNG::Chunk::ImageData>]
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#38
+  def data_chunks; end
+
+  # The chunks that together compose the images pixel data.
+  #
+  # @return [Array<ChunkyPNG::Chunk::ImageData>]
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#38
+  def data_chunks=(_arg0); end
+
+  # Enumerates the chunks in this datastream.
+  #
+  # This will iterate over the chunks using the order in which the chunks
+  # should appear in the PNG file.
+  #
+  # @see ChunkyPNG::Datastream#chunks
+  # @yield [chunk] Yields the chunks in this datastream, one by one in the correct order.
+  # @yieldparam chunk [ChunkyPNG::Chunk::Base] A chunk in this datastream.
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#124
+  def each_chunk; end
+
+  # The empty chunk that signals the end of this datastream
+  #
+  # @return [ChunkyPNG::Chunk::Header]
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#42
+  def end_chunk; end
+
+  # The empty chunk that signals the end of this datastream
+  #
+  # @return [ChunkyPNG::Chunk::Header]
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#42
+  def end_chunk=(_arg0); end
+
+  # The header chunk of this datastream.
+  #
+  # @return [ChunkyPNG::Chunk::Header]
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#18
+  def header_chunk; end
+
+  # The header chunk of this datastream.
+  #
+  # @return [ChunkyPNG::Chunk::Header]
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#18
+  def header_chunk=(_arg0); end
+
+  # Returns the uncompressed image data, combined from all the IDAT chunks
+  #
+  # @return [String] The uncompressed image data for this datastream
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#153
+  def imagedata; end
+
+  # Returns all the textual metadata key/value pairs as hash.
+  #
+  # @return [Hash] A hash containing metadata fields and their values.
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#143
+  def metadata; end
+
+  # All other chunks in this PNG file.
+  #
+  # @return [Array<ChunkyPNG::Chunk::Generic>]
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#22
+  def other_chunks; end
+
+  # All other chunks in this PNG file.
+  #
+  # @return [Array<ChunkyPNG::Chunk::Generic>]
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#22
+  def other_chunks=(_arg0); end
+
+  # The chunk containing the image's palette.
+  #
+  # @return [ChunkyPNG::Chunk::Palette]
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#26
+  def palette_chunk; end
+
+  # The chunk containing the image's palette.
+  #
+  # @return [ChunkyPNG::Chunk::Palette]
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#26
+  def palette_chunk=(_arg0); end
+
+  # The chunk containing the physical dimensions of the PNG's pixels.
+  #
+  # @return [ChunkyPNG::Chunk::Physical]
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#34
+  def physical_chunk; end
+
+  # The chunk containing the physical dimensions of the PNG's pixels.
+  #
+  # @return [ChunkyPNG::Chunk::Physical]
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#34
+  def physical_chunk=(_arg0); end
+
+  # Saves this datastream as a PNG file.
+  #
+  # @param filename [String] The filename to use.
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#170
+  def save(filename); end
+
+  # Encodes this datastream into a string.
+  #
+  # @return [String] The encoded PNG datastream.
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#176
+  def to_blob; end
+
+  # Encodes this datastream into a string.
+  #
+  # @return [String] The encoded PNG datastream.
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#176
+  def to_s; end
+
+  # Encodes this datastream into a string.
+  #
+  # @return [String] The encoded PNG datastream.
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#176
+  def to_string; end
+
+  # The chunk containing the transparency information of the palette.
+  #
+  # @return [ChunkyPNG::Chunk::Transparency]
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#30
+  def transparency_chunk; end
+
+  # The chunk containing the transparency information of the palette.
+  #
+  # @return [ChunkyPNG::Chunk::Transparency]
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#30
+  def transparency_chunk=(_arg0); end
+
+  # Writes the datastream to the given output stream.
+  #
+  # @param io [IO] The output stream to write to.
+  #
+  # source://chunky_png//lib/chunky_png/datastream.rb#163
+  def write(io); end
+
+  class << self
+    # Reads a PNG datastream from a string.
+    #
+    # @param str [String] The PNG encoded string to load from.
+    # @return [ChunkyPNG::Datastream] The loaded datastream instance.
+    #
+    # source://chunky_png//lib/chunky_png/datastream.rb#58
+    def from_blob(str); end
+
+    # Reads a PNG datastream from a file.
+    #
+    # @param filename [String] The path of the file to load from.
+    # @return [ChunkyPNG::Datastream] The loaded datastream instance.
+    #
+    # source://chunky_png//lib/chunky_png/datastream.rb#67
+    def from_file(filename); end
+
+    # Reads a PNG datastream from an input stream
+    #
+    # @param io [IO] The stream to read from.
+    # @return [ChunkyPNG::Datastream] The loaded datastream instance.
+    #
+    # source://chunky_png//lib/chunky_png/datastream.rb#76
+    def from_io(io); end
+
+    # Reads a PNG datastream from a string.
+    #
+    # @param str [String] The PNG encoded string to load from.
+    # @return [ChunkyPNG::Datastream] The loaded datastream instance.
+    #
+    # source://chunky_png//lib/chunky_png/datastream.rb#58
+    def from_string(str); end
+
+    # Verifies that the current stream is a PNG datastream by checking its signature.
+    #
+    # This method reads the PNG signature from the stream, setting the current position
+    # of the stream directly after the signature, where the IHDR chunk should begin.
+    #
+    # @param io [IO] The stream to read the PNG signature from.
+    # @raise [RuntimeError] An exception is raised if the PNG signature is not found at
+    #   the beginning of the stream.
+    #
+    # source://chunky_png//lib/chunky_png/datastream.rb#104
+    def verify_signature!(io); end
+  end
+end
+
+# The signature that each PNG file or stream should begin with.
+#
+# source://chunky_png//lib/chunky_png/datastream.rb#14
+ChunkyPNG::Datastream::SIGNATURE = T.let(T.unsafe(nil), String)
+
+# Class that represents the dimension of something, e.g. a {ChunkyPNG::Canvas}.
+#
+# This class contains some methods to simplify performing dimension related checks.
+#
+# source://chunky_png//lib/chunky_png/dimension.rb#68
+class ChunkyPNG::Dimension
+  # Initializes a new dimension instance.
+  #
+  # @param width [Integer] The width-component of the new dimension.
+  # @param height [Integer] The height-component of the new dimension.
+  # @return [Dimension] a new instance of Dimension
+  #
+  # source://chunky_png//lib/chunky_png/dimension.rb#82
+  def initialize(width, height); end
+
+  # Compares the size of 2 dimensions.
+  #
+  # @param other [ChunkyPNG::Dimension] The dimension to compare with.
+  # @return [-1, 0, 1] -1 if the other dimension has a larger area, 1 of this
+  #   dimension is larger, 0 if both are identical in size.
+  #
+  # source://chunky_png//lib/chunky_png/dimension.rb#121
+  def <=>(other); end
+
+  # Checks whether 2 dimensions are identical.
+  #
+  # @param other [ChunkyPNG::Dimension] The dimension to compare with.
+  # @return [true, false] <tt>true</tt> iff width and height match.
+  #
+  # source://chunky_png//lib/chunky_png/dimension.rb#104
+  def ==(other); end
+
+  # Returns the area of this dimension.
+  #
+  # @return [Integer] The area in number of pixels.
+  #
+  # source://chunky_png//lib/chunky_png/dimension.rb#88
+  def area; end
+
+  # Checks whether 2 dimensions are identical.
+  #
+  # @param other [ChunkyPNG::Dimension] The dimension to compare with.
+  # @return [true, false] <tt>true</tt> iff width and height match.
+  #
+  # source://chunky_png//lib/chunky_png/dimension.rb#104
+  def eql?(other); end
+
+  # Calculates a hash for the dimension object, based on width and height
+  #
+  # @return [Integer] A hashed value of the dimensions
+  #
+  # source://chunky_png//lib/chunky_png/dimension.rb#113
+  def hash; end
+
+  # @return [Integer] The height-component of this dimension.
+  #
+  # source://chunky_png//lib/chunky_png/dimension.rb#77
+  def height; end
+
+  # @return [Integer] The height-component of this dimension.
+  #
+  # source://chunky_png//lib/chunky_png/dimension.rb#77
+  def height=(_arg0); end
+
+  # Checks whether a point is within bounds of this dimension.
+  #
+  # @param point_like [ChunkyPNG::Point, ...] A point-like to bounds-check.
+  # @return [true, false] True iff the x and y coordinate fall in this dimension.
+  # @see ChunkyPNG.Point
+  #
+  # source://chunky_png//lib/chunky_png/dimension.rb#96
+  def include?(*point_like); end
+
+  # Casts this dimension into an array.
+  #
+  # @return [Array<Integer>] <tt>[width, height]</tt> for this dimension.
+  #
+  # source://chunky_png//lib/chunky_png/dimension.rb#127
+  def to_a; end
+
+  # Casts this dimension into an array.
+  #
+  # @return [Array<Integer>] <tt>[width, height]</tt> for this dimension.
+  #
+  # source://chunky_png//lib/chunky_png/dimension.rb#127
+  def to_ary; end
+
+  # @return [Integer] The width-component of this dimension.
+  #
+  # source://chunky_png//lib/chunky_png/dimension.rb#74
+  def width; end
+
+  # @return [Integer] The width-component of this dimension.
+  #
+  # source://chunky_png//lib/chunky_png/dimension.rb#74
+  def width=(_arg0); end
+end
+
+# @private
+# @return [Regexp] The regexp to parse dimensions from a string.
+#
+# source://chunky_png//lib/chunky_png/dimension.rb#71
+ChunkyPNG::Dimension::DIMENSION_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# Null-byte, with the encoding set correctly to ASCII-8BIT (binary) in Ruby 1.9.
+#
+# @private
+# @return [String] A binary string, consisting of one NULL-byte.
+#
+# source://chunky_png//lib/chunky_png.rb#146
+ChunkyPNG::EXTRA_BYTE = T.let(T.unsafe(nil), String)
+
+# Default exception class for ChunkyPNG
+#
+# source://chunky_png//lib/chunky_png.rb#110
+class ChunkyPNG::Exception < ::StandardError; end
+
+# Exception that is raised if an expectation fails.
+#
+# source://chunky_png//lib/chunky_png.rb#131
+class ChunkyPNG::ExpectationFailed < ::ChunkyPNG::Exception; end
+
+# Indicates that the PNG specification's default filtering are
+# being used in the image.
+#
+# @private
+#
+# source://chunky_png//lib/chunky_png.rb#83
+ChunkyPNG::FILTERING_DEFAULT = T.let(T.unsafe(nil), Integer)
+
+# Indicates that AVERAGE filtering is used for the scanline.
+#
+# @private
+#
+# source://chunky_png//lib/chunky_png.rb#99
+ChunkyPNG::FILTER_AVERAGE = T.let(T.unsafe(nil), Integer)
+
+# Indicates that no filtering is used for the scanline.
+#
+# @private
+#
+# source://chunky_png//lib/chunky_png.rb#87
+ChunkyPNG::FILTER_NONE = T.let(T.unsafe(nil), Integer)
+
+# Indicates that PAETH filtering is used for the scanline.
+#
+# @private
+#
+# source://chunky_png//lib/chunky_png.rb#103
+ChunkyPNG::FILTER_PAETH = T.let(T.unsafe(nil), Integer)
+
+# Indicates that SUB filtering is used for the scanline.
+#
+# @private
+#
+# source://chunky_png//lib/chunky_png.rb#91
+ChunkyPNG::FILTER_SUB = T.let(T.unsafe(nil), Integer)
+
+# Indicates that UP filtering is used for the scanline.
+#
+# @private
+#
+# source://chunky_png//lib/chunky_png.rb#95
+ChunkyPNG::FILTER_UP = T.let(T.unsafe(nil), Integer)
+
+# Indicates that the image uses Adam7 interlacing.
+#
+# @private
+#
+# source://chunky_png//lib/chunky_png.rb#76
+ChunkyPNG::INTERLACING_ADAM7 = T.let(T.unsafe(nil), Integer)
+
+# Indicates that the image does not use interlacing.
+#
+# @private
+#
+# source://chunky_png//lib/chunky_png.rb#72
+ChunkyPNG::INTERLACING_NONE = T.let(T.unsafe(nil), Integer)
+
+# ChunkyPNG::Image is an extension of the {ChunkyPNG::Canvas} class, that
+# also includes support for metadata.
+#
+# @see ChunkyPNG::Canvas
+#
+# source://chunky_png//lib/chunky_png/image.rb#10
+class ChunkyPNG::Image < ::ChunkyPNG::Canvas
+  # Initializes a new ChunkyPNG::Image instance.
+  #
+  # @param width [Integer] The width of the new image.
+  # @param height [Integer] The height of the new image.
+  # @param bg_color [Integer] The background color of the new image.
+  # @param metadata [Hash] A hash of metadata fields and values for this image.
+  # @return [Image] a new instance of Image
+  # @see ChunkyPNG::Canvas#initialize
+  #
+  # source://chunky_png//lib/chunky_png/image.rb#22
+  def initialize(width, height, bg_color = T.unsafe(nil), metadata = T.unsafe(nil)); end
+
+  # @return [Hash] The hash of metadata fields for this PNG image.
+  #
+  # source://chunky_png//lib/chunky_png/image.rb#14
+  def metadata; end
+
+  # @return [Hash] The hash of metadata fields for this PNG image.
+  #
+  # source://chunky_png//lib/chunky_png/image.rb#14
+  def metadata=(_arg0); end
+
+  # Returns the metadata for this image as PNG chunks.
+  #
+  # Chunks will either be of the {ChunkyPNG::Chunk::Text} type for small
+  # values (in bytes), or of the {ChunkyPNG::Chunk::CompressedText} type
+  # for values that are larger in size.
+  #
+  # @return [Array<ChunkyPNG::Chunk>] An array of metadata chunks.
+  # @see ChunkyPNG::Image::METADATA_COMPRESSION_TRESHOLD
+  #
+  # source://chunky_png//lib/chunky_png/image.rb#43
+  def metadata_chunks; end
+
+  # Encodes the image to a PNG datastream for saving to disk or writing to an IO stream.
+  #
+  # Besides encoding the canvas, it will also encode the metadata fields to text chunks.
+  #
+  # @param constraints [Hash] The constraints to use when encoding the canvas.
+  # @return [ChunkyPNG::Datastream] The datastream that contains this image.
+  # @see ChunkyPNG::Canvas::PNGEncoding#to_datastream
+  # @see #metadata_chunks
+  #
+  # source://chunky_png//lib/chunky_png/image.rb#61
+  def to_datastream(constraints = T.unsafe(nil)); end
+
+  private
+
+  # Initializes a copy of another ChunkyPNG::Image instance.
+  #
+  # @param other [ChunkyPNG::Image] The other image to copy.
+  #
+  # source://chunky_png//lib/chunky_png/image.rb#30
+  def initialize_copy(other); end
+
+  class << self
+    # Reads a ChunkyPNG::Image instance from a data stream.
+    #
+    # Besides decoding the canvas, this will also read the metadata fields
+    # from the datastream.
+    #
+    # @param ds [ChunkyPNG::Datastream] The datastream to read from.
+    #
+    # source://chunky_png//lib/chunky_png/image.rb#73
+    def from_datastream(ds); end
+  end
+end
+
+# The minimum size of bytes the value of a metadata field should be before compression
+# is enabled for the chunk.
+#
+# source://chunky_png//lib/chunky_png/image.rb#11
+ChunkyPNG::Image::METADATA_COMPRESSION_TRESHOLD = T.let(T.unsafe(nil), Integer)
+
+# Exception that is raised if an tTXt chunk does not contain valid UTF-8 data.
+#
+# source://chunky_png//lib/chunky_png.rb#127
+class ChunkyPNG::InvalidUTF8 < ::ChunkyPNG::Exception; end
+
+# Exception that is raised for an unsupported PNG image.
+#
+# source://chunky_png//lib/chunky_png.rb#114
+class ChunkyPNG::NotSupported < ::ChunkyPNG::Exception; end
+
+# Exception that when provided coordinates are out of bounds for the canvas
+#
+# source://chunky_png//lib/chunky_png.rb#135
+class ChunkyPNG::OutOfBounds < ::ChunkyPNG::ExpectationFailed; end
+
+# A palette describes the set of colors that is being used for an image.
+#
+# A PNG image can contain an explicit palette which defines the colors of
+# that image, but can also use an implicit palette, e.g. all truecolor colors
+# or all grayscale colors.
+#
+# This palette supports decoding colors from a palette if an explicit palette
+# is provided in a PNG datastream, and it supports encoding colors to an
+# explicit palette (stores as PLTE & tRNS chunks in a PNG file).
+#
+# @see ChunkyPNG::Color
+#
+# source://chunky_png//lib/chunky_png/palette.rb#22
+class ChunkyPNG::Palette < ::Set
+  # Builds a new palette given a set (Enumerable instance) of colors.
+  #
+  # @param enum [Enumerable<Integer>] The set of colors to include in this
+  #   palette.This Enumerable can contain duplicates.
+  # @param decoding_map [Array] An array of colors in the exact order at
+  #   which they appeared in the palette chunk, so that this array can be
+  #   used for decoding.
+  # @return [Palette] a new instance of Palette
+  #
+  # source://chunky_png//lib/chunky_png/palette.rb#23
+  def initialize(enum, decoding_map = T.unsafe(nil)); end
+
+  # Returns a color, given the position in the original palette chunk.
+  #
+  # @param index [Integer] The 0-based position of the color in the palette.
+  # @return [ChunkyPNG::Color] The color that is stored in the palette under
+  #   the given index
+  # @see ChunkyPNG::Palette#can_decode?
+  #
+  # source://chunky_png//lib/chunky_png/palette.rb#148
+  def [](index); end
+
+  # Determines the most suitable colormode for this palette.
+  #
+  # @return [Integer] The colormode which would create the smallest possible
+  #   file for images that use this exact palette.
+  #
+  # source://chunky_png//lib/chunky_png/palette.rb#195
+  def best_color_settings; end
+
+  # Check whether this palette only contains bacl and white.
+  #
+  # @return [true, false] True if all colors in this palette are grayscale
+  #   teints.
+  # @see ChunkyPNG::Color#grayscale??
+  #
+  # source://chunky_png//lib/chunky_png/palette.rb#104
+  def black_and_white?; end
+
+  # Checks whether this palette is suitable for decoding an image from a
+  # datastream.
+  #
+  # This requires that the positions of the colors in the original palette
+  # chunk is known, which is stored as an array in the +@decoding_map+
+  # instance variable.
+  #
+  # @return [true, false] True if a decoding map was built when this palette
+  #   was loaded.
+  #
+  # source://chunky_png//lib/chunky_png/palette.rb#126
+  def can_decode?; end
+
+  # Checks whether this palette is suitable for encoding an image from to
+  # datastream.
+  #
+  # This requires that the position of the color in the future palette chunk
+  # is known, which is stored as a hash in the +@encoding_map+ instance
+  # variable.
+  #
+  # @return [true, false] True if a encoding map was built when this palette
+  #   was loaded.
+  #
+  # source://chunky_png//lib/chunky_png/palette.rb#139
+  def can_encode?; end
+
+  # Determines the minimal bit depth required for an indexed image
+  #
+  # @return [Integer] Number of bits per pixel, i.e. 1, 2, 4 or 8, or nil if
+  #   this image cannot be saved as an indexed image.
+  #
+  # source://chunky_png//lib/chunky_png/palette.rb#216
+  def determine_bit_depth; end
+
+  # Check whether this palette only contains grayscale colors.
+  #
+  # @return [true, false] True if all colors in this palette are grayscale
+  #   teints.
+  # @see ChunkyPNG::Color#grayscale??
+  #
+  # source://chunky_png//lib/chunky_png/palette.rb#96
+  def grayscale?; end
+
+  # Returns the position of a color in the palette
+  #
+  # @param color [ChunkyPNG::Color] The color for which to look up the index.
+  # @return [Integer] The 0-based position of the color in the palette.
+  # @see ChunkyPNG::Palette#can_encode?
+  #
+  # source://chunky_png//lib/chunky_png/palette.rb#156
+  def index(color); end
+
+  # Checks whether the size of this palette is suitable for indexed storage.
+  #
+  # @return [true, false] True if the number of colors in this palette is at
+  #   most 256.
+  #
+  # source://chunky_png//lib/chunky_png/palette.rb#81
+  def indexable?; end
+
+  # Check whether this palette only contains opaque colors.
+  #
+  # @return [true, false] True if all colors in this palette are opaque.
+  # @see ChunkyPNG::Color#opaque?
+  #
+  # source://chunky_png//lib/chunky_png/palette.rb#88
+  def opaque?; end
+
+  # Returns a palette with all the opaque variants of the colors in this
+  # palette.
+  #
+  # @return [ChunkyPNG::Palette] A new Palette instance with only opaque
+  #   colors.
+  # @see ChunkyPNG::Color#opaque!
+  #
+  # source://chunky_png//lib/chunky_png/palette.rb#113
+  def opaque_palette; end
+
+  # Creates a PLTE chunk that corresponds with this palette to store the r,
+  # g, and b channels of all colors.
+  #
+  # @note A PLTE chunk should only be included if the image is encoded using
+  #   index colors. After this chunk has been built, the palette becomes
+  #   suitable for encoding an image.
+  # @return [ChunkyPNG::Chunk::Palette] The PLTE chunk.
+  # @see ChunkyPNG::Palette#can_encode?
+  #
+  # source://chunky_png//lib/chunky_png/palette.rb#180
+  def to_plte_chunk; end
+
+  # Creates a tRNS chunk that corresponds with this palette to store the
+  # alpha channel of all colors.
+  #
+  # Note that this chunk can be left out of every color in the palette is
+  # opaque, and the image is encoded using indexed colors.
+  #
+  # @return [ChunkyPNG::Chunk::Transparency] The tRNS chunk.
+  #
+  # source://chunky_png//lib/chunky_png/palette.rb#167
+  def to_trns_chunk; end
+
+  class << self
+    # Builds a palette instance from a given canvas.
+    #
+    # @param canvas [ChunkyPNG::Canvas] The canvas to create a palette for.
+    # @return [ChunkyPNG::Palette] The palette instance.
+    #
+    # source://chunky_png//lib/chunky_png/palette.rb#63
+    def from_canvas(canvas); end
+
+    # Builds a palette instance from a PLTE chunk and optionally a tRNS chunk
+    # from a PNG datastream.
+    #
+    # This method will cerate a palette that is suitable for decoding an image.
+    #
+    # @param palette_chunk [ChunkyPNG::Chunk::Palette] The palette chunk to
+    #   load from
+    # @param transparency_chunk [ChunkyPNG::Chunk::Transparency, nil] The
+    #   optional transparency chunk.
+    # @return [ChunkyPNG::Palette] The loaded palette instance.
+    # @see ChunkyPNG::Palette#can_decode?
+    #
+    # source://chunky_png//lib/chunky_png/palette.rb#41
+    def from_chunks(palette_chunk, transparency_chunk = T.unsafe(nil)); end
+
+    # Builds a palette instance from a given set of pixels.
+    #
+    # @param pixels [Enumerable<Integer>] An enumeration of pixels to create a
+    #   palette for
+    # @return [ChunkyPNG::Palette] The palette instance.
+    #
+    # source://chunky_png//lib/chunky_png/palette.rb#74
+    def from_pixels(pixels); end
+  end
+end
+
+# Simple class that represents a point on a canvas using an x and y coordinate.
+#
+# This class implements some basic methods to handle comparison, the splat operator and
+# bounds checking that make it easier to work with coordinates.
+#
+# @see ChunkyPNG.Point
+#
+# source://chunky_png//lib/chunky_png/point.rb#73
+class ChunkyPNG::Point
+  # Initializes a new point instance.
+  #
+  # @param x [Integer, :to_i] The x-coordinate.
+  # @param y [Integer, :to_i] The y-coordinate.
+  # @return [Point] a new instance of Point
+  #
+  # source://chunky_png//lib/chunky_png/point.rb#87
+  def initialize(x, y); end
+
+  # Compares 2 points.
+  #
+  # It will first compare the y coordinate, and it only takes the x-coordinate into
+  # account if the y-coordinates of the points are identical. This way, an array of
+  # points will be sorted into the order in which they would occur in the pixels
+  # array returned by {ChunkyPNG::Canvas#pixels}.
+  #
+  # @param other [ChunkyPNG::Point] The point to compare this point with.
+  # @return [-1, 0, 1] <tt>-1</tt> If this point comes before the other one, <tt>1</tt>
+  #   if after, and <tt>0</tt> if the points are identical.
+  #
+  # source://chunky_png//lib/chunky_png/point.rb#109
+  def <=>(other); end
+
+  # Checks whether 2 points are identical.
+  #
+  # @return [true, false] <tt>true</tt> iff the x and y coordinates match
+  #
+  # source://chunky_png//lib/chunky_png/point.rb#93
+  def ==(other); end
+
+  # Checks whether 2 points are identical.
+  #
+  # @return [true, false] <tt>true</tt> iff the x and y coordinates match
+  #
+  # source://chunky_png//lib/chunky_png/point.rb#93
+  def eql?(other); end
+
+  # Converts the point instance to an array.
+  #
+  # @return [Array] A 2-element array, i.e. <tt>[x, y]</tt>.
+  #
+  # source://chunky_png//lib/chunky_png/point.rb#115
+  def to_a; end
+
+  # Converts the point instance to an array.
+  #
+  # @return [Array] A 2-element array, i.e. <tt>[x, y]</tt>.
+  #
+  # source://chunky_png//lib/chunky_png/point.rb#115
+  def to_ary; end
+
+  # Checks whether the point falls into a dimension
+  #
+  # @param dimension_like [ChunkyPNG::Dimension, ...] The dimension of which the bounds
+  #   should be taken for the check.
+  # @return [true, false] <tt>true</tt> iff the x and y coordinate fall width the width
+  #   and height of the dimension.
+  #
+  # source://chunky_png//lib/chunky_png/point.rb#126
+  def within_bounds?(*dimension_like); end
+
+  # @return [Integer] The x-coordinate of the point.
+  #
+  # source://chunky_png//lib/chunky_png/point.rb#79
+  def x; end
+
+  # @return [Integer] The x-coordinate of the point.
+  #
+  # source://chunky_png//lib/chunky_png/point.rb#79
+  def x=(_arg0); end
+
+  # @return [Integer] The y-coordinate of the point.
+  #
+  # source://chunky_png//lib/chunky_png/point.rb#82
+  def y; end
+
+  # @return [Integer] The y-coordinate of the point.
+  #
+  # source://chunky_png//lib/chunky_png/point.rb#82
+  def y=(_arg0); end
+end
+
+# @private
+# @return [Regexp] The regexp to parse points from a string.
+#
+# source://chunky_png//lib/chunky_png/point.rb#76
+ChunkyPNG::Point::POINT_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# Exception that is raised if the PNG signature is not encountered at the
+# beginning of the file.
+#
+# source://chunky_png//lib/chunky_png.rb#119
+class ChunkyPNG::SignatureMismatch < ::ChunkyPNG::Exception; end
+
+# Indicates that the PNG chunk content is not compressed
+# flag used in iTXt chunk
+#
+# @private
+#
+# source://chunky_png//lib/chunky_png.rb#63
+ChunkyPNG::UNCOMPRESSED_CONTENT = T.let(T.unsafe(nil), Integer)
+
+# Exception that is raised when requesting the DPI of a PNG that doesn't
+# specify the units of its physical pixel dimensions.
+#
+# source://chunky_png//lib/chunky_png.rb#140
+class ChunkyPNG::UnitsUnknown < ::ChunkyPNG::Exception; end
+
+# The current version of ChunkyPNG.
+# Set it and commit the change this before running rake release.
+#
+# source://chunky_png//lib/chunky_png/version.rb#6
+ChunkyPNG::VERSION = T.let(T.unsafe(nil), String)
+
+# Class that represents a vector of points, i.e. a list of {ChunkyPNG::Point} instances.
+#
+# Vectors can be created quite flexibly. See the {ChunkyPNG.Vector} factory methods for
+# more information on how to construct vectors.
+#
+# source://chunky_png//lib/chunky_png/vector.rb#34
+class ChunkyPNG::Vector
+  include ::Enumerable
+
+  # Initializes a vector based on a list of Point instances.
+  #
+  # You usually do not want to use this method directly, but call {ChunkyPNG.Vector} instead.
+  #
+  # @param points [Array<ChunkyPNG::Point>]
+  # @return [Vector] a new instance of Vector
+  # @see ChunkyPNG.Vector
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#46
+  def initialize(points = T.unsafe(nil)); end
+
+  # Comparison between two vectors for quality.
+  #
+  # @param other [ChunkyPNG::Vector] The vector to compare with.
+  # @return [true, false] true if the list of points are identical
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#98
+  def ==(other); end
+
+  # Returns the point with the given indexof this vector.
+  #
+  # @param index [Integer] The 0-based index of the point in this vector.
+  # @return [ChunkyPNG::Point] The point instance.
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#69
+  def [](index); end
+
+  # Returns the dimension of the minimal bounding rectangle of the points in this vector.
+  #
+  # @return [ChunkyPNG::Dimension] The dimension instance with the width and height
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#162
+  def dimension; end
+
+  # Iterates over all the points in this vector
+  #
+  # @return [void]
+  # @yield [ChunkyPNG::Point] The points in the correct order.
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#91
+  def each(&block); end
+
+  # Iterates over all the edges in this vector.
+  #
+  # An edge is a combination of two subsequent points in the vector. Together, they will form
+  # a path from the first point to the last point
+  #
+  # @param close [true, false] Whether to close the path, i.e. return an edge that connects the last
+  #   point in the vector back to the first point.
+  # @raise [ChunkyPNG::ExpectationFailed] if the vector contains less than two points.
+  # @return [void]
+  # @see #edges
+  # @yield [points.last, points.first]
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#60
+  def each_edge(close = T.unsafe(nil)); end
+
+  # Returns an enumerator that will iterate over all the edges in this vector.
+  #
+  # @param close [true, false] Whether to close the path, i.e. return an edge that connects the last
+  #   point in the vector back to the first point.
+  # @raise [ChunkyPNG::ExpectationFailed] if the vector contains less than two points.
+  # @return [Enumerator] The enumerator that iterates over the edges.
+  # @see #each_edge
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#78
+  def edges(close = T.unsafe(nil)); end
+
+  # Comparison between two vectors for quality.
+  #
+  # @param other [ChunkyPNG::Vector] The vector to compare with.
+  # @return [true, false] true if the list of points are identical
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#98
+  def eql?(other); end
+
+  # Returns the height of the minimal bounding box of all the points in this vector.
+  #
+  # @return [Integer] The y-distance between the points that are farthest from each other.
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#156
+  def height; end
+
+  # Returns the number of points in this vector.
+  #
+  # @return [Integer] The length of the points array.
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#84
+  def length; end
+
+  # Finds the highest x-coordinate in this vector.
+  #
+  # @return [Integer] The highest x-coordinate of all the points in the vector.
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#124
+  def max_x; end
+
+  # Finds the highest y-coordinate in this vector.
+  #
+  # @return [Integer] The highest y-coordinate of all the points in the vector.
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#136
+  def max_y; end
+
+  # Finds the lowest x-coordinate in this vector.
+  #
+  # @return [Integer] The lowest x-coordinate of all the points in the vector.
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#118
+  def min_x; end
+
+  # Finds the lowest y-coordinate in this vector.
+  #
+  # @return [Integer] The lowest y-coordinate of all the points in the vector.
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#130
+  def min_y; end
+
+  # Returns the offset from (0,0) of the minimal bounding box of all the
+  # points in this vector
+  #
+  # @return [ChunkyPNG::Point] A point that describes the top left corner if a
+  #   minimal bounding box would be drawn around all the points in the vector.
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#144
+  def offset; end
+
+  # @return [Array<ChunkyPNG::Point>] The array that holds all the points in this vector.
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#38
+  def points; end
+
+  # Returns the width of the minimal bounding box of all the points in this vector.
+  #
+  # @return [Integer] The x-distance between the points that are farthest from each other.
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#150
+  def width; end
+
+  # Returns the range in x-coordinates for all the points in this vector.
+  #
+  # @return [Range] The (inclusive) range of x-coordinates.
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#106
+  def x_range; end
+
+  # Returns the range in y-coordinates for all the points in this vector.
+  #
+  # @return [Range] The (inclusive) range of y-coordinates.
+  #
+  # source://chunky_png//lib/chunky_png/vector.rb#112
+  def y_range; end
+
+  class << self
+    # @return [Array<ChunkyPNG::Point>] The list of points interpreted from the input array.
+    #
+    # source://chunky_png//lib/chunky_png/vector.rb#167
+    def multiple_from_array(source); end
+
+    # @return [Array<ChunkyPNG::Point>] The list of points parsed from the string.
+    #
+    # source://chunky_png//lib/chunky_png/vector.rb#181
+    def multiple_from_string(source_str); end
+  end
+end