@shopify/react-native-skia 1.0.1 → 1.0.2

package/lib/typescript/src/dom/nodes/paint/ImageFilters.d.ts

@@ -0,0 +1,42 @@
+import type { SkImageFilter } from "../../../skia/types";
+import type { BlendImageFilterProps, BlurImageFilterProps, DeclarationContext, DisplacementMapImageFilterProps, DropShadowImageFilterProps, MorphologyImageFilterProps, OffsetImageFilterProps, RuntimeShaderImageFilterProps } from "../../types";
+import { NodeType } from "../../types";
+import type { NodeContext } from "../Node";
+import { JsiDeclarationNode } from "../Node";
+export declare abstract class ImageFilterDeclaration<P> extends JsiDeclarationNode<P> {
+    constructor(ctx: NodeContext, type: NodeType, props: P);
+    protected input(ctx: DeclarationContext): SkImageFilter | null;
+    protected composeAndPush(ctx: DeclarationContext, imgf1: SkImageFilter): void;
+}
+export declare class OffsetImageFilterNode extends ImageFilterDeclaration<OffsetImageFilterProps> {
+    constructor(ctx: NodeContext, props: OffsetImageFilterProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class DisplacementMapImageFilterNode extends ImageFilterDeclaration<DisplacementMapImageFilterProps> {
+    constructor(ctx: NodeContext, props: DisplacementMapImageFilterProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class BlurImageFilterNode extends ImageFilterDeclaration<BlurImageFilterProps> {
+    constructor(ctx: NodeContext, props: BlurImageFilterProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class DropShadowImageFilterNode extends ImageFilterDeclaration<DropShadowImageFilterProps> {
+    constructor(ctx: NodeContext, props: DropShadowImageFilterProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare enum MorphologyOperator {
+    Erode = 0,
+    Dilate = 1
+}
+export declare class MorphologyImageFilterNode extends ImageFilterDeclaration<MorphologyImageFilterProps> {
+    constructor(ctx: NodeContext, props: MorphologyImageFilterProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class BlendImageFilterNode extends ImageFilterDeclaration<BlendImageFilterProps> {
+    constructor(ctx: NodeContext, props: BlendImageFilterProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class RuntimeShaderImageFilterNode extends ImageFilterDeclaration<RuntimeShaderImageFilterProps> {
+    constructor(ctx: NodeContext, props: RuntimeShaderImageFilterProps);
+    decorate(ctx: DeclarationContext): void;
+}

package/lib/typescript/src/dom/nodes/paint/MaskFilters.d.ts

@@ -0,0 +1,8 @@
+import type { NodeContext } from "../Node";
+import { JsiDeclarationNode } from "../Node";
+import type { BlurMaskFilterProps } from "../../types";
+import type { DeclarationContext } from "../../types/DeclarationContext";
+export declare class BlurMaskFilterNode extends JsiDeclarationNode<BlurMaskFilterProps> {
+    constructor(ctx: NodeContext, props: BlurMaskFilterProps);
+    decorate(ctx: DeclarationContext): void;
+}

package/lib/typescript/src/dom/nodes/paint/PathEffects.d.ts

@@ -0,0 +1,39 @@
+import type { SkPathEffect } from "../../../skia/types";
+import type { NodeContext } from "../Node";
+import { JsiDeclarationNode } from "../Node";
+import type { CornerPathEffectProps, DashPathEffectProps, DiscretePathEffectProps, Line2DPathEffectProps, Path1DPathEffectProps, Path2DPathEffectProps } from "../../types";
+import { NodeType } from "../../types";
+import type { DeclarationContext } from "../../types/DeclarationContext";
+declare abstract class PathEffectDeclaration<P> extends JsiDeclarationNode<P> {
+    constructor(ctx: NodeContext, type: NodeType, props: P);
+    protected composeAndPush(ctx: DeclarationContext, pe1: SkPathEffect): void;
+}
+export declare class DiscretePathEffectNode extends PathEffectDeclaration<DiscretePathEffectProps> {
+    constructor(ctx: NodeContext, props: DiscretePathEffectProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class Path2DPathEffectNode extends PathEffectDeclaration<Path2DPathEffectProps> {
+    constructor(ctx: NodeContext, props: Path2DPathEffectProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class DashPathEffectNode extends PathEffectDeclaration<DashPathEffectProps> {
+    constructor(ctx: NodeContext, props: DashPathEffectProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class CornerPathEffectNode extends PathEffectDeclaration<CornerPathEffectProps> {
+    constructor(ctx: NodeContext, props: CornerPathEffectProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class SumPathEffectNode extends PathEffectDeclaration<null> {
+    constructor(ctx: NodeContext);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class Line2DPathEffectNode extends PathEffectDeclaration<Line2DPathEffectProps> {
+    constructor(ctx: NodeContext, props: Line2DPathEffectProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class Path1DPathEffectNode extends PathEffectDeclaration<Path1DPathEffectProps> {
+    constructor(ctx: NodeContext, props: Path1DPathEffectProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export {};

package/lib/typescript/src/dom/nodes/paint/Shaders.d.ts

@@ -0,0 +1,43 @@
+import type { NodeContext } from "../Node";
+import { JsiDeclarationNode } from "../Node";
+import type { ColorProps, DeclarationContext, FractalNoiseProps, ImageShaderProps, LinearGradientProps, RadialGradientProps, ShaderProps, SweepGradientProps, TurbulenceProps, TwoPointConicalGradientProps } from "../../types";
+import { NodeType } from "../../types";
+export declare abstract class ShaderDeclaration<P> extends JsiDeclarationNode<P> {
+    constructor(ctx: NodeContext, type: NodeType, props: P);
+}
+export declare class ShaderNode extends ShaderDeclaration<ShaderProps> {
+    constructor(ctx: NodeContext, props: ShaderProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class ImageShaderNode extends ShaderDeclaration<ImageShaderProps> {
+    constructor(ctx: NodeContext, props: ImageShaderProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class ColorNode extends ShaderDeclaration<ColorProps> {
+    constructor(ctx: NodeContext, props: ColorProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class TurbulenceNode extends ShaderDeclaration<TurbulenceProps> {
+    constructor(ctx: NodeContext, props: TurbulenceProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class FractalNoiseNode extends ShaderDeclaration<FractalNoiseProps> {
+    constructor(ctx: NodeContext, props: FractalNoiseProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class LinearGradientNode extends ShaderDeclaration<LinearGradientProps> {
+    constructor(ctx: NodeContext, props: LinearGradientProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class RadialGradientNode extends ShaderDeclaration<RadialGradientProps> {
+    constructor(ctx: NodeContext, props: RadialGradientProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class SweepGradientNode extends ShaderDeclaration<SweepGradientProps> {
+    constructor(ctx: NodeContext, props: SweepGradientProps);
+    decorate(ctx: DeclarationContext): void;
+}
+export declare class TwoPointConicalGradientNode extends ShaderDeclaration<TwoPointConicalGradientProps> {
+    constructor(ctx: NodeContext, props: TwoPointConicalGradientProps);
+    decorate(ctx: DeclarationContext): void;
+}

package/lib/typescript/src/dom/nodes/paint/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./Shaders";
+export * from "./MaskFilters";
+export * from "./ColorFilters";
+export * from "./ImageFilters";
+export * from "./PathEffects";
+export * from "./BlendNode";

package/lib/typescript/src/dom/types/ColorFilters.d.ts

@@ -0,0 +1,12 @@
+import type { BlendMode, Color } from "../../skia/types";
+import type { ChildrenProps, SkEnum } from "./Common";
+export interface MatrixColorFilterProps extends ChildrenProps {
+    matrix: number[];
+}
+export interface BlendColorFilterProps extends ChildrenProps {
+    mode: SkEnum<typeof BlendMode>;
+    color: Color;
+}
+export interface LerpColorFilterProps extends ChildrenProps {
+    t: number;
+}

package/lib/typescript/src/dom/types/Common.d.ts

@@ -0,0 +1,57 @@
+import type { ReactNode } from "react";
+import type { BlendMode, Color, InputMatrix, InputRRect, PaintStyle, SkPaint, SkPath, SkRect, SkRRect, StrokeCap, StrokeJoin, Transforms3d, Vector } from "../../skia/types";
+export type SkEnum<T> = Uncapitalize<keyof T extends string ? keyof T : never>;
+export type PathDef = string | SkPath;
+export type ClipDef = SkRRect | SkRect | PathDef;
+export type Fit = "cover" | "contain" | "fill" | "fitHeight" | "fitWidth" | "none" | "scaleDown";
+export type Radius = number | Vector;
+export interface ChildrenProps {
+    children?: ReactNode | ReactNode[];
+}
+export interface RectCtor {
+    x?: number;
+    y?: number;
+    width: number;
+    height: number;
+}
+export interface RRectCtor extends RectCtor {
+    r?: Radius;
+}
+export type RectDef = RectCtor | {
+    rect: SkRect;
+};
+export type RRectDef = RRectCtor | {
+    rect: InputRRect;
+};
+export interface PointCircleDef {
+    c?: Vector;
+    r: number;
+}
+export interface ScalarCircleDef {
+    cx: number;
+    cy: number;
+    r: number;
+}
+export type CircleDef = PointCircleDef | ScalarCircleDef;
+export interface TransformProps {
+    transform?: Transforms3d;
+    origin?: Vector;
+    matrix?: InputMatrix;
+}
+export interface PaintProps extends ChildrenProps {
+    color?: Color;
+    strokeWidth?: number;
+    blendMode?: SkEnum<typeof BlendMode>;
+    style?: SkEnum<typeof PaintStyle>;
+    strokeJoin?: SkEnum<typeof StrokeJoin>;
+    strokeCap?: SkEnum<typeof StrokeCap>;
+    strokeMiter?: number;
+    opacity?: number;
+    antiAlias?: boolean;
+    dither?: boolean;
+}
+export interface GroupProps extends PaintProps, TransformProps {
+    clip?: ClipDef;
+    invertClip?: boolean;
+    layer?: SkPaint | boolean;
+}

package/lib/typescript/src/dom/types/DeclarationContext.d.ts

@@ -0,0 +1,29 @@
+import type { SkShader, SkPaint, SkImageFilter, SkMaskFilter, SkPathEffect, Skia, SkColorFilter } from "../../skia/types";
+type Composer<T> = (outer: T, inner: T) => T;
+export declare const composeDeclarations: <T>(filters: T[], composer: Composer<T>) => T;
+declare class Declaration<T> {
+    private composer?;
+    private decls;
+    private indexes;
+    constructor(composer?: Composer<T> | undefined);
+    private get index();
+    save(): void;
+    restore(): void;
+    pop(): T | undefined;
+    push(decl: T): void;
+    popAll(): T[];
+    popAllAsOne(): T;
+}
+export declare class DeclarationContext {
+    private Skia;
+    readonly paints: Declaration<SkPaint>;
+    readonly maskFilters: Declaration<SkMaskFilter>;
+    readonly shaders: Declaration<SkShader>;
+    readonly pathEffects: Declaration<SkPathEffect>;
+    readonly imageFilters: Declaration<SkImageFilter>;
+    readonly colorFilters: Declaration<SkColorFilter>;
+    constructor(Skia: Skia);
+    save(): void;
+    restore(): void;
+}
+export {};

package/lib/typescript/src/dom/types/DrawingContext.d.ts

@@ -0,0 +1,22 @@
+import type { SkCanvas, SkPaint, Skia } from "../../skia/types";
+import type { PaintProps } from "./Common";
+import { DeclarationContext } from "./DeclarationContext";
+import type { Node } from "./Node";
+export interface DrawingContext {
+    canvas: SkCanvas;
+    paint: SkPaint;
+    saveAndConcat(node: Node<PaintProps>, cache?: SkPaint): boolean;
+    restore(): void;
+    declarationCtx: DeclarationContext;
+}
+export declare class JsiDrawingContext implements DrawingContext {
+    private readonly Skia;
+    readonly canvas: SkCanvas;
+    paints: SkPaint[];
+    declarationCtx: DeclarationContext;
+    constructor(Skia: Skia, canvas: SkCanvas);
+    get paint(): SkPaint;
+    private save;
+    restore(): void;
+    saveAndConcat(node: Node<PaintProps>, cache?: SkPaint): boolean;
+}

package/lib/typescript/src/dom/types/Drawings.d.ts

@@ -0,0 +1,111 @@
+import type { FillType, SkImage, StrokeOpts, Vector, Color, SkPoint, BlendMode, PointMode, VertexMode, SkFont, SkRRect, SkTextBlob, SkPicture, SkSVG, SkPaint, SkRect, SkRSXform, SkColor } from "../../skia/types";
+import type { CircleDef, Fit, GroupProps, PathDef, RectDef, RRectDef, SkEnum } from "./Common";
+export interface DrawingNodeProps extends GroupProps {
+    paint?: SkPaint;
+}
+export type ImageProps = DrawingNodeProps & RectDef & {
+    fit?: Fit;
+    image: SkImage | null;
+};
+export type CircleProps = CircleDef & DrawingNodeProps;
+export interface PathProps extends DrawingNodeProps {
+    path: PathDef;
+    start: number;
+    end: number;
+    stroke?: StrokeOpts;
+    fillType?: SkEnum<typeof FillType>;
+}
+export interface LineProps extends DrawingNodeProps {
+    p1: Vector;
+    p2: Vector;
+}
+export type OvalProps = RectDef & DrawingNodeProps;
+export type RectProps = RectDef & DrawingNodeProps;
+export type RoundedRectProps = RRectDef & DrawingNodeProps;
+export interface AtlasProps extends DrawingNodeProps {
+    image: SkImage | null;
+    sprites: SkRect[];
+    transforms: SkRSXform[];
+    colors?: SkColor[];
+}
+export interface CubicBezierHandle {
+    pos: Vector;
+    c1: Vector;
+    c2: Vector;
+}
+export interface PatchProps extends DrawingNodeProps {
+    colors?: Color[];
+    patch: [
+        CubicBezierHandle,
+        CubicBezierHandle,
+        CubicBezierHandle,
+        CubicBezierHandle
+    ];
+    texture?: readonly [SkPoint, SkPoint, SkPoint, SkPoint];
+    blendMode?: SkEnum<typeof BlendMode>;
+}
+export interface VerticesProps extends DrawingNodeProps {
+    colors?: string[];
+    vertices: SkPoint[];
+    textures?: SkPoint[];
+    mode: SkEnum<typeof VertexMode>;
+    blendMode?: SkEnum<typeof BlendMode>;
+    indices?: number[];
+}
+export interface ImageSVGProps extends DrawingNodeProps {
+    svg: SkSVG | null;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    rect?: SkRect;
+}
+export interface PictureProps extends DrawingNodeProps {
+    picture: SkPicture;
+}
+export interface PointsProps extends DrawingNodeProps {
+    points: SkPoint[];
+    mode: SkEnum<typeof PointMode>;
+}
+export interface DiffRectProps extends DrawingNodeProps {
+    inner: SkRRect;
+    outer: SkRRect;
+}
+export interface TextProps extends DrawingNodeProps {
+    font: SkFont | null;
+    text: string;
+    x: number;
+    y: number;
+}
+export interface TextPathProps extends DrawingNodeProps {
+    font: SkFont | null;
+    text: string;
+    path: PathDef;
+    initialOffset: number;
+}
+export interface TextBlobProps extends DrawingNodeProps {
+    blob: SkTextBlob;
+    x: number;
+    y: number;
+}
+export interface Glyph {
+    id: number;
+    pos: SkPoint;
+}
+export interface GlyphsProps extends DrawingNodeProps {
+    font: SkFont | null;
+    x: number;
+    y: number;
+    glyphs: Glyph[];
+}
+export interface BoxProps extends DrawingNodeProps {
+    box: SkRRect | SkRect;
+}
+export interface BoxShadowProps {
+    dx?: number;
+    dy?: number;
+    spread?: number;
+    blur: number;
+    color?: Color;
+    inner?: boolean;
+}

package/lib/typescript/src/dom/types/ImageFilters.d.ts

@@ -0,0 +1,37 @@
+import type { BlendMode, Color, ColorChannel, SkRuntimeEffect, TileMode, Uniforms } from "../../skia/types";
+import type { Radius, SkEnum, ChildrenProps } from "./Common";
+export interface BlurImageFilterProps extends ChildrenProps {
+    blur: Radius;
+    mode: SkEnum<typeof TileMode>;
+}
+export interface OffsetImageFilterProps extends ChildrenProps {
+    x: number;
+    y: number;
+}
+export interface RuntimeShaderImageFilterProps extends ChildrenProps {
+    source: SkRuntimeEffect;
+    uniforms?: Uniforms;
+}
+export interface BlendImageFilterProps extends ChildrenProps {
+    mode: BlendMode;
+}
+export interface MorphologyImageFilterProps extends ChildrenProps {
+    operator: "erode" | "dilate";
+    radius: Radius;
+}
+export interface DropShadowImageFilterProps extends ChildrenProps {
+    dx: number;
+    dy: number;
+    blur: number;
+    color: Color;
+    inner?: boolean;
+    shadowOnly?: boolean;
+}
+export interface DisplacementMapImageFilterProps extends ChildrenProps {
+    channelX: SkEnum<typeof ColorChannel>;
+    channelY: SkEnum<typeof ColorChannel>;
+    scale: number;
+}
+export interface BlendProps extends ChildrenProps {
+    mode: SkEnum<typeof BlendMode>;
+}

package/lib/typescript/src/dom/types/MaskFilters.d.ts

@@ -0,0 +1,7 @@
+import type { BlurStyle } from "../../skia/types";
+import type { SkEnum } from "./Common";
+export interface BlurMaskFilterProps {
+    style: SkEnum<typeof BlurStyle>;
+    blur: number;
+    respectCTM: boolean;
+}

package/lib/typescript/src/dom/types/Node.d.ts

@@ -0,0 +1,23 @@
+import type { GroupProps } from "./Common";
+import type { DeclarationType, NodeType } from "./NodeType";
+import type { DeclarationContext } from "./DeclarationContext";
+import type { DrawingContext } from "./DrawingContext";
+export interface Node<P> {
+    type: NodeType;
+    setProps(props: P): void;
+    setProp<K extends keyof P>(name: K, v: P[K]): boolean;
+    getProps(): P;
+    children(): Node<unknown>[];
+    addChild(child: Node<unknown>): void;
+    removeChild(child: Node<unknown>): void;
+    insertChildBefore(child: Node<unknown>, before: Node<unknown>): void;
+}
+export type Invalidate = () => void;
+export interface DeclarationNode<P> extends Node<P> {
+    declarationType: DeclarationType;
+    decorate(ctx: DeclarationContext): void;
+    setInvalidate(invalidate: Invalidate): void;
+}
+export interface RenderNode<P extends GroupProps> extends Node<P> {
+    render(ctx: DrawingContext): void;
+}

package/lib/typescript/src/dom/types/NodeType.d.ts

@@ -0,0 +1,68 @@
+export declare const enum NodeType {
+    Layer = "skLayer",
+    Shader = "skShader",
+    ImageShader = "skImageShader",
+    ColorShader = "skColorShader",
+    Turbulence = "skTurbulence",
+    FractalNoise = "skFractalNoise",
+    LinearGradient = "skLinearGradient",
+    RadialGradient = "skRadialGradient",
+    SweepGradient = "skSweepGradient",
+    TwoPointConicalGradient = "skTwoPointConicalGradient",
+    BlurMaskFilter = "skBlurMaskFilter",
+    DiscretePathEffect = "skDiscretePathEffect",
+    DashPathEffect = "skDashPathEffect",
+    Path1DPathEffect = "skPath1DPathEffect",
+    Path2DPathEffect = "skPath2DPathEffect",
+    CornerPathEffect = "skCornerPathEffect",
+    SumPathEffect = "skSumPathEffect",
+    Line2DPathEffect = "skLine2DPathEffect",
+    MatrixColorFilter = "skMatrixColorFilter",
+    BlendColorFilter = "skBlendColorFilter",
+    LinearToSRGBGammaColorFilter = "skLinearToSRGBGammaColorFilter",
+    SRGBToLinearGammaColorFilter = "skSRGBToLinearGammaColorFilter",
+    LumaColorFilter = "skLumaColorFilter",
+    LerpColorFilter = "skLerpColorFilter",
+    OffsetImageFilter = "skOffsetImageFilter",
+    DisplacementMapImageFilter = "skDisplacementMapImageFilter",
+    BlurImageFilter = "skBlurImageFilter",
+    DropShadowImageFilter = "skDropShadowImageFilter",
+    MorphologyImageFilter = "skMorphologyImageFilter",
+    BlendImageFilter = "skBlendImageFilter",
+    RuntimeShaderImageFilter = "skRuntimeShaderImageFilter",
+    Blend = "skBlend",
+    BackdropFilter = "skBackdropFilter",
+    Box = "skBox",
+    BoxShadow = "skBoxShadow",
+    Group = "skGroup",
+    Paint = "skPaint",
+    Circle = "skCircle",
+    Fill = "skFill",
+    Image = "skImage",
+    Points = "skPoints",
+    Path = "skPath",
+    Rect = "skRect",
+    RRect = "skRRect",
+    Oval = "skOval",
+    Line = "skLine",
+    Patch = "skPatch",
+    Vertices = "skVertices",
+    DiffRect = "skDiffRect",
+    Text = "skText",
+    TextPath = "skTextPath",
+    TextBlob = "skTextBlob",
+    Glyphs = "skGlyphs",
+    Picture = "skPicture",
+    ImageSVG = "skImageSVG",
+    Atlas = "skAtlas",
+    Paragraph = "skParagraph"
+}
+export declare const enum DeclarationType {
+    Paint = 0,
+    Shader = 1,
+    ImageFilter = 2,
+    ColorFilter = 3,
+    PathEffect = 4,
+    MaskFilter = 5,
+    Unknown = 6
+}

package/lib/typescript/src/dom/types/Paragraph.d.ts

@@ -0,0 +1,8 @@
+import type { SkParagraph } from "../../skia/types/Paragraph";
+import type { GroupProps } from "./Common";
+export interface ParagraphProps extends GroupProps {
+    paragraph: SkParagraph | null;
+    x: number;
+    y: number;
+    width: number;
+}

package/lib/typescript/src/dom/types/PathEffects.d.ts

@@ -0,0 +1,28 @@
+import type { Path1DEffectStyle, SkMatrix } from "../../skia/types";
+import type { ChildrenProps, PathDef, SkEnum } from "./Common";
+export interface CornerPathEffectProps extends ChildrenProps {
+    r: number;
+}
+export interface DiscretePathEffectProps extends ChildrenProps {
+    length: number;
+    deviation: number;
+    seed: number;
+}
+export interface DashPathEffectProps extends ChildrenProps {
+    intervals: number[];
+    phase?: number;
+}
+export interface Path1DPathEffectProps extends ChildrenProps {
+    path: PathDef;
+    advance: number;
+    phase: number;
+    style: SkEnum<typeof Path1DEffectStyle>;
+}
+export interface Path2DPathEffectProps extends ChildrenProps {
+    matrix: SkMatrix;
+    path: PathDef;
+}
+export interface Line2DPathEffectProps extends ChildrenProps {
+    width: number;
+    matrix: SkMatrix;
+}

package/lib/typescript/src/dom/types/Shaders.d.ts

@@ -0,0 +1,59 @@
+import type { Color, FilterMode, MipmapMode, SkImage, SkRect, SkRuntimeEffect, TileMode, Uniforms, Vector } from "../../skia/types";
+import type { SkEnum, TransformProps, ChildrenProps, RectCtor, Fit } from "./Common";
+export interface ShaderProps extends TransformProps, ChildrenProps {
+    source: SkRuntimeEffect;
+    uniforms: Uniforms;
+}
+export interface ImageShaderProps extends TransformProps, Partial<RectCtor> {
+    tx: SkEnum<typeof TileMode>;
+    ty: SkEnum<typeof TileMode>;
+    fm: SkEnum<typeof FilterMode>;
+    mm: SkEnum<typeof MipmapMode>;
+    fit: Fit;
+    rect?: SkRect;
+    image: SkImage | null;
+}
+export interface ColorProps {
+    color: Color;
+}
+export interface TurbulenceProps {
+    freqX: number;
+    freqY: number;
+    octaves: number;
+    seed: number;
+    tileWidth: number;
+    tileHeight: number;
+}
+export interface FractalNoiseProps {
+    freqX: number;
+    freqY: number;
+    octaves: number;
+    seed: number;
+    tileWidth: number;
+    tileHeight: number;
+}
+export interface GradientProps extends TransformProps {
+    colors: Color[];
+    positions?: number[];
+    mode?: SkEnum<typeof TileMode>;
+    flags?: number;
+}
+export interface LinearGradientProps extends GradientProps {
+    start: Vector;
+    end: Vector;
+}
+export interface RadialGradientProps extends GradientProps {
+    c: Vector;
+    r: number;
+}
+export interface SweepGradientProps extends GradientProps {
+    c: Vector;
+    start?: number;
+    end?: number;
+}
+export interface TwoPointConicalGradientProps extends GradientProps {
+    start: Vector;
+    startR: number;
+    end: Vector;
+    endR: number;
+}