@shopify/react-native-skia 0.1.128 → 0.1.131

package/lib/typescript/src/renderer/processors/math/Transforms.d.ts

@@ -1,4 +1,4 @@
-import type { Vector } from "./Vector";
+import type { Vector } from "../../../skia/types";
 export declare const rotate: (tr: Vector, origin: Vector, rotation: number) => {
     x: number;
     y: number;

package/lib/typescript/src/renderer/processors/math/index.d.ts

@@ -1,5 +1,3 @@
-export * from "./Vector";
 export * from "./Coordinates";
-export * from "./Matrix3";
 export * from "./Math";
 export * from "./Transforms";

package/lib/typescript/src/renderer/useCanvas.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import type { Skia } from "../skia/types";
+import type { SkiaValue } from "../values/types";
+interface CanvasContext {
+    Skia: Skia;
+    size: SkiaValue<{
+        width: number;
+        height: number;
+    }>;
+}
+declare const CanvasContext: React.Context<CanvasContext | null>;
+export declare const CanvasProvider: React.Provider<CanvasContext | null>;
+export declare const useCanvas: () => CanvasContext;
+export {};

package/lib/typescript/src/skia/Skia.d.ts

@@ -1,41 +1,8 @@
-import "./NativeSetup";
-import type { SkiaApi as SkSkiaApi } from "./SkiaApi";
+import type { Skia as SkSkiaApi } from "./types";
 /**
  * Declares the SkiaApi as an available object in the global scope
  */
 declare global {
     var SkiaApi: SkSkiaApi;
 }
-/**
- * Declares the implemented API with overrides.
- */
-export declare const Skia: {
-    Typeface: import("./Typeface").TypefaceFactory;
-    MaskFilter: import("./MaskFilter").MaskFilterFactory;
-    RuntimeEffect: import("./RuntimeEffect").RuntimeEffectFactory;
-    Shader: import("./Shader").ShaderFactory;
-    ImageFilter: import("./ImageFilter").ImageFilterFactory;
-    PathEffect: import("./PathEffect").PathEffectFactory;
-    Data: import("./Data").DataFactory;
-    SVG: import("./SVG").SVGFactory;
-    FontMgr: import("./FontMgr").FontMgrFactory;
-    TextBlob: import("./TextBlob").TextBlobFactory;
-    Matrix: () => import("./Matrix").SkMatrix;
-    Font: (typeface?: import("./Typeface").SkTypeface | undefined, size?: number | undefined) => import("./Font").SkFont;
-    Point: (x: number, y: number) => import("./Point").SkPoint;
-    XYWHRect: (x: number, y: number, width: number, height: number) => import("./Rect").SkRect;
-    RRectXY: (rect: import("./Rect").SkRect, rx: number, ry: number) => import("./RRect").SkRRect;
-    RuntimeShaderBuilder: (rt: import("./RuntimeEffect").SkRuntimeEffect) => import("./RuntimeEffect").SkRuntimeShaderBuilder;
-    Paint: () => import("./Paint").SkPaint;
-    PictureRecorder: () => import("./Picture").SkPictureRecorder;
-    Picture: import("./Picture").PictureFactory;
-    Path: import("./Path").PathFactory;
-    ColorFilter: import("./ColorFilter").ColorFilterFactory;
-    ContourMeasureIter: (path: import("./Path").SkPath, forceClosed: boolean, resScale: number) => import("./ContourMeasure").SkContourMeasureIter;
-    Color: (color: import("./Color").Color) => Float32Array;
-    RSXform: (scos: number, ssin: number, tx: number, ty: number) => import("./RSXform").SkRSXform;
-    MakeSurface: (width: number, height: number) => import("./Surface").SkSurface | null;
-    MakeImageFromEncoded: (encoded: import("./Data").Data) => import("./Image").SkImage | null;
-    MakeImage: (info: import("./Image").ImageInfo, data: import("./Data").Data, bytesPerRow: number) => import("./Image").SkImage | null;
-    MakeVertices: (mode: import("./Vertices").VertexMode, positions: import("./Point").SkPoint[], textureCoordinates?: import("./Point").SkPoint[] | null | undefined, colors?: Float32Array[] | undefined, indices?: number[] | null | undefined, isVolatile?: boolean | undefined) => import("./Vertices").SkVertices;
-};
+export declare const Skia: SkSkiaApi;

package/lib/typescript/src/skia/Skia.web.d.ts

@@ -0,0 +1 @@
+export declare const Skia: import("./types").Skia;

package/lib/typescript/src/skia/core/Data.d.ts

@@ -0,0 +1,5 @@
+import type { DependencyList } from "react";
+import type { SkData, DataSource } from "../types";
+export declare const useDataCollection: <T>(sources: DataSource[], factory: (data: SkData[]) => T, deps?: DependencyList) => T | null;
+export declare const useRawData: <T>(source: DataSource | null | undefined, factory: (data: SkData) => T, onError?: ((err: Error) => void) | undefined) => T | null;
+export declare const useData: (source: DataSource | null | undefined, onError?: ((err: Error) => void) | undefined) => SkData | null;

package/lib/typescript/src/skia/core/Font.d.ts

@@ -0,0 +1,5 @@
+import type { DataSource, SkFont } from "../types";
+/**
+ * Returns a Skia Font object
+ * */
+export declare const useFont: (font: DataSource | null | undefined, size?: number | undefined, onError?: ((err: Error) => void) | undefined) => SkFont | null;

package/lib/typescript/src/skia/core/Image.d.ts

@@ -0,0 +1,5 @@
+import type { DataSource } from "../types";
+/**
+ * Returns a Skia Image object
+ * */
+export declare const useImage: (source: DataSource | null | undefined, onError?: ((err: Error) => void) | undefined) => import("../types").SkImage | null;

package/lib/typescript/src/skia/core/Matrix.d.ts

@@ -0,0 +1,2 @@
+import type { Transforms2d } from "../types";
+export declare const processTransform2d: (transforms: Transforms2d) => import("../types").SkMatrix;

package/lib/typescript/src/skia/core/Paint.d.ts

@@ -0,0 +1,6 @@
+import type { DependencyList } from "react";
+import type { SkPaint } from "../types";
+/**
+ * Returns a Skia Paint object
+ * */
+export declare const usePaint: (initializer?: ((paint: SkPaint) => void) | undefined, deps?: DependencyList | undefined) => SkPaint;

package/lib/typescript/src/skia/core/Path.d.ts

@@ -0,0 +1,21 @@
+import type { DependencyList } from "react";
+import type { SkFont, SkPath } from "../types";
+/**
+ * Memoizes and returns a Skia Path object with optional initializer
+ * @param initializer
+ * @param deps
+ * @returns
+ */
+export declare const usePath: (initializer?: ((path: SkPath) => void) | undefined, deps?: DependencyList | undefined) => SkPath;
+/**
+ * Initializes a Skia Path from an svg path string
+ * @param svgpath
+ * @returns
+ */
+export declare const useSvgPath: (svgpath: string) => SkPath;
+/**
+ * Initializes a Skia Path from a text string
+ * @param svgpath
+ * @returns
+ */
+export declare const useTextPath: (text: string, x: number, y: number, font: SkFont) => SkPath;

package/lib/typescript/src/skia/core/Picture.d.ts

@@ -0,0 +1,9 @@
+import type { DependencyList } from "react";
+import type { SkCanvas, SkPicture, SkRect } from "../types";
+/**
+ * Memoizes and returns an SkPicture that can be drawn to another canvas.
+ * @param rect Picture bounds
+ * @param cb Callback for drawing to the canvas
+ * @returns SkPicture
+ */
+export declare const usePicture: (rect: SkRect, cb: (canvas: SkCanvas) => void, deps?: DependencyList) => SkPicture;

package/lib/typescript/src/skia/core/RRect.d.ts

@@ -0,0 +1,2 @@
+import type { SkRect } from "../types";
+export declare const rrect: (r: SkRect, rx: number, ry: number) => import("../types").SkRRect;

package/lib/typescript/src/skia/core/Rect.d.ts

@@ -0,0 +1,8 @@
+import type { SkRect, SkRRect } from "../types";
+export declare const rect: (x: number, y: number, width: number, height: number) => SkRect;
+export declare const bounds: (rects: SkRect[]) => SkRect;
+export declare const topLeft: (r: SkRect | SkRRect) => import("../types").SkPoint;
+export declare const topRight: (r: SkRect | SkRRect) => import("../types").SkPoint;
+export declare const bottomLeft: (r: SkRect | SkRRect) => import("../types").SkPoint;
+export declare const bottomRight: (r: SkRect | SkRRect) => import("../types").SkPoint;
+export declare const center: (r: SkRect | SkRRect) => import("../types").SkPoint;

package/lib/typescript/src/skia/core/SVG.d.ts

@@ -0,0 +1,2 @@
+import type { DataSource } from "../types";
+export declare const useSVG: (source: DataSource | null | undefined, onError?: ((err: Error) => void) | undefined) => import("../types").SkSVG | null;

package/lib/typescript/src/skia/core/Typeface.d.ts

@@ -0,0 +1,5 @@
+import type { DataSource } from "../types";
+/**
+ * Returns a Skia Typeface object
+ * */
+export declare const useTypeface: (source: DataSource | null | undefined, onError?: ((err: Error) => void) | undefined) => import("../types").SkTypeface | null;

package/lib/typescript/src/skia/core/Vector.d.ts

@@ -0,0 +1,12 @@
+import type { Vector } from "../types";
+export declare const vec: (x?: number, y?: number | undefined) => import("../types").SkPoint;
+export declare const point: (x?: number, y?: number | undefined) => import("../types").SkPoint;
+export declare const neg: (a: Vector) => import("../types").SkPoint;
+export declare const add: (a: Vector, b: Vector) => import("../types").SkPoint;
+export declare const sub: (a: Vector, b: Vector) => import("../types").SkPoint;
+export declare const dist: (a: Vector, b: Vector) => number;
+export declare const translate: ({ x, y }: Vector) => readonly [{
+    readonly translateX: number;
+}, {
+    readonly translateY: number;
+}];

package/lib/typescript/src/skia/core/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./Data";
+export * from "./Font";
+export * from "./Typeface";
+export * from "./Image";
+export * from "./Picture";
+export * from "./SVG";
+export * from "./Path";
+export * from "./Vector";
+export * from "./Rect";
+export * from "./RRect";
+export * from "./Matrix";
+export * from "./Paint";

package/lib/typescript/src/skia/index.d.ts

@@ -1,24 +1,3 @@
 export { Skia } from "./Skia";
-export * from "./Canvas";
-export * from "./Paint";
-export * from "./Rect";
-export * from "./RRect";
-export * from "./Point";
-export * from "./Path";
-export * from "./Font";
-export * from "./Typeface";
-export * from "./MaskFilter";
-export * from "./ColorFilter";
-export * from "./ImageFilter";
-export * from "./PathEffect";
-export * from "./RuntimeEffect";
-export * from "./Shader";
-export * from "./Image";
-export * from "./Matrix";
-export * from "./SVG";
-export * from "./Surface";
-export * from "./FontMgr";
-export * from "./Vertices";
-export * from "./Color";
-export * from "./Picture";
-export * from "./Data";
+export * from "./core";
+export * from "./types";

package/lib/typescript/src/skia/types/Color.d.ts

@@ -0,0 +1,2 @@
+export declare type SkColor = Float32Array;
+export declare type Color = string | Float32Array | number;

package/lib/typescript/src/skia/types/ColorFilter/ColorFilterFactory.d.ts

@@ -0,0 +1,43 @@
+import type { SkColor } from "../Color";
+import type { BlendMode } from "../Paint";
+import type { SkColorFilter } from "./ColorFilter";
+export declare type InputColorMatrix = number[];
+export interface ColorFilterFactory {
+    /**
+     * Creates a color filter using the provided color matrix.
+     * @param cMatrix
+     */
+    MakeMatrix(cMatrix: InputColorMatrix): SkColorFilter;
+    /**
+     * Makes a color filter with the given color and blend mode.
+     * @param color
+     * @param mode
+     */
+    MakeBlend(color: SkColor, mode: BlendMode): SkColorFilter;
+    /**
+     * Makes a color filter composing two color filters.
+     * @param outer
+     * @param inner
+     */
+    MakeCompose(outer: SkColorFilter, inner: SkColorFilter): SkColorFilter;
+    /**
+     * Makes a color filter that is linearly interpolated between two other color filters.
+     * @param t - a float in the range of 0.0 to 1.0.
+     * @param dst
+     * @param src
+     */
+    MakeLerp(t: number, dst: SkColorFilter, src: SkColorFilter): SkColorFilter;
+    /**
+     * Makes a color filter that converts between linear colors and sRGB colors.
+     */
+    MakeLinearToSRGBGamma(): SkColorFilter;
+    /**
+     * Makes a color filter that converts between sRGB colors and linear colors.
+     */
+    MakeSRGBToLinearGamma(): SkColorFilter;
+    /**
+     * Makes a color filter that multiplies the luma of its input into the alpha channel,
+     * and sets the red, green, and blue channels to zero.
+     */
+    MakeLumaColorFilter(): SkColorFilter;
+}

package/lib/typescript/src/skia/types/ContourMeasure.d.ts

@@ -0,0 +1,40 @@
+import type { SkJSIInstance } from "./JsiInstance";
+import type { SkPath } from "./Path/Path";
+export interface PosTan {
+    px: number;
+    py: number;
+    tx: number;
+    ty: number;
+}
+export interface SkContourMeasure extends SkJSIInstance<"ContourMeasure"> {
+    /**
+     * Returns the given position and tangent line for the distance on the given contour.
+     * The return value is 4 floats in this order: posX, posY, vecX, vecY.
+     * @param distance - will be pinned between 0 and length().
+     */
+    getPosTan(distance: number): PosTan;
+    /**
+     * Returns an Path representing the segment of this contour.
+     * @param startD - will be pinned between 0 and length()
+     * @param stopD - will be pinned between 0 and length()
+     * @param startWithMoveTo
+     */
+    getSegment(startD: number, stopD: number, startWithMoveTo: boolean): SkPath;
+    /**
+     * Returns true if the contour is closed.
+     */
+    isClosed(): boolean;
+    /**
+     * Returns the length of this contour.
+     */
+    length(): number;
+}
+export interface SkContourMeasureIter extends SkJSIInstance<"ContourMeasureIter"> {
+    /**
+     *  Iterates through contours in path, returning a contour-measure object for each contour
+     *  in the path. Returns null when it is done.
+     *
+     *  See SkContourMeasure.h for more details.
+     */
+    next(): SkContourMeasure | null;
+}

package/lib/typescript/src/skia/types/Data/Data.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+/// <reference types="react-native" />
+import type { SkJSIInstance } from "../JsiInstance";
+export declare type SkData = SkJSIInstance<"Data">;
+export declare type DataSource = ReturnType<typeof require> | string | Uint8Array;

package/lib/typescript/src/skia/types/Data/DataFactory.d.ts

@@ -0,0 +1,18 @@
+import type { SkData } from "./Data";
+export interface DataFactory {
+    /**
+     * Creates a new Data object from an Uri, either locally or remotely.
+     * @param uri Uri to a valid resource
+     */
+    fromURI(uri: string): Promise<SkData>;
+    /**
+     * Creates a new Data object from a byte array.
+     * @param bytes An array of bytes representing the data
+     */
+    fromBytes(bytes: Uint8Array): SkData;
+    /**
+     * 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/typescript/src/skia/types/Font/Font.d.ts

@@ -0,0 +1,187 @@
+import type { SkJSIInstance } from "../JsiInstance";
+import type { SkPaint } from "../Paint";
+import type { SkRect } from "../Rect";
+import type { SkPoint } from "../Point";
+import type { SkTypeface } from "../Typeface";
+export interface FontMetrics {
+    ascent: number;
+    descent: number;
+    leading: number;
+    bounds?: SkRect;
+}
+export interface SkFont extends SkJSIInstance<"Font"> {
+    /** Returns the advance width of text.
+        The advance is the normal distance to move before drawing additional text.
+        Returns the bounding box of text if bounds is not nullptr. The paint
+        stroke settings, mask filter, or path effect may modify the bounds.
+  
+        @param text        character storage encoded with SkTextEncoding
+        @param byteLength  length of character storage in bytes
+        @param bounds      returns bounding box relative to (0, 0) if not nullptr
+        @param paint       optional; may be nullptr
+        @return            number of glyphs represented by text of length byteLength
+    */
+    measureText: (text: string, paint?: SkPaint) => SkRect;
+    /**
+     * Returns the FontMetrics for this font.
+     */
+    getMetrics(): FontMetrics;
+    /**
+     * Retrieves the glyph ids for each code point in the provided string. This call is passed to
+     * the typeface of this font. Note that glyph IDs are typeface-dependent; different faces
+     * may have different ids for the same code point.
+     * @param str
+     * @param numCodePoints - the number of code points in the string. Defaults to str.length.
+     */
+    getGlyphIDs(str: string, numCodePoints?: number): number[];
+    /**
+     * Retrieves the advanceX measurements for each glyph.
+     * If paint is not null, its stroking, PathEffect, and MaskFilter fields are respected.
+     * One width per glyph is returned in the returned array.
+     * @param glyphs
+     * @param paint
+     * @param output - if provided, the results will be copied into this array.
+     */
+    getGlyphWidths(glyphs: number[], paint?: SkPaint | null, output?: Float32Array): Float32Array;
+    /**
+     * Computes any intersections of a thick "line" and a run of positionsed glyphs.
+     * The thick line is represented as a top and bottom coordinate (positive for
+     * below the baseline, negative for above). If there are no intersections
+     * (e.g. if this is intended as an underline, and there are no "collisions")
+     * then the returned array will be empty. If there are intersections, the array
+     * will contain pairs of X coordinates [start, end] for each segment that
+     * intersected with a glyph.
+     *
+     * @param glyphs        the glyphs to intersect with
+     * @param positions     x,y coordinates (2 per glyph) for each glyph
+     * @param top           top of the thick "line" to use for intersection testing
+     * @param bottom        bottom of the thick "line" to use for intersection testing
+     * @return              array of [start, end] x-coordinate pairs. Maybe be empty.
+     */
+    getGlyphIntercepts(glyphs: number[], positions: SkPoint[], top: number, bottom: number): number[];
+    /**
+     * Returns text scale on x-axis. Default value is 1.
+     */
+    getScaleX(): number;
+    /**
+     * Returns text size in points.
+     */
+    getSize(): number;
+    /**
+     * Returns text skew on x-axis. Default value is zero.
+     */
+    getSkewX(): number;
+    /**
+     * Returns embolden effect for this font. Default value is false.
+     */
+    isEmbolden(): boolean;
+    /**
+     * Returns the Typeface set for this font.
+     */
+    getTypeface(): SkTypeface | null;
+    /**
+     * Requests, but does not require, that edge pixels draw opaque or with partial transparency.
+     * @param edging
+     */
+    setEdging(edging: FontEdging): void;
+    /**
+     * Requests, but does not require, to use bitmaps in fonts instead of outlines.
+     * @param embeddedBitmaps
+     */
+    setEmbeddedBitmaps(embeddedBitmaps: boolean): void;
+    /**
+     * Sets level of glyph outline adjustment.
+     * @param hinting
+     */
+    setHinting(hinting: FontHinting): void;
+    /**
+     * Requests, but does not require, linearly scalable font and glyph metrics.
+     *
+     * For outline fonts 'true' means font and glyph metrics should ignore hinting and rounding.
+     * Note that some bitmap formats may not be able to scale linearly and will ignore this flag.
+     * @param linearMetrics
+     */
+    setLinearMetrics(linearMetrics: boolean): void;
+    /**
+     * Sets the text scale on the x-axis.
+     * @param sx
+     */
+    setScaleX(sx: number): void;
+    /**
+     * Sets the text size in points on this font.
+     * @param points
+     */
+    setSize(points: number): void;
+    /**
+     * Sets the text-skew on the x axis for this font.
+     * @param sx
+     */
+    setSkewX(sx: number): void;
+    /**
+     * Set embolden effect for this font.
+     * @param embolden
+     */
+    setEmbolden(embolden: boolean): void;
+    /**
+     * Requests, but does not require, that glyphs respect sub-pixel positioning.
+     * @param subpixel
+     */
+    setSubpixel(subpixel: boolean): void;
+    /**
+     * Sets the typeface to use with this font. null means to clear the typeface and use the
+     * default one.
+     * @param face
+     */
+    setTypeface(face: SkTypeface | null): void;
+}
+export interface FontStyle {
+    weight?: FontWeight;
+    width?: FontWidth;
+    slant?: FontSlant;
+}
+export declare enum FontWeight {
+    Invisible = 0,
+    Thin = 100,
+    ExtraLight = 200,
+    Light = 300,
+    Normal = 400,
+    Medium = 500,
+    SemiBold = 600,
+    Bold = 700,
+    ExtraBold = 800,
+    Black = 900,
+    ExtraBlack = 1000
+}
+export declare enum FontWidth {
+    UltraCondensed = 1,
+    ExtraCondensed = 2,
+    Condensed = 3,
+    SemiCondensed = 4,
+    Normal = 5,
+    SemiExpanded = 6,
+    Expanded = 7,
+    ExtraExpanded = 8,
+    UltraExpanded = 9
+}
+export declare enum FontSlant {
+    Upright = 0,
+    Italic = 1,
+    Oblique = 2
+}
+export declare enum FontEdging {
+    Alias = 0,
+    AntiAlias = 1,
+    SubpixelAntiAlias = 2
+}
+export declare enum FontHinting {
+    None = 0,
+    Slight = 1,
+    Normal = 2,
+    Full = 3
+}
+export declare const FontStyle: {
+    Normal: FontStyle;
+    Bold: FontStyle;
+    Italic: FontStyle;
+    BoldItalic: FontStyle;
+};

package/lib/typescript/src/skia/types/Font/index.d.ts

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

package/lib/typescript/src/skia/types/FontMgr/FontMgr.d.ts

@@ -0,0 +1,18 @@
+import type { SkJSIInstance } from "../JsiInstance";
+import type { FontStyle } from "../Font/Font";
+import type { SkTypeface } from "../Typeface";
+export interface SkFontMgr extends SkJSIInstance<"FontMgr"> {
+    /**
+     * Return the number of font families loaded in this manager. Useful for debugging.
+     */
+    countFamilies(): number;
+    /**
+     * Return the nth family name. Useful for debugging.
+     * @param index
+     */
+    getFamilyName(index: number): string;
+    /**
+     *  Find the closest matching typeface to the specified familyName and style and return a ref to it.
+     */
+    matchFamilyStyle(familyName: string, fontStyle?: FontStyle): SkTypeface | null;
+}

package/lib/typescript/src/skia/types/FontMgr/FontMgrFactory.d.ts

@@ -0,0 +1,4 @@
+import type { SkFontMgr } from "./FontMgr";
+export interface FontMgrFactory {
+    RefDefault: () => SkFontMgr;
+}

package/lib/typescript/src/skia/types/FontMgr/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./FontMgrFactory";
+export * from "./FontMgr";

package/lib/typescript/src/skia/types/Image/Image.d.ts

@@ -0,0 +1,75 @@
+import type { SkMatrix } from "../Matrix";
+import type { SkJSIInstance } from "../JsiInstance";
+import type { TileMode } from "../ImageFilter";
+import type { SkShader } from "../Shader";
+export declare enum FilterMode {
+    Linear = 0,
+    Nearest = 1
+}
+export declare enum MipmapMode {
+    None = 0,
+    Nearest = 1,
+    Linear = 2
+}
+export declare enum ImageFormat {
+    PNG = 0,
+    JPEG = 1,
+    WEBP = 2
+}
+export interface SkImage extends SkJSIInstance<"Image"> {
+    /**
+     * Returns the possibly scaled height of the image.
+     */
+    height(): number;
+    /**
+     * Returns the possibly scaled width of the image.
+     */
+    width(): number;
+    /**
+     * Returns this image as a shader with the specified tiling. It will use cubic sampling.
+     * @param tx - tile mode in the x direction.
+     * @param ty - tile mode in the y direction.
+     * @param fm - The filter mode. (default nearest)
+     * @param mm - The mipmap mode. Note: for settings other than None, the image must have mipmaps (default none)
+     *             calculated with makeCopyWithDefaultMipmaps;
+     * @param localMatrix
+     */
+    makeShaderOptions(tx: TileMode, ty: TileMode, fm: FilterMode, mm: MipmapMode, localMatrix?: SkMatrix): SkShader;
+    /**
+     * Returns this image as a shader with the specified tiling. It will use cubic sampling.
+     * @param tx - tile mode in the x direction.
+     * @param ty - tile mode in the y direction.
+     * @param B - See CubicResampler in SkSamplingOptions.h for more information
+     * @param C - See CubicResampler in SkSamplingOptions.h for more information
+     * @param localMatrix
+     */
+    makeShaderCubic(tx: TileMode, ty: TileMode, B: number, C: number, localMatrix?: SkMatrix): SkShader;
+    /** Encodes Image pixels, returning result as UInt8Array. Returns existing
+       encoded data if present; otherwise, SkImage is encoded with
+       SkEncodedImageFormat::kPNG. Skia must be built with SK_ENCODE_PNG to encode
+       SkImage.
+  
+      Returns nullptr if existing encoded data is missing or invalid, and
+      encoding fails.
+  
+      @param fmt - PNG is the default value.
+      @param quality - a value from 0 to 100; 100 is the least lossy. May be ignored.
+  
+      @return  Uint8Array with data
+    */
+    encodeToBytes(fmt?: ImageFormat, quality?: number): Uint8Array;
+    /** Encodes Image pixels, returning result as a base64 encoded string. Returns existing
+       encoded data if present; otherwise, SkImage is encoded with
+       SkEncodedImageFormat::kPNG. Skia must be built with SK_ENCODE_PNG to encode
+       SkImage.
+  
+      Returns nullptr if existing encoded data is missing or invalid, and
+      encoding fails.
+  
+      @param fmt - PNG is the default value.
+      @param quality - a value from 0 to 100; 100 is the least lossy. May be ignored.
+  
+      @return  base64 encoded string of data
+    */
+    encodeToBase64(fmt?: ImageFormat, quality?: number): string;
+}