/**
 * @copyright
 * Copyright 2026 Steven Roussey
 * All Rights Reserved
 */
import type { GpuImageEncodeFormat, GpuImage as IGpuImage } from "./gpuImage";
import type { ImageChannels } from "./imageTypes";
import type { ImageValue } from "./imageValue";
type Sharp = {
    clone(): Sharp;
    flip(): Sharp;
    flop(): Sharp;
    blur(sigma: number): Sharp;
    grayscale(grayscale?: boolean): Sharp;
    negate(options?: {
        alpha?: boolean;
    }): Sharp;
    recomb(matrix: number[][]): Sharp;
    linear(a: number | number[], b: number | number[]): Sharp;
    threshold(threshold: number, options?: {
        grayscale?: boolean;
    }): Sharp;
    tint(rgb: {
        r: number;
        g: number;
        b: number;
    }): Sharp;
    ensureAlpha(alpha?: number): Sharp;
    extend(options: {
        top?: number;
        bottom?: number;
        left?: number;
        right?: number;
        background?: unknown;
    }): Sharp;
    extract(region: {
        left: number;
        top: number;
        width: number;
        height: number;
    }): Sharp;
    rotate(angle?: number, options?: {
        background?: unknown;
    }): Sharp;
    resize(width?: number | null, height?: number | null, options?: {
        kernel?: string;
        fit?: string;
        background?: unknown;
    }): Sharp;
    raw(): Sharp;
    png(opts?: unknown): Sharp;
    jpeg(opts?: unknown): Sharp;
    webp(opts?: unknown): Sharp;
    metadata(): Promise<{
        width?: number;
        height?: number;
        channels?: number;
    }>;
    toBuffer(opts?: unknown): Promise<Buffer | {
        data: Buffer;
        info: {
            width: number;
            height: number;
            channels: number;
        };
    }>;
};
export declare class SharpImage implements IGpuImage {
    private pipeline;
    readonly width: number;
    readonly height: number;
    readonly channels: ImageChannels;
    readonly backend: "sharp";
    private constructor();
    static from(value: ImageValue): Promise<SharpImage>;
    apply(op: (p: Sharp) => Sharp, outSize?: {
        width: number;
        height: number;
        channels?: ImageChannels;
    }): SharpImage;
    toBuffer(format: "png" | "jpeg" | "raw-rgba"): Promise<Buffer>;
    toImageValue(previewScale: number): Promise<ImageValue>;
    encode(format: GpuImageEncodeFormat, quality?: number): Promise<Uint8Array>;
    dispose(): void;
}
export interface DecodeBufferToRawOptions {
    readonly limitInputPixels?: number;
    readonly sequentialRead?: boolean;
    readonly ensureAlpha?: boolean;
}
export interface RawPixelInput {
    readonly data: Buffer | Uint8ClampedArray;
    readonly width: number;
    readonly height: number;
    readonly channels: 1 | 2 | 3 | 4;
}
export type EncodeRawPixelsOptions = {
    readonly format: "png";
    readonly compressionLevel?: number;
} | {
    readonly format: "jpeg";
    readonly quality?: number;
    readonly mozjpeg?: boolean;
} | {
    readonly format: "webp";
    readonly quality?: number;
};
export declare function probeImageDimensions(buffer: Buffer): Promise<{
    width: number;
    height: number;
    channels: number | undefined;
}>;
export declare function decodeBufferToRaw(buffer: Buffer, options?: DecodeBufferToRawOptions): Promise<{
    data: Buffer;
    width: number;
    height: number;
    channels: number;
}>;
export declare function encodeRawPixels(raw: RawPixelInput, options: EncodeRawPixelsOptions): Promise<Buffer>;
export {};
//# sourceMappingURL=sharpImage.server.d.ts.map