@shopify/react-native-skia 0.1.171 → 0.1.172

package/lib/commonjs/skia/web/JsiSkCanvas.d.ts

@@ -0,0 +1,44 @@
+import type { Canvas, CanvasKit } from "canvaskit-wasm";
+import type { BlendMode, ClipOp, FilterMode, MipmapMode, PointMode, SaveLayerFlag, SkCanvas, SkColor, SkFont, SkImage, SkImageFilter, SkMatrix, SkPaint, SkPath, SkPicture, SkPoint, SkRect, SkRRect, SkSVG, SkTextBlob, SkVertices } from "../types";
+import { HostObject } from "./Host";
+export declare class JsiSkCanvas extends HostObject<Canvas, "Canvas"> implements SkCanvas {
+    constructor(CanvasKit: CanvasKit, ref: Canvas);
+    drawRect(rect: SkRect, paint: SkPaint): void;
+    drawImage(image: SkImage, x: number, y: number, paint?: SkPaint): void;
+    drawImageRect(img: SkImage, src: SkRect, dest: SkRect, paint: SkPaint, fastSample?: boolean): void;
+    drawImageCubic(img: SkImage, left: number, top: number, B: number, C: number, paint?: SkPaint | null): void;
+    drawImageOptions(img: SkImage, left: number, top: number, fm: FilterMode, mm: MipmapMode, paint?: SkPaint | null): void;
+    drawImageNine(img: SkImage, center: SkRect, dest: SkRect, filter: FilterMode, paint?: SkPaint | null): void;
+    drawImageRectCubic(img: SkImage, src: SkRect, dest: SkRect, B: number, C: number, paint?: SkPaint | null): void;
+    drawImageRectOptions(img: SkImage, src: SkRect, dest: SkRect, fm: FilterMode, mm: MipmapMode, paint?: SkPaint | null): void;
+    drawPaint(paint: SkPaint): void;
+    drawLine(x0: number, y0: number, x1: number, y1: number, paint: SkPaint): void;
+    drawCircle(cx: number, cy: number, radius: number, paint: SkPaint): void;
+    drawVertices(verts: SkVertices, mode: BlendMode, paint: SkPaint): void;
+    drawPatch(cubics: SkPoint[], colors?: SkColor[] | null, texs?: SkPoint[] | null, mode?: BlendMode | null, paint?: SkPaint): void;
+    restoreToCount(saveCount: number): void;
+    drawPoints(mode: PointMode, points: SkPoint[], paint: SkPaint): void;
+    drawArc(oval: SkRect, startAngle: number, sweepAngle: number, useCenter: boolean, paint: SkPaint): void;
+    drawRRect(rrect: SkRRect, paint: SkPaint): void;
+    drawDRRect(outer: SkRRect, inner: SkRRect, paint: SkPaint): void;
+    drawOval(oval: SkRect, paint: SkPaint): void;
+    drawPath(path: SkPath, paint: SkPaint): void;
+    drawText(str: string, x: number, y: number, paint: SkPaint, font: SkFont): void;
+    drawTextBlob(blob: SkTextBlob, x: number, y: number, paint: SkPaint): void;
+    drawGlyphs(glyphs: number[], positions: SkPoint[], x: number, y: number, font: SkFont, paint: SkPaint): void;
+    drawSvg(_svgDom: SkSVG, _width?: number, _height?: number): void;
+    save(): number;
+    saveLayer(paint?: SkPaint, bounds?: SkRect | null, backdrop?: SkImageFilter | null, flags?: SaveLayerFlag): number;
+    restore(): void;
+    rotate(rotationInDegrees: number, rx: number, ry: number): void;
+    scale(sx: number, sy: number): void;
+    skew(sx: number, sy: number): void;
+    translate(dx: number, dy: number): void;
+    drawColor(color: SkColor, blendMode?: BlendMode): void;
+    clear(color: SkColor): void;
+    clipPath(path: SkPath, op: ClipOp, doAntiAlias: boolean): void;
+    clipRect(rect: SkRect, op: ClipOp, doAntiAlias: boolean): void;
+    clipRRect(rrect: SkRRect, op: ClipOp, doAntiAlias: boolean): void;
+    concat(m: SkMatrix): void;
+    drawPicture(skp: SkPicture): void;
+}

package/lib/commonjs/skia/web/JsiSkColor.d.ts

@@ -0,0 +1,2 @@
+import type { SkColor, Color as InputColor } from "../types";
+export declare const Color: (color: InputColor) => SkColor;

package/lib/commonjs/skia/web/JsiSkColorFilter.d.ts

@@ -0,0 +1,6 @@
+import type { CanvasKit, ColorFilter } from "canvaskit-wasm";
+import type { SkColorFilter } from "../types";
+import { HostObject } from "./Host";
+export declare class JsiSkColorFilter extends HostObject<ColorFilter, "ColorFilter"> implements SkColorFilter {
+    constructor(CanvasKit: CanvasKit, ref: ColorFilter);
+}

package/lib/commonjs/skia/web/JsiSkColorFilterFactory.d.ts

@@ -0,0 +1,14 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { ColorFilterFactory, SkColorFilter, InputColorMatrix, SkColor, BlendMode } from "../types";
+import { Host } from "./Host";
+import { JsiSkColorFilter } from "./JsiSkColorFilter";
+export declare class JsiSkColorFilterFactory extends Host implements ColorFilterFactory {
+    constructor(CanvasKit: CanvasKit);
+    MakeMatrix(cMatrix: InputColorMatrix): JsiSkColorFilter;
+    MakeBlend(color: SkColor, mode: BlendMode): JsiSkColorFilter;
+    MakeCompose(outer: SkColorFilter, inner: SkColorFilter): JsiSkColorFilter;
+    MakeLerp(t: number, dst: SkColorFilter, src: SkColorFilter): JsiSkColorFilter;
+    MakeLinearToSRGBGamma(): JsiSkColorFilter;
+    MakeSRGBToLinearGamma(): JsiSkColorFilter;
+    MakeLumaColorFilter(): SkColorFilter;
+}

package/lib/commonjs/skia/web/JsiSkContourMeasure.d.ts

@@ -0,0 +1,12 @@
+import type { CanvasKit, ContourMeasure } from "canvaskit-wasm";
+import type { SkContourMeasure } from "../types";
+import { HostObject } from "./Host";
+import { JsiSkPath } from "./JsiSkPath";
+import { JsiSkPoint } from "./JsiSkPoint";
+export declare class JsiSkContourMeasure extends HostObject<ContourMeasure, "ContourMeasure"> implements SkContourMeasure {
+    constructor(CanvasKit: CanvasKit, ref: ContourMeasure);
+    getPosTan(distance: number): [position: JsiSkPoint, tangent: JsiSkPoint];
+    getSegment(startD: number, stopD: number, startWithMoveTo: boolean): JsiSkPath;
+    isClosed(): boolean;
+    length(): number;
+}

package/lib/commonjs/skia/web/JsiSkContourMeasureIter.d.ts

@@ -0,0 +1,8 @@
+import type { CanvasKit, ContourMeasureIter } from "canvaskit-wasm";
+import type { SkContourMeasureIter } from "../types/ContourMeasure";
+import { HostObject } from "./Host";
+import { JsiSkContourMeasure } from "./JsiSkContourMeasure";
+export declare class JsiSkContourMeasureIter extends HostObject<ContourMeasureIter, "ContourMeasureIter"> implements SkContourMeasureIter {
+    constructor(CanvasKit: CanvasKit, ref: ContourMeasureIter);
+    next(): JsiSkContourMeasure | null;
+}

package/lib/commonjs/skia/web/JsiSkData.d.ts

@@ -0,0 +1,8 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { SkData } from "../types";
+import { HostObject } from "./Host";
+declare type Data = ArrayBuffer;
+export declare class JsiSkData extends HostObject<Data, "Data"> implements SkData {
+    constructor(CanvasKit: CanvasKit, ref: Data);
+}
+export {};

package/lib/commonjs/skia/web/JsiSkDataFactory.d.ts

@@ -0,0 +1,19 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { SkData } from "../types";
+import type { DataFactory } from "../types/Data/DataFactory";
+import { Host } from "./Host";
+import { JsiSkData } from "./JsiSkData";
+export declare class JsiSkDataFactory extends Host implements DataFactory {
+    constructor(CanvasKit: CanvasKit);
+    fromURI(uri: string): Promise<JsiSkData>;
+    /**
+     * Creates a new Data object from a byte array.
+     * @param bytes An array of bytes representing the data
+     */
+    fromBytes(bytes: Uint8Array): JsiSkData;
+    /**
+     * Creates a new Data object from a base64 encoded string.
+     * @param base64 A Base64 encoded string representing the data
+     */
+    fromBase64(base64: string): SkData;
+}

package/lib/commonjs/skia/web/JsiSkFont.d.ts

@@ -0,0 +1,33 @@
+import type { CanvasKit, Font } from "canvaskit-wasm";
+import type { FontEdging, FontHinting, SkFont, SkPaint, SkPoint, SkTypeface } from "../types";
+import { HostObject } from "./Host";
+import { JsiSkRect } from "./JsiSkRect";
+import { JsiSkTypeface } from "./JsiSkTypeface";
+export declare class JsiSkFont extends HostObject<Font, "Font"> implements SkFont {
+    constructor(CanvasKit: CanvasKit, ref: Font);
+    getTextWidth(text: string, paint?: SkPaint | undefined): number;
+    getMetrics(): {
+        ascent: number;
+        descent: number;
+        leading: number;
+        bounds: JsiSkRect | undefined;
+    };
+    getGlyphIDs(str: string, numCodePoints?: number): number[];
+    getGlyphWidths(glyphs: number[], paint?: SkPaint | null): number[];
+    getGlyphIntercepts(glyphs: number[], positions: SkPoint[], top: number, bottom: number): number[];
+    getScaleX(): number;
+    getSize(): number;
+    getSkewX(): number;
+    isEmbolden(): boolean;
+    getTypeface(): JsiSkTypeface | null;
+    setEdging(edging: FontEdging): void;
+    setEmbeddedBitmaps(embeddedBitmaps: boolean): void;
+    setHinting(hinting: FontHinting): void;
+    setLinearMetrics(linearMetrics: boolean): void;
+    setScaleX(sx: number): void;
+    setSize(points: number): void;
+    setSkewX(sx: number): void;
+    setEmbolden(embolden: boolean): void;
+    setSubpixel(subpixel: boolean): void;
+    setTypeface(face: SkTypeface | null): void;
+}

package/lib/commonjs/skia/web/JsiSkImage.d.ts

@@ -0,0 +1,12 @@
+import type { CanvasKit, Image } from "canvaskit-wasm";
+import type { ImageFormat, FilterMode, MipmapMode, SkImage, SkMatrix, SkShader, TileMode } from "../types";
+import { HostObject } from "./Host";
+export declare class JsiSkImage extends HostObject<Image, "Image"> implements SkImage {
+    constructor(CanvasKit: CanvasKit, ref: Image);
+    height(): number;
+    width(): number;
+    makeShaderOptions(tx: TileMode, ty: TileMode, fm: FilterMode, mm: MipmapMode, localMatrix?: SkMatrix): SkShader;
+    makeShaderCubic(tx: TileMode, ty: TileMode, B: number, C: number, localMatrix?: SkMatrix): SkShader;
+    encodeToBytes(fmt?: ImageFormat, quality?: number): Uint8Array;
+    encodeToBase64(fmt?: ImageFormat, quality?: number): string;
+}

package/lib/commonjs/skia/web/JsiSkImageFactory.d.ts

@@ -0,0 +1,10 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { SkData, ImageInfo } from "../types";
+import type { ImageFactory } from "../types/Image/ImageFactory";
+import { Host } from "./Host";
+import { JsiSkImage } from "./JsiSkImage";
+export declare class JsiSkImageFactory extends Host implements ImageFactory {
+    constructor(CanvasKit: CanvasKit);
+    MakeImageFromEncoded(encoded: SkData): JsiSkImage | null;
+    MakeImage(info: ImageInfo, data: SkData, bytesPerRow: number): JsiSkImage | null;
+}

package/lib/commonjs/skia/web/JsiSkImageFilter.d.ts

@@ -0,0 +1,6 @@
+import type { CanvasKit, ImageFilter } from "canvaskit-wasm";
+import type { SkImageFilter } from "../types";
+import { HostObject } from "./Host";
+export declare class JsiSkImageFilter extends HostObject<ImageFilter, "ImageFilter"> implements SkImageFilter {
+    constructor(CanvasKit: CanvasKit, ref: ImageFilter);
+}

package/lib/commonjs/skia/web/JsiSkImageFilterFactory.d.ts

@@ -0,0 +1,19 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { ColorChannel, ImageFilterFactory, SkColor, SkColorFilter, SkImageFilter, BlendMode, SkRect, SkRuntimeShaderBuilder, SkShader, TileMode } from "../types";
+import { Host } from "./Host";
+import { JsiSkImageFilter } from "./JsiSkImageFilter";
+export declare class JsiSkImageFilterFactory extends Host implements ImageFilterFactory {
+    constructor(CanvasKit: CanvasKit);
+    MakeOffset(dx: number, dy: number, input: SkImageFilter | null): JsiSkImageFilter;
+    MakeDisplacementMap(channelX: ColorChannel, channelY: ColorChannel, scale: number, in1: SkImageFilter, input: SkImageFilter | null): SkImageFilter;
+    MakeShader(shader: SkShader, _input: SkImageFilter | null): SkImageFilter;
+    MakeBlur(sigmaX: number, sigmaY: number, mode: TileMode, input: SkImageFilter | null): JsiSkImageFilter;
+    MakeColorFilter(cf: SkColorFilter, input: SkImageFilter | null): JsiSkImageFilter;
+    MakeCompose(outer: SkImageFilter | null, inner: SkImageFilter | null): JsiSkImageFilter;
+    MakeDropShadow(dx: number, dy: number, sigmaX: number, sigmaY: number, color: SkColor, input: SkImageFilter | null, cropRect?: SkRect): SkImageFilter;
+    MakeDropShadowOnly(dx: number, dy: number, sigmaX: number, sigmaY: number, color: SkColor, input: SkImageFilter | null, cropRect?: SkRect): SkImageFilter;
+    MakeErode(rx: number, ry: number, input: SkImageFilter | null, cropRect?: SkRect): SkImageFilter;
+    MakeDilate(rx: number, ry: number, input: SkImageFilter | null, cropRect?: SkRect): SkImageFilter;
+    MakeBlend(mode: BlendMode, background: SkImageFilter, foreground: SkImageFilter | null, cropRect?: SkRect): SkImageFilter;
+    MakeRuntimeShader(_builder: SkRuntimeShaderBuilder, _childShaderName: string | null, _input: SkImageFilter | null): SkImageFilter;
+}

package/lib/commonjs/skia/web/JsiSkMaskFilter.d.ts

@@ -0,0 +1,6 @@
+import type { CanvasKit, MaskFilter } from "canvaskit-wasm";
+import type { SkMaskFilter } from "../types";
+import { HostObject } from "./Host";
+export declare class JsiSkMaskFilter extends HostObject<MaskFilter, "MaskFilter"> implements SkMaskFilter {
+    constructor(CanvasKit: CanvasKit, ref: MaskFilter);
+}

package/lib/commonjs/skia/web/JsiSkMaskFilterFactory.d.ts

@@ -0,0 +1,9 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { BlurStyle } from "../types";
+import type { MaskFilterFactory } from "../types/MaskFilter";
+import { Host } from "./Host";
+import { JsiSkMaskFilter } from "./JsiSkMaskFilter";
+export declare class JsiSkMaskFilterFactory extends Host implements MaskFilterFactory {
+    constructor(CanvasKit: CanvasKit);
+    MakeBlur(style: BlurStyle, sigma: number, respectCTM: boolean): JsiSkMaskFilter;
+}

package/lib/commonjs/skia/web/JsiSkMatrix.d.ts

@@ -0,0 +1,13 @@
+import type { CanvasKit, Matrix3x3 } from "canvaskit-wasm";
+import type { SkMatrix } from "../types";
+import { HostObject } from "./Host";
+export declare class JsiSkMatrix extends HostObject<Matrix3x3, "Matrix"> implements SkMatrix {
+    constructor(CanvasKit: CanvasKit, ref: Matrix3x3);
+    concat(matrix: SkMatrix): void;
+    translate(x: number, y: number): void;
+    scale(x: number, y?: number): void;
+    skew(x: number, y: number): void;
+    rotate(value: number): void;
+    identity(): void;
+    get(): number[];
+}

package/lib/commonjs/skia/web/JsiSkPaint.d.ts

@@ -0,0 +1,28 @@
+import type { CanvasKit, Paint } from "canvaskit-wasm";
+import type { StrokeJoin, BlendMode, SkColor, SkColorFilter, SkImageFilter, SkPaint, SkShader, StrokeCap, PaintStyle, SkMaskFilter, SkPathEffect } from "../types";
+import { HostObject } from "./Host";
+export declare class JsiSkPaint extends HostObject<Paint, "Paint"> implements SkPaint {
+    constructor(CanvasKit: CanvasKit, ref: Paint);
+    copy(): JsiSkPaint;
+    reset(): void;
+    getAlphaf(): number;
+    getColor(): Float32Array;
+    getStrokeCap(): number;
+    getStrokeJoin(): number;
+    getStrokeMiter(): number;
+    getStrokeWidth(): number;
+    setAlphaf(alpha: number): void;
+    setAntiAlias(aa: boolean): void;
+    setBlendMode(blendMode: BlendMode): void;
+    setColor(color: SkColor): void;
+    setColorFilter(filter: SkColorFilter | null): void;
+    setImageFilter(filter: SkImageFilter | null): void;
+    setMaskFilter(filter: SkMaskFilter | null): void;
+    setPathEffect(effect: SkPathEffect | null): void;
+    setShader(shader: SkShader | null): void;
+    setStrokeCap(cap: StrokeCap): void;
+    setStrokeJoin(join: StrokeJoin): void;
+    setStrokeMiter(limit: number): void;
+    setStrokeWidth(width: number): void;
+    setStyle(style: PaintStyle): void;
+}

package/lib/commonjs/skia/web/JsiSkPath.d.ts

@@ -0,0 +1,57 @@
+import type { CanvasKit, Path } from "canvaskit-wasm";
+import type { FillType, PathCommand, PathOp, SkMatrix, SkPath, SkPoint, SkRect, SkRRect, StrokeOpts } from "../types";
+import { HostObject } from "./Host";
+import { JsiSkPoint } from "./JsiSkPoint";
+import { JsiSkRect } from "./JsiSkRect";
+export declare class JsiSkPath extends HostObject<Path, "Path"> implements SkPath {
+    constructor(CanvasKit: CanvasKit, ref: Path);
+    addPath(src: SkPath, matrix?: SkMatrix, extend?: boolean): this;
+    addArc(oval: SkRect, startAngleInDegrees: number, sweepAngleInDegrees: number): this;
+    addOval(oval: SkRect, isCCW?: boolean, startIndex?: number): this;
+    countPoints(): number;
+    addPoly(points: SkPoint[], close: boolean): this;
+    moveTo(x: number, y: number): this;
+    lineTo(x: number, y: number): this;
+    makeAsWinding(): this | null;
+    offset(dx: number, dy: number): this;
+    rArcTo(rx: number, ry: number, xAxisRotateInDegrees: number, useSmallArc: boolean, isCCW: boolean, dx: number, dy: number): this;
+    rConicTo(dx1: number, dy1: number, dx2: number, dy2: number, w: number): this;
+    rCubicTo(cpx1: number, cpy1: number, cpx2: number, cpy2: number, x: number, y: number): this;
+    rMoveTo(x: number, y: number): this;
+    rLineTo(x: number, y: number): this;
+    rQuadTo(x1: number, y1: number, x2: number, y2: number): this;
+    setFillType(fill: FillType): void;
+    setIsVolatile(volatile: boolean): void;
+    stroke(opts?: StrokeOpts): this | null;
+    close(): void;
+    reset(): void;
+    rewind(): void;
+    computeTightBounds(): SkRect;
+    arcToOval(oval: SkRect, startAngleInDegrees: number, sweepAngleInDegrees: number, forceMoveTo: boolean): this;
+    arcToRotated(rx: number, ry: number, xAxisRotateInDegrees: number, useSmallArc: boolean, isCCW: boolean, x: number, y: number): this;
+    arcToTangent(x1: number, y1: number, x2: number, y2: number, radius: number): this;
+    conicTo(x1: number, y1: number, x2: number, y2: number, w: number): this;
+    contains(x: number, y: number): boolean;
+    copy(): JsiSkPath;
+    cubicTo(cpx1: number, cpy1: number, cpx2: number, cpy2: number, x: number, y: number): this;
+    dash(on: number, off: number, phase: number): boolean;
+    equals(other: SkPath): boolean;
+    getBounds(): JsiSkRect;
+    getFillType(): number;
+    quadTo(x1: number, y1: number, x2: number, y2: number): void;
+    addRect(rect: SkRect, isCCW?: boolean): void;
+    addRRect(rrect: SkRRect, isCCW?: boolean): this;
+    getPoint(index: number): JsiSkPoint;
+    isEmpty(): boolean;
+    isVolatile(): boolean;
+    addCircle(x: number, y: number, r: number): this;
+    getLastPt(): JsiSkPoint;
+    op(path: SkPath, op: PathOp): boolean;
+    simplify(): boolean;
+    toSVGString(): string;
+    trim(startT: number, stopT: number, isComplement: boolean): this | null;
+    transform(m3: SkMatrix): void;
+    interpolate(end: SkPath, t: number): JsiSkPath | null;
+    isInterpolatable(path2: SkPath): boolean;
+    toCmds(): PathCommand[];
+}

package/lib/commonjs/skia/web/JsiSkPathEffect.d.ts

@@ -0,0 +1,6 @@
+import type { CanvasKit, PathEffect } from "canvaskit-wasm";
+import type { SkPathEffect } from "../types/PathEffect";
+import { HostObject } from "./Host";
+export declare class JsiSkPathEffect extends HostObject<PathEffect, "PathEffect"> implements SkPathEffect {
+    constructor(CanvasKit: CanvasKit, ref: PathEffect);
+}

package/lib/commonjs/skia/web/JsiSkPathEffectFactory.d.ts

@@ -0,0 +1,15 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { Path1DEffectStyle, PathEffectFactory, SkMatrix, SkPath, SkPathEffect } from "../types";
+import { Host } from "./Host";
+import { JsiSkPathEffect } from "./JsiSkPathEffect";
+export declare class JsiSkPathEffectFactory extends Host implements PathEffectFactory {
+    constructor(CanvasKit: CanvasKit);
+    MakeCorner(radius: number): JsiSkPathEffect | null;
+    MakeDash(intervals: number[], phase?: number): JsiSkPathEffect;
+    MakeDiscrete(segLength: number, dev: number, seedAssist: number): JsiSkPathEffect;
+    MakeCompose(_outer: SkPathEffect, _inner: SkPathEffect): SkPathEffect;
+    MakeSum(_outer: SkPathEffect, _inner: SkPathEffect): SkPathEffect;
+    MakeLine2D(width: number, matrix: SkMatrix): JsiSkPathEffect | null;
+    MakePath1D(path: SkPath, advance: number, phase: number, style: Path1DEffectStyle): JsiSkPathEffect | null;
+    MakePath2D(matrix: SkMatrix, path: SkPath): JsiSkPathEffect | null;
+}

package/lib/commonjs/skia/web/JsiSkPathFactory.d.ts

@@ -0,0 +1,13 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { PathCommand, PathOp, SkFont, SkPath } from "../types";
+import type { PathFactory } from "../types/Path/PathFactory";
+import { Host } from "./Host";
+import { JsiSkPath } from "./JsiSkPath";
+export declare class JsiSkPathFactory extends Host implements PathFactory {
+    constructor(CanvasKit: CanvasKit);
+    Make(): JsiSkPath;
+    MakeFromSVGString(str: string): JsiSkPath | null;
+    MakeFromOp(one: SkPath, two: SkPath, op: PathOp): JsiSkPath | null;
+    MakeFromCmds(cmds: PathCommand[]): JsiSkPath | null;
+    MakeFromText(_text: string, _x: number, _y: number, _font: SkFont): SkPath | null;
+}

package/lib/commonjs/skia/web/JsiSkPicture.d.ts

@@ -0,0 +1,9 @@
+import type { CanvasKit, SkPicture as Picture } from "canvaskit-wasm";
+import type { FilterMode, SkRect, TileMode, SkPicture, SkMatrix } from "../types";
+import { HostObject } from "./Host";
+import { JsiSkShader } from "./JsiSkShader";
+export declare class JsiSkPicture extends HostObject<Picture, "Picture"> implements SkPicture {
+    constructor(CanvasKit: CanvasKit, ref: Picture);
+    makeShader(tmx: TileMode, tmy: TileMode, mode: FilterMode, localMatrix?: SkMatrix, tileRect?: SkRect): JsiSkShader;
+    serialize(): Uint8Array | null;
+}

package/lib/commonjs/skia/web/JsiSkPictureFactory.d.ts

@@ -0,0 +1,8 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { PictureFactory } from "../types";
+import { Host } from "./Host";
+import { JsiSkPicture } from "./JsiSkPicture";
+export declare class JsiSkPictureFactory extends Host implements PictureFactory {
+    constructor(CanvasKit: CanvasKit);
+    MakePicture(bytes: Uint8Array | ArrayBuffer): JsiSkPicture | null;
+}

package/lib/commonjs/skia/web/JsiSkPictureRecorder.d.ts

@@ -0,0 +1,11 @@
+import type { CanvasKit, PictureRecorder } from "canvaskit-wasm";
+import type { SkRect } from "../types";
+import type { SkPictureRecorder } from "../types/Picture/PictureRecorder";
+import { HostObject } from "./Host";
+import { JsiSkCanvas } from "./JsiSkCanvas";
+import { JsiSkPicture } from "./JsiSkPicture";
+export declare class JsiSkPictureRecorder extends HostObject<PictureRecorder, "PictureRecorder"> implements SkPictureRecorder {
+    constructor(CanvasKit: CanvasKit, ref: PictureRecorder);
+    beginRecording(bounds: SkRect): JsiSkCanvas;
+    finishRecordingAsPicture(): JsiSkPicture;
+}

package/lib/commonjs/skia/web/JsiSkPoint.d.ts

@@ -0,0 +1,9 @@
+import type { CanvasKit, Point } from "canvaskit-wasm";
+import type { SkPoint } from "../types";
+import { BaseHostObject } from "./Host";
+export declare class JsiSkPoint extends BaseHostObject<Point, "Point"> implements SkPoint {
+    static fromValue(point: SkPoint): Float32Array;
+    constructor(CanvasKit: CanvasKit, ref: Point);
+    get x(): number;
+    get y(): number;
+}

package/lib/commonjs/skia/web/JsiSkRRect.d.ts

@@ -0,0 +1,11 @@
+import type { CanvasKit, RRect } from "canvaskit-wasm";
+import type { SkRect, SkRRect } from "../types";
+import { BaseHostObject } from "./Host";
+import { JsiSkRect } from "./JsiSkRect";
+export declare class JsiSkRRect extends BaseHostObject<RRect, "RRect"> implements SkRRect {
+    static fromValue(CanvasKit: CanvasKit, rect: SkRRect): Float32Array;
+    constructor(CanvasKit: CanvasKit, rect: SkRect, rx: number, ry: number);
+    get rx(): number;
+    get ry(): number;
+    get rect(): JsiSkRect;
+}

package/lib/commonjs/skia/web/JsiSkRSXform.d.ts

@@ -0,0 +1,7 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { SkRSXform } from "../types";
+import { HostObject } from "./Host";
+export declare type RSXform = Float32Array;
+export declare class JsiSkRSXform extends HostObject<RSXform, "RSXform"> implements SkRSXform {
+    constructor(CanvasKit: CanvasKit, ref: RSXform);
+}

package/lib/commonjs/skia/web/JsiSkRect.d.ts

@@ -0,0 +1,11 @@
+import type { CanvasKit, Rect } from "canvaskit-wasm";
+import type { SkRect } from "../types";
+import { BaseHostObject } from "./Host";
+export declare class JsiSkRect extends BaseHostObject<Rect, "Rect"> implements SkRect {
+    static fromValue(CanvasKit: CanvasKit, rect: SkRect): Float32Array;
+    constructor(CanvasKit: CanvasKit, ref: Rect);
+    get x(): number;
+    get y(): number;
+    get width(): number;
+    get height(): number;
+}

package/lib/commonjs/skia/web/JsiSkRuntimeEffect.d.ts

@@ -0,0 +1,16 @@
+import type { CanvasKit, RuntimeEffect } from "canvaskit-wasm";
+import type { SkMatrix, SkShader } from "../types";
+import type { SkRuntimeEffect } from "../types/RuntimeEffect/RuntimeEffect";
+import { HostObject } from "./Host";
+import { JsiSkShader } from "./JsiSkShader";
+export declare class JsiSkRuntimeEffect extends HostObject<RuntimeEffect, "RuntimeEffect"> implements SkRuntimeEffect {
+    private sksl;
+    constructor(CanvasKit: CanvasKit, ref: RuntimeEffect, sksl: string);
+    source(): string;
+    makeShader(uniforms: number[], localMatrix?: SkMatrix): JsiSkShader;
+    makeShaderWithChildren(uniforms: number[], children?: SkShader[], localMatrix?: SkMatrix): JsiSkShader;
+    getUniform(index: number): import("canvaskit-wasm").SkSLUniform;
+    getUniformCount(): number;
+    getUniformFloatCount(): number;
+    getUniformName(index: number): string;
+}

package/lib/commonjs/skia/web/JsiSkRuntimeEffectFactory.d.ts

@@ -0,0 +1,8 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { RuntimeEffectFactory } from "../types/RuntimeEffect/RuntimeEffectFactory";
+import { Host } from "./Host";
+import { JsiSkRuntimeEffect } from "./JsiSkRuntimeEffect";
+export declare class JsiSkRuntimeEffectFactory extends Host implements RuntimeEffectFactory {
+    constructor(CanvasKit: CanvasKit);
+    Make(sksl: string): JsiSkRuntimeEffect | null;
+}

package/lib/commonjs/skia/web/JsiSkSVGFactory.d.ts

@@ -0,0 +1,9 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { SkData, SkSVG } from "../types";
+import type { SVGFactory } from "../types/SVG/SVGFactory";
+import { Host } from "./Host";
+export declare class JsiSkSVGFactory extends Host implements SVGFactory {
+    constructor(CanvasKit: CanvasKit);
+    MakeFromData(_data: SkData): SkSVG | null;
+    MakeFromString(_str: string): SkSVG | null;
+}

package/lib/commonjs/skia/web/JsiSkShader.d.ts

@@ -0,0 +1,6 @@
+import type { CanvasKit, Shader } from "canvaskit-wasm";
+import type { SkShader } from "../types";
+import { HostObject } from "./Host";
+export declare class JsiSkShader extends HostObject<Shader, "Shader"> implements SkShader {
+    constructor(CanvasKit: CanvasKit, ref: Shader);
+}

package/lib/commonjs/skia/web/JsiSkShaderFactory.d.ts

@@ -0,0 +1,16 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { BlendMode, SkColor, SkMatrix, SkPoint, SkShader, TileMode } from "../types";
+import type { ShaderFactory } from "../types/Shader/ShaderFactory";
+import { Host } from "./Host";
+import { JsiSkShader } from "./JsiSkShader";
+export declare class JsiSkShaderFactory extends Host implements ShaderFactory {
+    constructor(CanvasKit: CanvasKit);
+    MakeLinearGradient(start: SkPoint, end: SkPoint, colors: SkColor[], pos: number[] | null, mode: TileMode, localMatrix?: SkMatrix, flags?: number): JsiSkShader;
+    MakeRadialGradient(center: SkPoint, radius: number, colors: SkColor[], pos: number[] | null, mode: TileMode, localMatrix?: SkMatrix, flags?: number): JsiSkShader;
+    MakeTwoPointConicalGradient(start: SkPoint, startRadius: number, end: SkPoint, endRadius: number, colors: SkColor[], pos: number[] | null, mode: TileMode, localMatrix?: SkMatrix, flags?: number): JsiSkShader;
+    MakeSweepGradient(cx: number, cy: number, colors: SkColor[], pos: number[] | null, mode: TileMode, localMatrix?: SkMatrix | null, flags?: number, startAngleInDegrees?: number, endAngleInDegrees?: number): JsiSkShader;
+    MakeTurbulence(baseFreqX: number, baseFreqY: number, octaves: number, seed: number, tileW: number, tileH: number): JsiSkShader;
+    MakeFractalNoise(baseFreqX: number, baseFreqY: number, octaves: number, seed: number, tileW: number, tileH: number): JsiSkShader;
+    MakeBlend(mode: BlendMode, one: SkShader, two: SkShader): JsiSkShader;
+    MakeColor(color: SkColor): JsiSkShader;
+}

package/lib/commonjs/skia/web/JsiSkSurface.d.ts

@@ -0,0 +1,8 @@
+import type { CanvasKit, Surface } from "canvaskit-wasm";
+import type { SkCanvas, SkImage, SkRect, SkSurface } from "../types";
+import { HostObject } from "./Host";
+export declare class JsiSkSurface extends HostObject<Surface, "Surface"> implements SkSurface {
+    constructor(CanvasKit: CanvasKit, ref: Surface);
+    getCanvas(): SkCanvas;
+    makeImageSnapshot(bounds?: SkRect): SkImage;
+}

package/lib/commonjs/skia/web/JsiSkSurfaceFactory.d.ts

@@ -0,0 +1,8 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { SurfaceFactory } from "../types";
+import { Host } from "./Host";
+import { JsiSkSurface } from "./JsiSkSurface";
+export declare class JsiSkSurfaceFactory extends Host implements SurfaceFactory {
+    constructor(CanvasKit: CanvasKit);
+    Make(width: number, height: number): JsiSkSurface;
+}

package/lib/commonjs/skia/web/JsiSkTextBlob.d.ts

@@ -0,0 +1,6 @@
+import type { CanvasKit, TextBlob } from "canvaskit-wasm";
+import type { SkTextBlob } from "../types";
+import { HostObject } from "./Host";
+export declare class JsiSkTextBlob extends HostObject<TextBlob, "TextBlob"> implements SkTextBlob {
+    constructor(CanvasKit: CanvasKit, ref: TextBlob);
+}

package/lib/commonjs/skia/web/JsiSkTextBlobFactory.d.ts

@@ -0,0 +1,13 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { SkFont } from "../types";
+import type { TextBlobFactory } from "../types/TextBlob";
+import type { SkRSXform } from "../types/RSXform";
+import { Host } from "./Host";
+import { JsiSkTextBlob } from "./JsiSkTextBlob";
+export declare class JsiSkTextBlobFactory extends Host implements TextBlobFactory {
+    constructor(CanvasKit: CanvasKit);
+    MakeFromText(str: string, font: SkFont): JsiSkTextBlob;
+    MakeFromGlyphs(glyphs: number[], font: SkFont): JsiSkTextBlob;
+    MakeFromRSXform(str: string, rsxforms: SkRSXform[], font: SkFont): JsiSkTextBlob;
+    MakeFromRSXformGlyphs(glyphs: number[], rsxforms: SkRSXform[], font: SkFont): JsiSkTextBlob;
+}

package/lib/commonjs/skia/web/JsiSkTypeface.d.ts

@@ -0,0 +1,8 @@
+import type { CanvasKit, Typeface } from "canvaskit-wasm";
+import type { SkTypeface } from "../types";
+import { HostObject } from "./Host";
+export declare class JsiSkTypeface extends HostObject<Typeface, "Typeface"> implements SkTypeface {
+    constructor(CanvasKit: CanvasKit, ref: Typeface);
+    get bold(): boolean;
+    get italic(): boolean;
+}

package/lib/commonjs/skia/web/JsiSkTypefaceFactory.d.ts

@@ -0,0 +1,8 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { SkData, TypefaceFactory } from "../types";
+import { Host } from "./Host";
+import { JsiSkTypeface } from "./JsiSkTypeface";
+export declare class JsiSkTypefaceFactory extends Host implements TypefaceFactory {
+    constructor(CanvasKit: CanvasKit);
+    MakeFreeTypeFaceFromData(data: SkData): JsiSkTypeface | null;
+}

package/lib/commonjs/skia/web/JsiSkVertices.d.ts

@@ -0,0 +1,9 @@
+import type { CanvasKit, Vertices } from "canvaskit-wasm";
+import type { SkVertices } from "../types";
+import { HostObject } from "./Host";
+import { JsiSkRect } from "./JsiSkRect";
+export declare class JsiSkVertices extends HostObject<Vertices, "Vertices"> implements SkVertices {
+    constructor(CanvasKit: CanvasKit, ref: Vertices);
+    bounds(): JsiSkRect;
+    uniqueID(): number;
+}

package/lib/commonjs/skia/web/JsiSkVerticesFactory.d.ts

@@ -0,0 +1,4 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { SkColor, SkPoint, VertexMode } from "../types";
+import { JsiSkVertices } from "./JsiSkVertices";
+export declare const MakeVertices: (CanvasKit: CanvasKit, mode: VertexMode, positions: SkPoint[], textureCoordinates?: SkPoint[] | null, colors?: SkColor[], indices?: number[] | null, isVolatile?: boolean) => JsiSkVertices;

package/lib/commonjs/skia/web/JsiSkia.d.ts

@@ -0,0 +1,3 @@
+import type { CanvasKit } from "canvaskit-wasm";
+import type { Skia } from "../types";
+export declare const JsiSkApi: (CanvasKit: CanvasKit) => Skia;

package/lib/commonjs/skia/web/index.d.ts

@@ -0,0 +1 @@
+export * from "./JsiSkia";

package/lib/commonjs/values/api.d.ts

@@ -0,0 +1,5 @@
+import type { ISkiaValueApi } from "./types";
+declare global {
+    var SkiaValueApi: ISkiaValueApi;
+}
+export declare const ValueApi: ISkiaValueApi;

package/lib/commonjs/values/api.web.d.ts

@@ -0,0 +1,2 @@
+export declare const ValueApi: import("./types").ISkiaValueApi;
+export declare const createValue: <T>(initialValue: T) => import("./types").SkiaMutableValue<T>, createComputedValue: <R>(cb: () => R, values: import("./types").SkiaValue<unknown>[]) => import("./types").SkiaValue<R>;

package/lib/commonjs/values/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./useClockValue";
+export * from "./useComputedValue";
+export * from "./useValue";
+export * from "./useValueEffect";