@shopify/react-native-skia 1.0.1 → 1.0.3

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

@@ -0,0 +1,189 @@
+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
+     * @param text
+     * @param paint
+     */
+    measureText(text: string, paint?: SkPaint): SkRect;
+    /**
+     * Retrieves the total width of the provided text
+     * @param text
+     * @param paint
+     * @deprecated Use measureText or getGlyphWidths instead
+     */
+    getTextWidth(text: string, paint?: SkPaint): 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
+     */
+    getGlyphWidths(glyphs: number[], paint?: SkPaint): number[];
+    /**
+     * 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[];
+    /**
+     * 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/FontMgr.d.ts

@@ -0,0 +1,8 @@
+import type { SkJSIInstance } from "../JsiInstance";
+import type { SkTypeface } from "../Typeface";
+import type { FontStyle } from "./Font";
+export interface SkFontMgr extends SkJSIInstance<"FontMgr"> {
+    countFamilies(): number;
+    getFamilyName(index: number): string;
+    matchFamilyStyle(name?: string, style?: FontStyle): SkTypeface;
+}

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

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

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

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

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

@@ -0,0 +1,102 @@
+import type { SkMatrix } from "../Matrix";
+import type { SkJSIInstance } from "../JsiInstance";
+import type { TileMode } from "../ImageFilter";
+import type { SkShader } from "../Shader";
+import type { ImageInfo } from "./ImageFactory";
+export interface CubicResampler {
+    B: number;
+    C: number;
+}
+export interface FilterOptions {
+    filter: FilterMode;
+    mipmap?: MipmapMode;
+}
+export declare enum FilterMode {
+    Nearest = 0,
+    Linear = 1
+}
+export declare enum MipmapMode {
+    None = 0,
+    Nearest = 1,
+    Linear = 2
+}
+export declare enum ImageFormat {
+    JPEG = 3,
+    PNG = 4,
+    WEBP = 6
+}
+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 the ImageInfo describing the image.
+     */
+    getImageInfo(): ImageInfo;
+    /**
+     * 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;
+    /** Read Image pixels
+     *
+     * @param srcX - optional x-axis upper left corner of the rectangle to read from
+     * @param srcY - optional y-axis upper left corner of the rectangle to read from
+     * @param imageInfo - optional describes the pixel format and dimensions of the data to read into
+     * @return Float32Array or Uint8Array with data or null if the read failed.
+     */
+    readPixels(srcX?: number, srcY?: number, imageInfo?: ImageInfo): Float32Array | Uint8Array | null;
+    /**
+     * Returns raster image or lazy image. Copies SkImage backed by GPU texture
+     * into CPU memory if needed. Returns original SkImage if decoded in raster
+     * bitmap, or if encoded in a stream.
+     */
+    makeNonTextureImage(): SkImage;
+}

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

@@ -0,0 +1,73 @@
+import type { SkData } from "../Data";
+import type { SkImage } from "./Image";
+export declare enum AlphaType {
+    Unknown = 0,
+    Opaque = 1,
+    Premul = 2,
+    Unpremul = 3
+}
+export declare enum ColorType {
+    Unknown = 0,
+    Alpha_8 = 1,
+    RGB_565 = 2,
+    ARGB_4444 = 3,
+    RGBA_8888 = 4,
+    RGB_888x = 5,
+    BGRA_8888 = 6,
+    RGBA_1010102 = 7,
+    BGRA_1010102 = 8,
+    RGB_101010x = 9,
+    BGR_101010x = 10,
+    BGR_101010x_XR = 11,
+    RGBA_10x6 = 12,
+    Gray_8 = 13,
+    RGBA_F16Norm = 14,
+    RGBA_F16 = 15,
+    RGBA_F32 = 16,
+    R8G8_unorm = 17,
+    A16_float = 18,
+    R16G16_float = 19,
+    A16_unorm = 20,
+    R16G16_unorm = 21,
+    R16G16B16A16_unorm = 22,
+    SRGBA_8888 = 23,
+    R8_unorm = 24,
+    N32_SkColorType = 25
+}
+export interface ImageInfo {
+    alphaType: AlphaType;
+    colorType: ColorType;
+    height: number;
+    width: number;
+}
+export interface ImageFactory {
+    /**
+     * Return an Image backed by the encoded data, but attempt to defer decoding until the image
+     * is actually used/drawn. This deferral allows the system to cache the result, either on the
+     * CPU or on the GPU, depending on where the image is drawn.
+     * This decoding uses the codecs that have been compiled into CanvasKit. If the bytes are
+     * invalid (or an unrecognized codec), null will be returned. See Image.h for more details.
+     * @param data - Data object with bytes of data
+     * @returns If the encoded format is not supported, or subset is outside of the bounds of the decoded
+     *  image, nullptr is returned.
+     */
+    MakeImageFromEncoded: (encoded: SkData) => SkImage | null;
+    /**
+     * Returns an image that will be a screenshot of the view represented by
+     * the view tag
+     * @param viewTag - The tag of the view to make an image from.
+     * @returns Returns a valid SkImage, if the view tag is invalid, nullptr is returned.
+     */
+    MakeImageFromViewTag: (viewTag: number) => Promise<SkImage | null>;
+    /**
+     * Returns an image with the given pixel data and format.
+     * Note that we will always make a copy of the pixel data, because of inconsistencies in
+     * behavior between GPU and CPU (i.e. the pixel data will be turned into a GPU texture and
+     * not modifiable after creation).
+     *
+     * @param info
+     * @param data - bytes representing the pixel data.
+     * @param bytesPerRow
+     */
+    MakeImage(info: ImageInfo, data: SkData, bytesPerRow: number): SkImage | null;
+}

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

@@ -0,0 +1,2 @@
+export * from "./Image";
+export * from "./ImageFactory";

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

@@ -0,0 +1,23 @@
+import type { SkJSIInstance } from "../JsiInstance";
+export declare enum TileMode {
+    /**
+     *  Replicate the edge color if the shader draws outside of its
+     *  original bounds.
+     */
+    Clamp = 0,
+    /**
+     *  Repeat the shader's image horizontally and vertically.
+     */
+    Repeat = 1,
+    /**
+     *  Repeat the shader's image horizontally and vertically, alternating
+     *  mirror images so that adjacent images always seam.
+     */
+    Mirror = 2,
+    /**
+     *  Only draw within the original domain, return transparent-black everywhere else.
+     */
+    Decal = 3
+}
+export declare const isImageFilter: (obj: SkJSIInstance<string> | null) => obj is SkImageFilter;
+export type SkImageFilter = SkJSIInstance<"ImageFilter">;

package/lib/typescript/src/skia/types/ImageFilter/ImageFilterFactory.d.ts

@@ -0,0 +1,130 @@
+import type { SkColor } from "../Color";
+import type { SkColorFilter } from "../ColorFilter/ColorFilter";
+import type { BlendMode } from "../Paint";
+import type { SkRect } from "../Rect";
+import type { SkRuntimeShaderBuilder } from "../RuntimeEffect";
+import type { SkShader } from "../Shader";
+import type { SkImageFilter, TileMode } from "./ImageFilter";
+export declare enum ColorChannel {
+    R = 0,
+    G = 1,
+    B = 2,
+    A = 3
+}
+export interface ImageFilterFactory {
+    /**
+     * Offsets the input image
+     *
+     * @param dx - Offset along the X axis
+     * @param dy - Offset along the X axis
+     * @param input - if null, it will use the dynamic source image
+     */
+    MakeOffset(dx: number, dy: number, input: SkImageFilter | null): SkImageFilter;
+    /**
+     * Spatially displace pixel values of the filtered image
+     *
+     * @param channelX - Color channel to be used along the X axis
+     * @param channelY - Color channel to be used along the Y axis
+     * @param scale - Scale factor to be used in the displacement
+     * @param in1 - Source image filter to use for the displacement
+     * @param input - if null, it will use the dynamic source image
+     */
+    MakeDisplacementMap(channelX: ColorChannel, channelY: ColorChannel, scale: number, in1: SkImageFilter, input: SkImageFilter | null): SkImageFilter;
+    /**
+     * Transforms a shader into an impage filter
+     *
+     * @param shader - The Shader to be transformed
+     * @param input - if null, it will use the dynamic source image
+     */
+    MakeShader(shader: SkShader, input: SkImageFilter | null): SkImageFilter;
+    /**
+     * Create a filter that blurs its input by the separate X and Y sigmas. The provided tile mode
+     * is used when the blur kernel goes outside the input image.
+     *
+     * @param sigmaX - The Gaussian sigma value for blurring along the X axis.
+     * @param sigmaY - The Gaussian sigma value for blurring along the Y axis.
+     * @param mode
+     * @param input - if null, it will use the dynamic source image (e.g. a saved layer)
+     */
+    MakeBlur(sigmaX: number, sigmaY: number, mode: TileMode, input: SkImageFilter | null): SkImageFilter;
+    /**
+     * Create a filter that applies the color filter to the input filter results.
+     * @param cf
+     * @param input - if null, it will use the dynamic source image (e.g. a saved layer)
+     */
+    MakeColorFilter(cf: SkColorFilter, input: SkImageFilter | null): SkImageFilter;
+    /**
+     * Create a filter that composes 'inner' with 'outer', such that the results of 'inner' are
+     * treated as the source bitmap passed to 'outer'.
+     * If either param is null, the other param will be returned.
+     * @param outer
+     * @param inner - if null, it will use the dynamic source image (e.g. a saved layer)
+     */
+    MakeCompose(outer: SkImageFilter | null, inner: SkImageFilter | null): SkImageFilter;
+    /**
+     * Create a filter that draws a drop shadow under the input content.
+     * This filter produces an image that includes the inputs' content.
+     * @param dx The X offset of the shadow.
+     * @param dy	The Y offset of the shadow.
+     * @param sigmaX	The blur radius for the shadow, along the X axis.
+     * @param sigmaY	The blur radius for the shadow, along the Y axis.
+     * @param color	The color of the drop shadow.
+     * @param input	The input filter, or will use the source bitmap if this is null.
+     * @param cropRect	Optional rectangle that crops the input and output.
+     */
+    MakeDropShadow: (dx: number, dy: number, sigmaX: number, sigmaY: number, color: SkColor, input: SkImageFilter | null, cropRect?: SkRect) => SkImageFilter;
+    /**
+     * Create a filter that renders a drop shadow, in exactly the same manner as ::DropShadow, except
+     * that the resulting image does not include the input content.
+     * This allows the shadow and input to be composed by a filter DAG in a more flexible manner.
+     * @param dx The X offset of the shadow.
+     * @param dy	The Y offset of the shadow.
+     * @param sigmaX	The blur radius for the shadow, along the X axis.
+     * @param sigmaY	The blur radius for the shadow, along the Y axis.
+     * @param color	The color of the drop shadow.
+     * @param input	The input filter, or will use the source bitmap if this is null.
+     * @param cropRect	Optional rectangle that crops the input and output.
+     */
+    MakeDropShadowOnly: (dx: number, dy: number, sigmaX: number, sigmaY: number, color: SkColor, input: SkImageFilter | null, cropRect?: SkRect) => SkImageFilter;
+    /**
+     *  Create a filter that erodes each input pixel's channel values to the minimum channel value
+     *  within the given radii along the x and y axes.
+     *  @param radiusX  The distance to erode along the x axis to either side of each pixel.
+     *  @param radiusY  The distance to erode along the y axis to either side of each pixel.
+     *  @param input    The image filter that is eroded, using source bitmap if this is null.
+     *  @param cropRect Optional rectangle that crops the input and output.
+     */
+    MakeErode: (rx: number, ry: number, input: SkImageFilter | null, cropRect?: SkRect) => SkImageFilter;
+    /**
+     *  Create a filter that dilates each input pixel's channel values to the max value within the
+     *  given radii along the x and y axes.
+     *  @param radiusX  The distance to dilate along the x axis to either side of each pixel.
+     *  @param radiusY  The distance to dilate along the y axis to either side of each pixel.
+     *  @param input    The image filter that is dilated, using source bitmap if this is null.
+     *  @param cropRect Optional rectangle that crops the input and output.
+     */
+    MakeDilate: (rx: number, ry: number, input: SkImageFilter | null, cropRect?: SkRect) => SkImageFilter;
+    /**
+     *  This filter takes an SkBlendMode and uses it to composite the two filters together.
+     *  @param mode       The blend mode that defines the compositing operation
+     *  @param background The Dst pixels used in blending, if null the source bitmap is used.
+     *  @param foreground The Src pixels used in blending, if null the source bitmap is used.
+     *  @cropRect         Optional rectangle to crop input and output.
+     */
+    MakeBlend: (mode: BlendMode, background: SkImageFilter, foreground: SkImageFilter | null, cropRect?: SkRect) => SkImageFilter;
+    /**
+     *  Create a filter that fills the output with the per-pixel evaluation of the SkShader produced
+     *  by the SkRuntimeShaderBuilder. The shader is defined in the image filter's local coordinate
+     *  system, so it will automatically be affected by SkCanvas' transform.
+     *
+     *  @param builder         The builder used to produce the runtime shader, that will in turn
+     *                         fill the result image
+     *  @param childShaderName The name of the child shader defined in the builder that will be
+     *                         bound to the input param (or the source image if the input param
+     *                         is null).  If null the builder can have exactly one child shader,
+     *                         which automatically binds the input param.
+     *  @param input           The image filter that will be provided as input to the runtime
+     *                         shader. If null the implicit source image is used instead
+     */
+    MakeRuntimeShader: (builder: SkRuntimeShaderBuilder, childShaderName: string | null, input: SkImageFilter | null) => SkImageFilter;
+}

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

@@ -0,0 +1,2 @@
+export * from "./ImageFilter";
+export * from "./ImageFilterFactory";

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

@@ -0,0 +1,4 @@
+export interface SkJSIInstance<T extends string> {
+    __typename__: T;
+    dispose(): void;
+}

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

@@ -0,0 +1,21 @@
+import type { SkJSIInstance } from "./JsiInstance";
+export declare enum BlurStyle {
+    Normal = 0,
+    Solid = 1,
+    Outer = 2,
+    Inner = 3
+}
+export declare const isMaskFilter: (obj: SkJSIInstance<string> | null) => obj is SkMaskFilter;
+export type SkMaskFilter = SkJSIInstance<"MaskFilter">;
+/**
+ * See SkMaskFilter.h for more details.
+ */
+export interface MaskFilterFactory {
+    /**
+     * Create a blur maskfilter
+     * @param style
+     * @param sigma - Standard deviation of the Gaussian blur to apply. Must be > 0.
+     * @param respectCTM - if true the blur's sigma is modified by the CTM.
+     */
+    MakeBlur(style: BlurStyle, sigma: number, respectCTM: boolean): SkMaskFilter;
+}

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

@@ -0,0 +1,23 @@
+import type { SkJSIInstance } from "./JsiInstance";
+import type { SkCanvas } from "./Canvas";
+import type { Matrix3, Matrix4, Transforms3d } from "./Matrix4";
+export declare const isMatrix: (obj: unknown) => obj is SkMatrix;
+export interface SkMatrix extends SkJSIInstance<"Matrix"> {
+    concat: (matrix: InputMatrix) => SkMatrix;
+    translate: (x: number, y: number) => SkMatrix;
+    scale: (x: number, y?: number) => SkMatrix;
+    skew: (x: number, y: number) => SkMatrix;
+    rotate: (theta: number) => SkMatrix;
+    postTranslate: (x: number, y: number) => SkMatrix;
+    postScale: (x: number, y?: number) => SkMatrix;
+    postSkew: (x: number, y: number) => SkMatrix;
+    postRotate: (theta: number) => SkMatrix;
+    identity: () => SkMatrix;
+    get: () => number[];
+}
+export type InputMatrix = SkMatrix | Matrix3 | Matrix4 | number[];
+export interface TransformProp {
+    transform?: Transforms3d;
+}
+export declare const processTransform: <T extends SkMatrix | SkCanvas>(m: T, transforms: Transforms3d) => T;
+export declare const toDegrees: (rad: number) => number;