export { AddPathMode, AlphaType, BitDepth, BlendMode, BlurStyle, ClipOp, ColorChannel, ColorSpace, ColorType, FillType, FilterMode, FontEdging, FontHinting, FontSlant, FontWeight, FontWidth, ImageFormat, MipmapMode, PaintStyle, Path1DEffectStyle, PathDirection, PathOp, PathVerb, PointMode, SaveLayerFlag, StrokeCap, StrokeJoin, TextAlign, TextDirection, TextEncoding, TileMode, VertexMode, } from "./enums.gen.js";
import { AddPathMode, AlphaType, BitDepth, BlendMode, BlurStyle, ClipOp, ColorChannel, ColorSpace, ColorType, FillType, FilterMode, FontEdging, FontHinting, FontSlant, FontWeight, FontWidth, ImageFormat, MipmapMode, PaintStyle, Path1DEffectStyle, PathDirection, PathOp, PathVerb, PointMode, SaveLayerFlag, StrokeCap, StrokeJoin, TextAlign, TextDirection, TextEncoding, TileMode, VertexMode } from "./enums.gen.js";
export type RRect = ArrayLike<number>;
export type WebGLContextHandle = number;
export type EncodedImageFormat = number;
export declare function XYWHRect(x: number, y: number, w: number, h: number): Float32Array;
export declare function LTRBRect(l: number, t: number, r: number, b: number): Float32Array;
export declare function RRectXY(rect: ArrayLike<number>, rx: number, ry: number): Float32Array;
export declare class Paint {
    ptr: number;
    constructor(_ptr?: number);
    setColor4f(r: number, g: number, b: number, a: number): void;
    setColorComponents(r: number, g: number, b: number, a: number): void;
    setColor(rgba: ArrayLike<number>): void;
    setColorInt(argb: number): void;
    setAlphaf(alpha: number): void;
    setAntiAlias(enabled: boolean): void;
    setDither(enabled: boolean): void;
    setStyle(style: PaintStyle): void;
    setBlendMode(mode: BlendMode): void;
    setStrokeWidth(width: number): void;
    setStrokeCap(cap: StrokeCap): void;
    setStrokeJoin(join: StrokeJoin): void;
    setStrokeMiter(limit: number): void;
    setShader(shader: Shader | undefined): void;
    setImageFilter(filter: ImageFilter | undefined): void;
    setColorFilter(filter: ColorFilter | undefined): void;
    setPathEffect(effect: PathEffect | undefined): void;
    setMaskFilter(filter: MaskFilter | undefined): void;
    setBlender(blender: Blender | undefined): void;
    getColor(): Float32Array;
    getAlphaf(): number;
    getStyle(): PaintStyle;
    getBlendMode(): BlendMode;
    getStrokeWidth(): number;
    getStrokeCap(): StrokeCap;
    getStrokeJoin(): StrokeJoin;
    getStrokeMiter(): number;
    isAntiAlias(): boolean;
    copy(): Paint;
    delete(): void;
}
export declare class Path {
    static readonly AddMode: Readonly<{
        readonly Append: 0;
        readonly Extend: 1;
    }>;
    ptr: number;
    constructor(ptr?: number);
    static MakeFromSVGString(svg: string): Path | undefined;
    static MakeFromOp(a: Path, b: Path, op: PathOp): Path | undefined;
    static MakeRect(rect: ArrayLike<number>, direction?: PathDirection): Path;
    static MakeOval(rect: ArrayLike<number>, direction?: PathDirection, startIndex?: number): Path;
    static MakeCircle(x: number, y: number, radius: number, direction?: PathDirection): Path;
    static MakeRRect(rrect: ArrayLike<number>, direction?: PathDirection): Path;
    static MakeLine(x0: number, y0: number, x1: number, y1: number): Path;
    static MakePolygon(pts: ArrayLike<number>, close: boolean): Path;
    copy(): Path;
    makeTransformed(matrix3x3: ArrayLike<number>): Path;
    makeStroked(opts?: {
        width?: number;
        miter_limit?: number;
        precision?: number;
        join?: StrokeJoin;
        cap?: StrokeCap;
    }): Path | undefined;
    toSVGString(): string;
    readSegments(): Float32Array;
    setFillType(fillType: FillType): void;
    getFillType(): FillType;
    contains(x: number, y: number): boolean;
    computeTightBounds(): Float32Array;
    getBounds(): Float32Array;
    isRect(): Float32Array | undefined;
    isOval(): Float32Array | undefined;
    isRRect(): Float32Array | undefined;
    isEmpty(): boolean;
    countPoints(): number;
    getPoint(index: number): [number, number];
    getGenerationID(): number;
    simplify(): Path | undefined;
    trim(startT: number, stopT: number, isComplement?: boolean): Path | undefined;
    makeAsWinding(): Path | undefined;
    makeDashed(on: number, off: number, phase: number): Path | undefined;
    setIsVolatile(v: boolean): void;
    isVolatile(): boolean;
    equals(other: Path): boolean;
    delete(): void;
    writeToMemory(): Uint8Array;
}
export declare class PathBuilder {
    ptr: number;
    constructor();
    moveTo(x: number, y: number): PathBuilder;
    lineTo(x: number, y: number): PathBuilder;
    quadTo(x1: number, y1: number, x2: number, y2: number): PathBuilder;
    cubicTo(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): PathBuilder;
    close(): PathBuilder;
    addRect(rect: ArrayLike<number>, isCCW?: boolean): PathBuilder;
    addOval(rect: ArrayLike<number>, isCCW?: boolean, startIndex?: number): PathBuilder;
    addRRect(rrect: ArrayLike<number>, isCCW?: boolean): PathBuilder;
    addArc(rect: ArrayLike<number>, startDeg: number, sweepDeg: number): PathBuilder;
    arcToOval(rect: ArrayLike<number>, startDeg: number, sweepDeg: number, forceMoveTo: boolean): PathBuilder;
    conicTo(x1: number, y1: number, x2: number, y2: number, weight: number): PathBuilder;
    offset(dx: number, dy: number): PathBuilder;
    setFillType(fillType: FillType): PathBuilder;
    addPath(path: Path, mode?: AddPathMode): PathBuilder;
    rMoveTo(dx: number, dy: number): PathBuilder;
    rLineTo(dx: number, dy: number): PathBuilder;
    rQuadTo(dx1: number, dy1: number, dx2: number, dy2: number): PathBuilder;
    rCubicTo(dx1: number, dy1: number, dx2: number, dy2: number, dx3: number, dy3: number): PathBuilder;
    rConicTo(dx1: number, dy1: number, dx2: number, dy2: number, weight: number): PathBuilder;
    addCircle(x: number, y: number, radius: number, isCCW?: boolean): PathBuilder;
    addPolygon(pts: ArrayLike<number>, close: boolean): PathBuilder;
    arcToRotated(rx: number, ry: number, xAxisRotate: number, useSmallArc: boolean, isCCW: boolean, x: number, y: number): PathBuilder;
    arcToTangent(x1: number, y1: number, x2: number, y2: number, radius: number): PathBuilder;
    rArcTo(rx: number, ry: number, xAxisRotate: number, useSmallArc: boolean, isCCW: boolean, dx: number, dy: number): PathBuilder;
    snapshot(): Path;
    reset(): PathBuilder;
    detach(): Path;
    detachAndDelete(): Path;
    countPoints(): number;
    isEmpty(): boolean;
    getBounds(): Float32Array;
    contains(x: number, y: number): boolean;
    delete(): void;
}
export declare class Shader {
    ptr: number;
    constructor(ptr: number);
    static MakeColor(color: ArrayLike<number>, colorSpace?: ColorSpace): Shader;
    static MakeLinearGradient(start: ArrayLike<number>, end: ArrayLike<number>, colors: ArrayLike<number>, positions: ArrayLike<number> | undefined, tileMode: TileMode, localMatrix?: ArrayLike<number> | undefined, flags?: number): Shader;
    static MakeRadialGradient(center: ArrayLike<number>, radius: number, colors: ArrayLike<number>, positions: ArrayLike<number> | undefined, tileMode: TileMode, localMatrix?: ArrayLike<number> | undefined, flags?: number): Shader;
    static MakeSweepGradient(cx: number, cy: number, colors: ArrayLike<number>, positions: ArrayLike<number> | undefined, tileMode: TileMode, localMatrix?: ArrayLike<number> | undefined, flags?: number, startAngle?: number, endAngle?: number): Shader;
    static MakeTwoPointConicalGradient(start: ArrayLike<number>, startRadius: number, end: ArrayLike<number>, endRadius: number, colors: ArrayLike<number>, positions: ArrayLike<number> | undefined, tileMode: TileMode, localMatrix?: ArrayLike<number> | undefined, flags?: number): Shader;
    static MakeBlend(blendMode: BlendMode, dst: Shader, src: Shader): Shader;
    static MakeFractalNoise(baseFreqX: number, baseFreqY: number, octaves: number, seed: number, tileW?: number, tileH?: number): Shader;
    static MakeTurbulence(baseFreqX: number, baseFreqY: number, octaves: number, seed: number, tileW?: number, tileH?: number): Shader;
    delete(): void;
    makeWithLocalMatrix(localMatrix: ArrayLike<number>): Shader;
}
export declare class ImageFilter {
    ptr: number;
    constructor(ptr: number);
    static MakeBlur(sigmaX: number, sigmaY: number, tileMode: TileMode, input: ImageFilter | undefined): ImageFilter;
    static MakeDropShadow(dx: number, dy: number, sigmaX: number, sigmaY: number, color: ArrayLike<number>, input: ImageFilter | undefined): ImageFilter;
    static MakeDropShadowOnly(dx: number, dy: number, sigmaX: number, sigmaY: number, color: ArrayLike<number>, input: ImageFilter | undefined): ImageFilter;
    static MakeColorFilter(cf: ColorFilter, input: ImageFilter | undefined): ImageFilter;
    static MakeCompose(outer: ImageFilter, inner: ImageFilter): ImageFilter;
    static MakeOffset(dx: number, dy: number, input: ImageFilter | undefined): ImageFilter;
    static MakeMatrix(matrix3x3: ArrayLike<number>, filter?: FilterMode, mipmap?: MipmapMode, input?: ImageFilter): ImageFilter;
    static MakeBlend(blendMode: BlendMode, background: ImageFilter | undefined, foreground: ImageFilter | undefined): ImageFilter;
    static MakeErode(rx: number, ry: number, input: ImageFilter | undefined): ImageFilter;
    static MakeDilate(rx: number, ry: number, input: ImageFilter | undefined): ImageFilter;
    static MakeShader(shader: Shader): ImageFilter;
    static MakeImage(image: SkImage, sampling: {
        filter?: FilterMode;
        mipmap?: MipmapMode;
        B?: number;
        C?: number;
    }, src?: ArrayLike<number>, dst?: ArrayLike<number>): ImageFilter;
    static MakeDisplacementMap(xChannel: ColorChannel, yChannel: ColorChannel, scale: number, displacement: ImageFilter | undefined, color: ImageFilter | undefined): ImageFilter;
    getOutputBounds(drawBounds: ArrayLike<number>, ctm?: ArrayLike<number>): Int32Array;
    delete(): void;
}
export declare class MaskFilter {
    ptr: number;
    constructor(ptr: number);
    static MakeBlur(style: BlurStyle, sigma: number, respectCTM?: boolean): MaskFilter;
    delete(): void;
}
export declare class Blender {
    ptr: number;
    constructor(ptr: number);
    static Mode(blendMode: BlendMode): Blender;
    delete(): void;
}
export declare class PathEffect {
    ptr: number;
    constructor(ptr: number);
    static MakeDash(intervals: ArrayLike<number>, phase?: number): PathEffect;
    static MakeCorner(radius: number): PathEffect;
    static MakeDiscrete(segLength: number, deviation: number, seed: number): PathEffect;
    static MakeCompose(outer: PathEffect, inner: PathEffect): PathEffect;
    static MakeSum(a: PathEffect, b: PathEffect): PathEffect;
    static MakePath1D(path: Path, advance: number, phase: number, style: Path1DEffectStyle): PathEffect;
    static MakeLine2D(width: number, matrix: ArrayLike<number>): PathEffect;
    static MakePath2D(matrix: ArrayLike<number>, path: Path): PathEffect;
    delete(): void;
}
export declare class ColorFilter {
    ptr: number;
    constructor(ptr: number);
    static MakeMatrix(matrix: ArrayLike<number>): ColorFilter;
    static MakeBlend(color: ArrayLike<number>, blendMode: BlendMode): ColorFilter;
    static MakeCompose(outer: ColorFilter, inner: ColorFilter): ColorFilter;
    static MakeLerp(t: number, dst: ColorFilter, src: ColorFilter): ColorFilter;
    static MakeLinearToSRGB(): ColorFilter;
    static MakeSRGBToLinear(): ColorFilter;
    static MakeLuma(): ColorFilter;
    delete(): void;
}
export declare class Vertices {
    ptr: number;
    constructor(ptr: number);
    static MakeVertices(mode: VertexMode, positions: ArrayLike<number>, texs: ArrayLike<number> | undefined, colors: ArrayLike<number> | undefined, indices: ArrayLike<number> | undefined): Vertices;
    bounds(): Float32Array;
    uniqueID(): number;
    delete(): void;
}
export declare class ContourMeasure {
    ptr: number;
    constructor(ptr: number);
    length(): number;
    isClosed(): boolean;
    getPosTan(distance: number): [number, number, number, number] | undefined;
    getSegment(startD: number, stopD: number, startWithMoveTo: boolean): Path | undefined;
    delete(): void;
}
export declare class ContourMeasureIter {
    ptr: number;
    constructor(path: Path, forceClosed: boolean, resScale?: number);
    next(): ContourMeasure | undefined;
    delete(): void;
}
export declare class SkImage {
    ptr: number;
    constructor(ptr: number);
    static MakeImageFromEncoded(bytes: Uint8Array | ArrayBuffer, alphaType?: AlphaType): SkImage | undefined;
    width(): number;
    height(): number;
    getImageInfo(): {
        width: number;
        height: number;
        colorType: ColorType;
        alphaType: AlphaType;
    };
    getUniqueID(): number;
    makeCopyWithDefaultMipmaps(): SkImage;
    getColorSpace(): ColorSpace;
    makeShader(tx: number, ty: number, filter?: FilterMode, mipmap?: MipmapMode, localMatrix?: ArrayLike<number> | undefined): Shader;
    makeShaderOptions(tx: number, ty: number, filter?: FilterMode, mipmap?: MipmapMode, localMatrix?: ArrayLike<number> | undefined): Shader;
    makeShaderCubic(tx: number, ty: number, cubicB: number, cubicC: number, localMatrix?: ArrayLike<number> | undefined): Shader;
    encodeToBytes(grContext: GrDirectContext | undefined, format?: number, quality?: number): Uint8Array | undefined;
    readPixels(srcX: number, srcY: number, imageInfo: {
        width: number;
        height: number;
        colorType: ColorType;
        alphaType: AlphaType;
        colorSpace?: ColorSpace;
    }): Uint8Array | undefined;
    reinterpretColorSpace(colorSpace: ColorSpace): SkImage;
    delete(): void;
}
export declare class SkImages {
    static deferredFromPicture(picture: Picture, width: number, height: number, localMatrix?: ArrayLike<number> | undefined, paint?: Paint | undefined, bitDepth?: BitDepth, colorSpace?: ColorSpace): SkImage;
}
export interface RuntimeEffectResult {
    effect?: RuntimeEffect;
    error?: string;
}
export interface RuntimeEffectUniform {
    name: string;
    type: number;
    count: number;
    offset: number;
    flags: number;
    isColor: boolean;
    isArray: boolean;
    columns: number;
    rows: number;
    slot: number;
    isInteger: boolean;
}
export declare class RuntimeEffect {
    ptr: number;
    constructor(ptr: number);
    static Make(sksl: string): RuntimeEffectResult;
    static MakeForShader(sksl: string): RuntimeEffectResult;
    static MakeForColorFilter(sksl: string): RuntimeEffectResult;
    static MakeForBlender(sksl: string): RuntimeEffectResult;
    private static _make;
    getUniformCount(): number;
    getUniformSize(): number;
    getUniform(index: number): RuntimeEffectUniform | undefined;
    makeShader(uniforms: Uint8Array | ArrayLike<number> | undefined, localMatrix?: ArrayLike<number> | undefined): Shader;
    makeShaderWithChildren(uniforms: Uint8Array | ArrayLike<number> | undefined, children?: (Shader | undefined)[], localMatrix?: ArrayLike<number> | undefined): Shader;
    private _makeShader;
    makeColorFilter(uniforms: Uint8Array | ArrayLike<number> | undefined): ColorFilter;
    makeBlender(uniforms: Uint8Array | ArrayLike<number> | undefined): Blender;
    delete(): void;
}
export declare class PDFDocument {
    ptr: number;
    constructor();
    beginPage(width: number, height: number): Canvas;
    endPage(): void;
    close(): Uint8Array;
    getBytes(): Uint8Array;
    delete(): void;
}
export interface FontStyle {
    weight: FontWeight;
    width: FontWidth;
    slant: FontSlant;
}
export interface VariationAxis {
    tag: number;
    min: number;
    def: number;
    max: number;
    isHidden: boolean;
}
export declare class Typeface {
    ptr: number;
    constructor(ptr: number);
    static MakeFromData(bytes: Uint8Array | ArrayBuffer): Typeface | undefined;
    getFamilyName(): string;
    fontStyle(): FontStyle;
    getVariationDesignParameters(): VariationAxis[];
    delete(): void;
}
export declare class FontMgr {
    ptr: number;
    constructor(ptr: number);
    static MakeEmpty(): FontMgr;
    static FromData(...buffers: (Uint8Array | ArrayBuffer)[]): FontMgr | undefined;
    countFamilies(): number;
    getFamilyName(index: number): string;
    matchFamilyStyle(name: string, style: {
        weight?: FontWeight;
        width?: FontWidth;
        slant?: FontSlant;
    }): Typeface | undefined;
    delete(): void;
}
export declare class Font {
    ptr: number;
    constructor(typeface?: Typeface | undefined, size?: number);
    copy(): Font;
    setTypeface(typeface: Typeface | undefined): void;
    setSize(size: number): void;
    setScaleX(sx: number): void;
    setSkewX(kx: number): void;
    setEdging(e: FontEdging): void;
    setHinting(h: FontHinting): void;
    setSubpixel(v: boolean): void;
    setEmbeddedBitmaps(v: boolean): void;
    setForceAutoHinting(v: boolean): void;
    setLinearMetrics(v: boolean): void;
    getSize(): number;
    getScaleX(): number;
    getSkewX(): number;
    getEdging(): FontEdging;
    getHinting(): FontHinting;
    countText(text: string, encoding?: TextEncoding): number;
    getGlyphIDs(text: string): Uint16Array;
    measureText(text: string): number;
    getGlyphWidths(glyphs: Uint16Array): Float32Array;
    delete(): void;
}
export declare class TextBlob {
    ptr: number;
    constructor(ptr: number);
    static MakeFromText(text: string, font: Font, encoding?: TextEncoding): TextBlob | undefined;
    static MakeFromGlyphs(glyphs: Uint16Array, font: Font): TextBlob | undefined;
    static MakeFromRSXform(text: string, rsxforms: ArrayLike<number>, font: Font, encoding?: TextEncoding): TextBlob | undefined;
    delete(): void;
}
export declare class Picture {
    ptr: number;
    constructor(ptr: number);
    cullRect(): Float32Array;
    uniqueID(): number;
    approximateOpCount(): number;
    makeShader(tx: number, ty: number, filterMode?: FilterMode, localMatrix?: ArrayLike<number> | undefined, tileRect?: ArrayLike<number> | undefined): Shader;
    serialize(): Uint8Array | undefined;
    delete(): void;
}
export declare class PictureRecorder {
    ptr: number;
    constructor();
    beginRecording(bounds: ArrayLike<number>): Canvas;
    finishRecordingAsPicture(): Picture | undefined;
    delete(): void;
}
export declare class SkUnicodeImpl {
    ptr: number;
    constructor(ptr: number);
    static MakeICU(): SkUnicodeImpl | undefined;
    delete(): void;
}
export declare class TypefaceFontProvider {
    ptr: number;
    constructor();
    static Make(): TypefaceFontProvider;
    registerFont(bytes: Uint8Array | ArrayBuffer, alias?: string): boolean;
    delete(): void;
}
export declare class FontCollection {
    ptr: number;
    constructor();
    static Make(): FontCollection;
    setDefaultFontManager(mgr: TypefaceFontProvider | FontMgr | undefined): void;
    setDynamicFontManager(provider: TypefaceFontProvider | undefined): void;
    enableFontFallback(): void;
    clearCaches(): void;
    delete(): void;
}
interface TextShadow {
    color?: ArrayLike<number>;
    offset?: ArrayLike<number>;
    blurRadius?: number;
}
interface TextFontFeatures {
    name: string;
    value: number;
}
interface TextFontVariations {
    axis: string;
    value: number;
}
interface TextStyleProps {
    color?: ArrayLike<number>;
    foregroundColor?: ArrayLike<number>;
    backgroundColor?: ArrayLike<number>;
    decoration?: number;
    decorationColor?: ArrayLike<number>;
    decorationThickness?: number;
    decorationStyle?: number;
    fontFamilies?: string[];
    fontFeatures?: TextFontFeatures[];
    fontSize?: number;
    fontStyle?: {
        weight?: FontWeight;
        width?: FontWidth;
        slant?: FontSlant;
    };
    fontVariations?: TextFontVariations[];
    heightMultiplier?: number;
    halfLeading?: boolean;
    letterSpacing?: number;
    locale?: string;
    shadows?: TextShadow[];
    textBaseline?: number;
    wordSpacing?: number;
}
interface StrutStyleProps {
    strutEnabled?: boolean;
    fontFamilies?: string[];
    fontStyle?: {
        weight?: FontWeight;
        width?: FontWidth;
        slant?: FontSlant;
    };
    fontSize?: number;
    heightMultiplier?: number;
    halfLeading?: boolean;
    leading?: number;
    forceStrutHeight?: boolean;
}
interface ParagraphStyleProps {
    disableHinting?: boolean;
    ellipsis?: string;
    heightMultiplier?: number;
    maxLines?: number;
    replaceTabCharacters?: boolean;
    strutStyle?: StrutStyleProps;
    textAlign?: TextAlign;
    textDirection?: TextDirection;
    textHeightBehavior?: number;
    textStyle?: TextStyleProps;
    applyRoundingHack?: boolean;
}
export interface LineMetrics {
    startIndex: number;
    endIndex: number;
    endExcludingWhitespaces: number;
    endIncludingNewline: number;
    hardBreak: boolean;
    ascent: number;
    descent: number;
    height: number;
    width: number;
    left: number;
    baseline: number;
    lineNumber: number;
}
export interface GlyphInfo {
    graphemeLayoutBounds: Float32Array;
    graphemeClusterTextRange: {
        start: number;
        end: number;
    };
    direction: TextDirection;
    isEllipsis: boolean;
}
export declare class Paragraph {
    ptr: number;
    constructor(ptr: number);
    layout(width: number): void;
    paint(canvas: Canvas, x: number, y: number): void;
    getMaxWidth(): number;
    getHeight(): number;
    getMinIntrinsicWidth(): number;
    getMaxIntrinsicWidth(): number;
    getAlphabeticBaseline(): number;
    getIdeographicBaseline(): number;
    getNumberOfLines(): number;
    didExceedMaxLines(): boolean;
    getGlyphPositionAtCoordinate(dx: number, dy: number): {
        position: number;
        affinity: number;
    };
    getLineMetricsAt(lineNumber: number): LineMetrics | undefined;
    getLineMetrics(): LineMetrics[];
    getLongestLine(): number;
    getRectsForRange(start: number, end: number, rectHeightStyle: number, rectWidthStyle: number): Float32Array;
    getWordBoundary(offset: number): {
        start: number;
        end: number;
    };
    getLineNumberAt(index: number): number;
    getRectsForPlaceholders(): Float32Array;
    getGlyphInfoAt(index: number): GlyphInfo | undefined;
    getClosestGlyphInfoAtCoordinate(dx: number, dy: number): GlyphInfo | undefined;
    getPath(): Path;
    unresolvedCodepoints(): number[];
    delete(): void;
}
export declare class ParagraphBuilder {
    ptr: number;
    constructor(ptr: number);
    static MakeFromFontCollection(style: ParagraphStyleProps, fc: FontCollection, unicode?: SkUnicodeImpl): ParagraphBuilder;
    pushStyle(style: TextStyleProps): void;
    pushPaintStyle(textStyle: TextStyleProps, fg: Paint, bg: Paint): void;
    pop(): void;
    addText(text: string): void;
    addPlaceholder(width: number, height: number, alignment: number, baseline: number, offset: number): void;
    build(): Paragraph;
    reset(): void;
    getText(): string;
    delete(): void;
}
export declare class Canvas {
    ptr: number;
    _glHandle: number;
    constructor(ptr: number);
    clear(rOrColor: number | ArrayLike<number>, g?: number, b?: number, a?: number): void;
    drawColor(color: ArrayLike<number>, blendMode?: BlendMode): void;
    drawColorInt(color: number, blendMode?: BlendMode): void;
    drawPaint(paint: Paint): void;
    drawRect(rect: ArrayLike<number>, paint: Paint): void;
    drawRect4f(l: number, t: number, r: number, b: number, paint: Paint): void;
    drawRRect(rrect: ArrayLike<number>, paint: Paint): void;
    drawCircle(cx: number, cy: number, radius: number, paint: Paint): void;
    drawOval(rect: ArrayLike<number>, paint: Paint): void;
    drawLine(x0: number, y0: number, x1: number, y1: number, paint: Paint): void;
    drawPath(path: Path, paint: Paint): void;
    drawVertices(vertices: Vertices, blendMode: BlendMode, paint: Paint): void;
    drawImage(image: SkImage, x: number, y: number, paint?: Paint | undefined, filter?: FilterMode, mipmap?: MipmapMode): void;
    drawImageRect(image: SkImage, src: ArrayLike<number>, dst: ArrayLike<number>, paint?: Paint | undefined, fastSample?: boolean, filter?: FilterMode, mipmap?: MipmapMode): void;
    drawImageNine(image: SkImage, center: ArrayLike<number>, dst: ArrayLike<number>, filter: FilterMode, paint?: Paint | undefined): void;
    drawImageCubic(image: SkImage, x: number, y: number, B: number, C: number, paint?: Paint | undefined): void;
    drawImageRectCubic(image: SkImage, src: ArrayLike<number>, dst: ArrayLike<number>, B: number, C: number, paint?: Paint | undefined): void;
    writePixels(pixels: Uint8Array, srcWidth: number, srcHeight: number, destX: number, destY: number, alphaType?: number, colorType?: number, colorSpace?: ColorSpace): boolean;
    makeSurface(info: {
        width: number;
        height: number;
        colorType?: ColorType;
        alphaType?: AlphaType;
        colorSpace?: ColorSpace;
    }): Surface | undefined;
    drawParagraph(p: Paragraph, x: number, y: number): void;
    drawArc(oval: ArrayLike<number>, startAngle: number, sweepAngle: number, useCenter: boolean, paint: Paint): void;
    drawDRRect(outer: ArrayLike<number>, inner: ArrayLike<number>, paint: Paint): void;
    drawPoints(mode: PointMode, points: ArrayLike<number>, paint: Paint): void;
    quickReject(rect: ArrayLike<number>): boolean;
    drawText(text: string, x: number, y: number, paint: Paint, font: Font): void;
    drawGlyphs(glyphs: Uint16Array, positions: ArrayLike<number>, x: number, y: number, font: Font, paint: Paint): void;
    drawTextBlob(blob: TextBlob, x: number, y: number, paint: Paint): void;
    drawPicture(picture: Picture): void;
    drawPatch(cubics: ArrayLike<number>, colors?: ArrayLike<number> | undefined, texs?: ArrayLike<number> | undefined, blendMode?: BlendMode, paint?: Paint): void;
    drawAtlas(atlas: SkImage, srcRects: ArrayLike<number>, dstXforms: ArrayLike<number>, paint: Paint, blendMode?: BlendMode, colors?: ArrayLike<number> | undefined, sampling?: {
        filter?: FilterMode;
        mipmap?: MipmapMode;
        B?: number;
        C?: number;
    }): void;
    drawShadow(path: Path, zPlane: ArrayLike<number>, lightPos: ArrayLike<number>, lightRadius: number, ambientColor: ArrayLike<number>, spotColor: ArrayLike<number>, flags: number): void;
    save(): number;
    saveLayer(paint?: Paint | undefined, bounds?: ArrayLike<number> | undefined, backdrop?: ImageFilter | undefined, flags?: number, backdropTileMode?: TileMode): number;
    restore(): void;
    getSaveCount(): number;
    restoreToCount(count: number): void;
    translate(dx: number, dy: number): void;
    scale(sx: number, sy: number): void;
    rotate(degrees: number, px?: number, py?: number): void;
    skew(sx: number, sy: number): void;
    concat(matrix: ArrayLike<number>): void;
    resetMatrix(): void;
    clipRect(rect: ArrayLike<number>, clipOp?: ClipOp, antiAlias?: boolean): void;
    clipRRect(rrect: ArrayLike<number>, clipOp?: ClipOp, antiAlias?: boolean): void;
    clipPath(path: Path, clipOp?: ClipOp, antiAlias?: boolean): void;
    readPixels(srcX: number, srcY: number, imageInfo: {
        width: number;
        height: number;
        colorType: ColorType;
        alphaType: AlphaType;
        colorSpace?: ColorSpace;
    }, out?: Uint8Array): Uint8Array | undefined;
    getTotalMatrix(): Float32Array;
    getLocalToDevice(): Float32Array;
    getDeviceClipBounds(): Int32Array;
    getSurface(): Surface | undefined;
}
export declare class GrDirectContext {
    ptr: number;
    _glHandle: number;
    constructor(ptr: number, glHandle?: number);
    private _bind;
    setResourceCacheLimitBytes(maxBytes: number): void;
    getResourceCacheLimitBytes(): number;
    getResourceCacheUsage(): {
        count: number;
        bytes: number;
    };
    getResourceCacheUsageBytes(): number;
    getResourceCachePurgeableBytes(): number;
    freeGpuResources(): void;
    purgeUnlockedResources(scratchResourcesOnly?: boolean): void;
    performDeferredCleanup(msNotUsed: number, scratchResourcesOnly?: boolean): void;
    flush(): void;
    submit(syncCpu?: boolean): void;
    flushAndSubmit(syncCpu?: boolean): void;
    abandonContext(): void;
    isAbandoned(): boolean;
    maxTextureSize(): number;
    maxRenderTargetSize(): number;
    releaseResourcesAndAbandonContext(): void;
    delete(): void;
}
export declare class Surface {
    ptr: number;
    _glHandle: number;
    constructor(ptr: number);
    private _bind;
    static MakeSurface(w: number, h: number): Surface | undefined;
    static MakeSurfaceWithInfo(info: {
        width: number;
        height: number;
        colorType?: ColorType;
        alphaType?: AlphaType;
        colorSpace?: ColorSpace;
    }): Surface | undefined;
    makeImageSnapshot(bounds?: ArrayLike<number> | undefined): SkImage;
    draw(canvas: Canvas, x: number, y: number, filter?: FilterMode, mipmap?: MipmapMode, paint?: Paint | undefined): void;
    makeSurface(info: {
        width: number;
        height: number;
        colorType?: ColorType;
        alphaType?: AlphaType;
        colorSpace?: ColorSpace;
    }, sampleCount?: number): Surface | undefined;
    width(): number;
    height(): number;
    sampleCnt(): number;
    makeImageFromTexture(texId: number, info: {
        width: number;
        height: number;
        colorType?: ColorType;
        alphaType?: AlphaType;
    }): SkImage | undefined;
    imageInfo(): {
        width: number;
        height: number;
        colorType: ColorType;
        alphaType: AlphaType;
        colorSpace: ColorSpace;
    };
    flush(): void;
    getCanvas(): Canvas;
    delete(): void;
}
export declare function MakeWebGLContext(handle: number): GrDirectContext | undefined;
export declare function MakeOnScreenGLSurface(grContext: GrDirectContext, width: number, height: number, colorSpace?: ColorSpace, sampleCount?: number, stencil?: number): Surface | undefined;
export declare function MakeSurface(w: number, h: number): Surface | undefined;
export declare function MakeRenderTarget(grContext: GrDirectContext, info: {
    width: number;
    height: number;
    colorType?: ColorType;
    alphaType?: AlphaType;
    colorSpace?: ColorSpace;
}, sampleCount?: number): Surface | undefined;
export declare function GetWebGLContext(canvas: HTMLCanvasElement | OffscreenCanvas, attrs?: WebGLContextAttributes): number;
export declare function setCurrentContext(handle: number): boolean;
export declare function deleteContext(handle: number): void;
export type Image = SkImage;
export interface PencilWasmInitOptions {
    wasmBinary?: Uint8Array;
    locateFile?: (path: string, prefix: string) => string;
}
export interface PencilWasm {
    readonly Surface: typeof Surface;
    readonly Canvas: typeof Canvas;
    readonly Paint: typeof Paint;
    readonly Path: typeof Path;
    readonly PathBuilder: typeof PathBuilder;
    readonly Shader: typeof Shader;
    readonly ImageFilter: typeof ImageFilter;
    readonly ColorFilter: typeof ColorFilter;
    readonly Vertices: typeof Vertices;
    readonly ContourMeasure: typeof ContourMeasure;
    readonly ContourMeasureIter: typeof ContourMeasureIter;
    readonly Image: typeof SkImage;
    readonly RuntimeEffect: typeof RuntimeEffect;
    readonly PDFDocument: typeof PDFDocument;
    readonly FontMgr: typeof FontMgr;
    readonly Typeface: typeof Typeface;
    readonly Font: typeof Font;
    readonly TextBlob: typeof TextBlob;
    readonly Picture: typeof Picture;
    readonly PictureRecorder: typeof PictureRecorder;
    readonly MaskFilter: typeof MaskFilter;
    readonly Blender: typeof Blender;
    readonly SkUnicodeImpl: typeof SkUnicodeImpl;
    readonly TypefaceFontProvider: typeof TypefaceFontProvider;
    readonly FontCollection: typeof FontCollection;
    readonly ParagraphBuilder: typeof ParagraphBuilder;
    readonly Paragraph: typeof Paragraph;
    readonly PathEffect: typeof PathEffect;
    readonly GrDirectContext: typeof GrDirectContext;
    XYWHRect(x: number, y: number, w: number, h: number): Float32Array;
    LTRBRect(l: number, t: number, r: number, b: number): Float32Array;
    RRectXY(rect: ArrayLike<number>, rx: number, ry: number): Float32Array;
    readonly PaintStyle: typeof PaintStyle;
    readonly StrokeCap: typeof StrokeCap;
    readonly StrokeJoin: typeof StrokeJoin;
    readonly TileMode: typeof TileMode;
    readonly ClipOp: typeof ClipOp;
    readonly VertexMode: typeof VertexMode;
    readonly PointMode: typeof PointMode;
    readonly PathOp: typeof PathOp;
    readonly FillType: typeof FillType;
    readonly BlendMode: typeof BlendMode;
    readonly BlurStyle: typeof BlurStyle;
    readonly FilterMode: typeof FilterMode;
    readonly MipmapMode: typeof MipmapMode;
    readonly ImageFormat: typeof ImageFormat;
    readonly TextAlign: typeof TextAlign;
    readonly TextDirection: typeof TextDirection;
    readonly TextEncoding: typeof TextEncoding;
    readonly FontSlant: typeof FontSlant;
    readonly FontWeight: typeof FontWeight;
    readonly FontWidth: typeof FontWidth;
    readonly FontEdging: typeof FontEdging;
    readonly FontHinting: typeof FontHinting;
    readonly ColorType: typeof ColorType;
    readonly AlphaType: typeof AlphaType;
    readonly ColorSpace: typeof ColorSpace;
    readonly ColorChannel: typeof ColorChannel;
    readonly Path1DEffectStyle: typeof Path1DEffectStyle;
    readonly PathVerb: typeof PathVerb;
    readonly SaveLayerFlag: typeof SaveLayerFlag;
    createWebGLContext(canvas: HTMLCanvasElement | OffscreenCanvas, attrs?: WebGLContextAttributes): number;
    setCurrentContext(handle: number): boolean;
    deleteContext(handle: number): void;
    GetWebGLContext(canvas: HTMLCanvasElement | OffscreenCanvas, attrs?: WebGLContextAttributes): number;
    MakeWebGLContext(handle: number): GrDirectContext | undefined;
    MakeOnScreenGLSurface(grContext: GrDirectContext, width: number, height: number, colorSpace?: ColorSpace, sampleCount?: number, stencil?: number): Surface | undefined;
    MakeSurface(w: number, h: number): Surface | undefined;
    MakeRenderTarget(grContext: GrDirectContext, info: {
        width: number;
        height: number;
        colorType?: ColorType;
        alphaType?: AlphaType;
        colorSpace?: ColorSpace;
    }, sampleCount?: number): Surface | undefined;
}
export default function PencilWasmInit(opts?: PencilWasmInitOptions): Promise<PencilWasm>;