/** @format */
import { Encoder, EncoderEncodeOptions } from './encoder.js';
import { MemoryImage } from '../image/image.js';
import { DitherKernel } from '../filter/dither-kernel.js';
/**
 * Interface for initializing GifEncoder options.
 */
export interface GifEncoderInitOptions {
    /** The delay between frames in milliseconds. */
    delay?: number;
    /** The number of times the GIF should loop. 0 means infinite looping. */
    repeat?: number;
    /**  The sampling factor for color quantization. */
    samplingFactor?: number;
    /** The dithering kernel to use. */
    dither?: DitherKernel;
    /** Whether to use serpentine dithering. */
    ditherSerpentine?: boolean;
}
/**
 * Class for encoding GIF images.
 */
export declare class GifEncoder implements Encoder {
    /**
     * GIF89a identifier.
     */
    private static readonly _gif89Id;
    /**
     * Image Descriptor Record Type.
     */
    private static readonly _imageDescRecordType;
    /**
     * Extension Record Type.
     */
    private static readonly _extensionRecordType;
    /**
     * Terminate Record Type.
     */
    private static readonly _terminateRecordType;
    /**
     * Application Extension.
     */
    private static readonly _applicationExt;
    /**
     * Graphic Control Extension.
     */
    private static readonly _graphicControlExt;
    /**
     * End of File.
     */
    private static readonly _eof;
    /**
     * Number of bits.
     */
    private static readonly _bits;
    /**
     * Hash table size.
     */
    private static readonly _hSize;
    /**
     * Masks for bit operations.
     */
    private static readonly _masks;
    /**
     * Delay between frames.
     */
    private _delay;
    /**
     * Repeat count for the GIF.
     */
    private _repeat;
    /**
     * Number of colors in the palette.
     */
    private _numColors;
    /**
     * Type of quantizer to use.
     */
    private _quantizerType;
    /**
     * Sampling factor for the quantizer.
     */
    private _samplingFactor;
    /**
     * Last image added to the encoder.
     */
    private _lastImage?;
    /**
     * Duration of the last image.
     */
    private _lastImageDuration?;
    /**
     * Last color map used.
     */
    private _lastColorMap?;
    /**
     * Width of the GIF.
     */
    private _width;
    /**
     * Height of the GIF.
     */
    private _height;
    /**
     * Number of encoded frames.
     */
    private _encodedFrames;
    /**
     * Current accumulator for LZW encoding.
     */
    private _curAccum;
    /**
     * Current bits for LZW encoding.
     */
    private _curBits;
    /**
     * Number of bits for LZW encoding.
     */
    private _nBits;
    /**
     * Initial number of bits for LZW encoding.
     */
    private _initBits;
    /**
     * End of file code for LZW encoding.
     */
    private _eofCode;
    /**
     * Maximum code for LZW encoding.
     */
    private _maxCode;
    /**
     * Clear code for LZW encoding.
     */
    private _clearCode;
    /**
     * Free entry for LZW encoding.
     */
    private _freeEnt;
    /**
     * Flag indicating if the clear code was used.
     */
    private _clearFlag;
    /**
     * Block of bytes for LZW encoding.
     */
    private _block;
    /**
     * Size of the block for LZW encoding.
     */
    private _blockSize;
    /**
     * Output buffer for the encoded GIF.
     */
    private _outputBuffer?;
    /**
     * Dither kernel to use.
     */
    private _dither;
    /**
     * Flag indicating if serpentine dithering is used.
     */
    private _ditherSerpentine;
    /**
     * Does this encoder support animation?
     */
    private readonly _supportsAnimation;
    /**
     * Getter for supportsAnimation.
     */
    get supportsAnimation(): boolean;
    /**
     * Constructor for GifEncoder.
     * @param {GifEncoderInitOptions} [opt] - Initialization options.
     * @param {number} [opt.delay] - The delay between frames in milliseconds. Default is 80.
     * @param {number} [opt.repeat] - The number of times the animation should repeat. Default is 0 (infinite).
     * @param {number} [opt.samplingFactor] - The factor by which to downsample the image. Default is 10.
     * @param {string} [opt.dither] - The dithering algorithm to use. Default is Floyd-Steinberg.
     * @param {boolean} [opt.ditherSerpentine] - Whether to use serpentine dithering. Default is false.
     */
    constructor(opt?: GifEncoderInitOptions);
    /**
     * Adds an image to the GIF.
     * @param {MemoryImage} image - The image to add.
     * @param {number} width - The width of the image.
     * @param {number} height - The height of the image.
     * @throws {LibError} Throws an error if the image does not have a palette.
     */
    private addImage;
    /**
     * Encodes the image using LZW compression.
     * @param {MemoryImage} image - The image to encode.
     */
    private encodeLZW;
    /**
     * Outputs the given code.
     * @param {number | undefined} code - The code to output.
     */
    private output;
    /**
     * Writes the current block to the output buffer.
     */
    private writeBlock;
    /**
     * Adds a byte to the current block.
     * @param {number} c - The byte to add.
     */
    private addToBlock;
    /**
     * Writes the application extension block.
     */
    private writeApplicationExt;
    /**
     * Writes the graphics control extension block.
     * @param {MemoryImage} image - The image for which the extension is written.
     */
    private writeGraphicsCtrlExt;
    /**
     * Writes the GIF header and Logical Screen Descriptor.
     * @param {number} width - The width of the GIF.
     * @param {number} height - The height of the GIF.
     */
    private writeHeader;
    /**
     * Encode the images that were added with **addFrame**.
     * After this has been called (returning the finished GIF),
     * calling **addFrame** for a new animation or image is safe again.
     *
     * **addFrame** will not encode the first image passed and after that
     * always encode the previous image. Hence, the last image needs to be
     * encoded here.
     *
     * @returns {Uint8Array | undefined} The encoded GIF as a byte array, or undefined if there was an error.
     */
    private finish;
    /**
     * This adds the frame passed to **image**.
     * After the last frame has been added, **finish** is required to be called.
     * Optional frame **duration** is in 1/100 sec.
     *
     * @param {MemoryImage} image - The image to add as a frame.
     * @param {number} [duration] - Optional duration of the frame in 1/100 sec.
     */
    addFrame(image: MemoryImage, duration?: number): void;
    /**
     * Encode a single frame image.
     * @param {EncoderEncodeOptions} opt - The options for encoding.
     * @param {MemoryImage} opt.image - The image to encode.
     * @param {boolean} [opt.singleFrame] - Optional flag to encode a single frame.
     * @returns {Uint8Array} The encoded image as a Uint8Array.
     */
    encode(opt: EncoderEncodeOptions): Uint8Array;
}