@rendley/sdk 1.5.3 → 1.7.0

package/dist/modules/clip/clips/shape/ShapeClip.d.ts

@@ -18,33 +18,46 @@ export declare class ShapeClip extends Clip<ShapeSprite, ShapeStyle> {
         shape: string;
         type: string;
         id: string;
+        duration: number;
+        subtitlesOffset: number;
+        startTime: number;
+        leftTrim: number;
+        rightTrim: number;
         filters: {
+            id: string;
             options: {
                 lutUrl: string;
             };
+            sourceId: string;
+        }[];
+        effects: {
             id: string;
+            options: {
+                textureWidth: number;
+                textureHeight: number;
+                frameWidth: number;
+                frameHeight: number;
+                fragmentSrc?: string | undefined;
+                uniforms?: Record<string, unknown> | undefined;
+            };
             sourceId: string;
         }[];
-        effects: unknown[];
-        subtitlesOffset: number;
-        startTime: number;
-        duration: number;
-        leftTrim: number;
-        rightTrim: number;
-        warpMode: import('../../../../types').WarpModeEnum;
+        isVisible: boolean;
         text?: string | undefined;
+        style?: unknown;
+        customData?: [string, unknown][] | undefined;
         mediaDataId?: string | undefined;
         subtitlesId?: string | undefined;
-        style?: unknown;
+        wrapMode?: import('../../../../types').WrapModeEnum | undefined;
         animationController?: {
             animationDataIn?: {
                 name: string;
                 inOutOfRange: import("../../../..").OutOfRangeEnum;
                 outOutOfRange: import("../../../..").OutOfRangeEnum;
                 propertyAnimations: {
-                    property: string;
                     inOutOfRange: import("../../../..").OutOfRangeEnum;
                     outOutOfRange: import("../../../..").OutOfRangeEnum;
+                    property: string;
                     keyframes: {
                         time: number;
                         value: string | number;
@@ -62,9 +75,9 @@ export declare class ShapeClip extends Clip<ShapeSprite, ShapeStyle> {
                 inOutOfRange: import("../../../..").OutOfRangeEnum;
                 outOutOfRange: import("../../../..").OutOfRangeEnum;
                 propertyAnimations: {
-                    property: string;
                     inOutOfRange: import("../../../..").OutOfRangeEnum;
                     outOutOfRange: import("../../../..").OutOfRangeEnum;
+                    property: string;
                     keyframes: {
                         time: number;
                         value: string | number;
@@ -82,9 +95,9 @@ export declare class ShapeClip extends Clip<ShapeSprite, ShapeStyle> {
                 inOutOfRange: import("../../../..").OutOfRangeEnum;
                 outOutOfRange: import("../../../..").OutOfRangeEnum;
                 propertyAnimations: {
-                    property: string;
                     inOutOfRange: import("../../../..").OutOfRangeEnum;
                     outOutOfRange: import("../../../..").OutOfRangeEnum;
+                    property: string;
                     keyframes: {
                         time: number;
                         value: string | number;
@@ -102,7 +115,11 @@ export declare class ShapeClip extends Clip<ShapeSprite, ShapeStyle> {
             animationLoopCount?: number | undefined;
             loopSmoothing?: number | undefined;
         } | undefined;
-        customData?: [string, unknown][] | undefined;
+        clipMasks?: {
+            id: string;
+            clipId: string;
+            wrapMode: import("../../../filter/MaskFilter").MaskWrapModeEnum;
+        }[] | undefined;
     };
     static deserialize(payload: object): ShapeClip;
 }

package/dist/modules/clip/clips/shape/ShapeStyle.d.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { ShapeSprite } from "./ShapeSprite";
 import { ClipStyle, ClipStyleOptions } from "../../ClipStyle";
 interface ShapeClipStyleOptions extends ClipStyleOptions {
@@ -7,6 +8,58 @@ interface ShapeClipStyleOptions extends ClipStyleOptions {
     strokeAlpha?: number;
     hasFill?: boolean;
 }
+export declare const ShapeStyleSchema: z.ZodObject<{
+    height: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodOptional<z.ZodNumber>;
+    mediaDataId: z.ZodOptional<z.ZodString>;
+    clipId: z.ZodString;
+    alpha: z.ZodNumber;
+    rotation: z.ZodNumber;
+    position: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    scale: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    zIndex: z.ZodNumber;
+    cornerRadius: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    relativeCornerRadius: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    fillColor: z.ZodOptional<z.ZodString>;
+    strokeColor: z.ZodOptional<z.ZodString>;
+    strokeWidth: z.ZodOptional<z.ZodNumber>;
+    strokeAlpha: z.ZodOptional<z.ZodNumber>;
+    hasFill: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    clipId: string;
+    alpha: number;
+    rotation: number;
+    position: [number, number];
+    scale: [number, number];
+    zIndex: number;
+    relativeCornerRadius: boolean;
+    hasFill: boolean;
+    height?: number | undefined;
+    width?: number | undefined;
+    mediaDataId?: string | undefined;
+    cornerRadius?: [number, number, number, number] | undefined;
+    fillColor?: string | undefined;
+    strokeColor?: string | undefined;
+    strokeWidth?: number | undefined;
+    strokeAlpha?: number | undefined;
+}, {
+    clipId: string;
+    alpha: number;
+    rotation: number;
+    position: [number, number];
+    scale: [number, number];
+    zIndex: number;
+    height?: number | undefined;
+    width?: number | undefined;
+    mediaDataId?: string | undefined;
+    cornerRadius?: [number, number, number, number] | undefined;
+    relativeCornerRadius?: boolean | undefined;
+    fillColor?: string | undefined;
+    strokeColor?: string | undefined;
+    strokeWidth?: number | undefined;
+    strokeAlpha?: number | undefined;
+    hasFill?: boolean | undefined;
+}>;
 export declare class ShapeStyle extends ClipStyle<ShapeSprite> {
     protected fillColor: string;
     protected strokeColor: string;
@@ -34,9 +87,9 @@ export declare class ShapeStyle extends ClipStyle<ShapeSprite> {
         zIndex: number;
         relativeCornerRadius: boolean;
         hasFill: boolean;
-        mediaDataId?: string | undefined;
-        width?: number | undefined;
         height?: number | undefined;
+        width?: number | undefined;
+        mediaDataId?: string | undefined;
         cornerRadius?: [number, number, number, number] | undefined;
         fillColor?: string | undefined;
         strokeColor?: string | undefined;

package/dist/modules/clip/clips/text/TextClip.d.ts

@@ -23,32 +23,45 @@ export declare class TextClip extends Clip<TextSprite, TextStyle> {
         text: string;
         type: string;
         id: string;
+        duration: number;
+        subtitlesOffset: number;
+        startTime: number;
+        leftTrim: number;
+        rightTrim: number;
         filters: {
+            id: string;
             options: {
                 lutUrl: string;
             };
+            sourceId: string;
+        }[];
+        effects: {
             id: string;
+            options: {
+                textureWidth: number;
+                textureHeight: number;
+                frameWidth: number;
+                frameHeight: number;
+                fragmentSrc?: string | undefined;
+                uniforms?: Record<string, unknown> | undefined;
+            };
             sourceId: string;
         }[];
-        effects: unknown[];
-        subtitlesOffset: number;
-        startTime: number;
-        duration: number;
-        leftTrim: number;
-        rightTrim: number;
-        warpMode: import('../../../../index').WarpModeEnum;
+        isVisible: boolean;
+        style?: unknown;
+        customData?: [string, unknown][] | undefined;
         mediaDataId?: string | undefined;
         subtitlesId?: string | undefined;
-        style?: unknown;
+        wrapMode?: import('../../../../index').WrapModeEnum | undefined;
         animationController?: {
             animationDataIn?: {
                 name: string;
                 inOutOfRange: import('../../../../index').OutOfRangeEnum;
                 outOutOfRange: import('../../../../index').OutOfRangeEnum;
                 propertyAnimations: {
-                    property: string;
                     inOutOfRange: import('../../../../index').OutOfRangeEnum;
                     outOutOfRange: import('../../../../index').OutOfRangeEnum;
+                    property: string;
                     keyframes: {
                         time: number;
                         value: string | number;
@@ -66,9 +79,9 @@ export declare class TextClip extends Clip<TextSprite, TextStyle> {
                 inOutOfRange: import('../../../../index').OutOfRangeEnum;
                 outOutOfRange: import('../../../../index').OutOfRangeEnum;
                 propertyAnimations: {
-                    property: string;
                     inOutOfRange: import('../../../../index').OutOfRangeEnum;
                     outOutOfRange: import('../../../../index').OutOfRangeEnum;
+                    property: string;
                     keyframes: {
                         time: number;
                         value: string | number;
@@ -86,9 +99,9 @@ export declare class TextClip extends Clip<TextSprite, TextStyle> {
                 inOutOfRange: import('../../../../index').OutOfRangeEnum;
                 outOutOfRange: import('../../../../index').OutOfRangeEnum;
                 propertyAnimations: {
-                    property: string;
                     inOutOfRange: import('../../../../index').OutOfRangeEnum;
                     outOutOfRange: import('../../../../index').OutOfRangeEnum;
+                    property: string;
                     keyframes: {
                         time: number;
                         value: string | number;
@@ -106,7 +119,11 @@ export declare class TextClip extends Clip<TextSprite, TextStyle> {
             animationLoopCount?: number | undefined;
             loopSmoothing?: number | undefined;
         } | undefined;
-        customData?: [string, unknown][] | undefined;
+        clipMasks?: {
+            id: string;
+            clipId: string;
+            wrapMode: import("../../../filter/MaskFilter").MaskWrapModeEnum;
+        }[] | undefined;
     };
     static deserialize(payload: object): TextClip;
 }

package/dist/modules/clip/clips/text/TextStyle.d.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { TextSprite } from "./TextSprite";
 import { ClipStyle, ClipStyleOptions } from "../../ClipStyle";
 import { TextStyleAlign, TextStyleFontStyle, TextStyleFontWeight } from '../../../../types/text.types';
@@ -10,7 +11,80 @@ interface TextClipStyleOptions extends ClipStyleOptions {
     fontStyle?: TextStyleFontStyle;
     backgroundColor?: string | null;
     wordWrapWidth?: number | null;
+    strokeColor?: string;
+    strokeThickness?: number;
+    padding?: number[];
 }
+export declare const TextStyleSchema: z.ZodObject<{
+    height: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodOptional<z.ZodNumber>;
+    mediaDataId: z.ZodOptional<z.ZodString>;
+    clipId: z.ZodString;
+    alpha: z.ZodNumber;
+    rotation: z.ZodNumber;
+    position: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    scale: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    zIndex: z.ZodNumber;
+    cornerRadius: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    relativeCornerRadius: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    fontSize: z.ZodNumber;
+    color: z.ZodString;
+    fontWeight: z.ZodEnum<["normal", "bold", "bolder", "lighter", "100", "200", "300", "400", "500", "600", "700", "800", "900"]>;
+    fontFamily: z.ZodString;
+    textAlign: z.ZodEnum<["left", "center", "right", "justify"]>;
+    fontStyle: z.ZodEnum<["normal", "italic", "oblique"]>;
+    backgroundColor: z.ZodNullable<z.ZodString>;
+    strokeColor: z.ZodDefault<z.ZodString>;
+    strokeThickness: z.ZodDefault<z.ZodNumber>;
+    wordWrapWidth: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    padding: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
+}, "strip", z.ZodTypeAny, {
+    color: string;
+    clipId: string;
+    alpha: number;
+    rotation: number;
+    position: [number, number];
+    scale: [number, number];
+    zIndex: number;
+    relativeCornerRadius: boolean;
+    fontSize: number;
+    fontWeight: "bold" | "normal" | "bolder" | "lighter" | "100" | "200" | "300" | "400" | "500" | "600" | "700" | "800" | "900";
+    fontFamily: string;
+    fontStyle: "normal" | "italic" | "oblique";
+    backgroundColor: string | null;
+    strokeThickness: number;
+    strokeColor: string;
+    padding: number[];
+    wordWrapWidth: number | null;
+    textAlign: "left" | "center" | "right" | "justify";
+    height?: number | undefined;
+    width?: number | undefined;
+    mediaDataId?: string | undefined;
+    cornerRadius?: [number, number, number, number] | undefined;
+}, {
+    color: string;
+    clipId: string;
+    alpha: number;
+    rotation: number;
+    position: [number, number];
+    scale: [number, number];
+    zIndex: number;
+    fontSize: number;
+    fontWeight: "bold" | "normal" | "bolder" | "lighter" | "100" | "200" | "300" | "400" | "500" | "600" | "700" | "800" | "900";
+    fontFamily: string;
+    fontStyle: "normal" | "italic" | "oblique";
+    backgroundColor: string | null;
+    textAlign: "left" | "center" | "right" | "justify";
+    height?: number | undefined;
+    width?: number | undefined;
+    mediaDataId?: string | undefined;
+    cornerRadius?: [number, number, number, number] | undefined;
+    relativeCornerRadius?: boolean | undefined;
+    strokeColor?: string | undefined;
+    strokeThickness?: number | undefined;
+    wordWrapWidth?: number | null | undefined;
+    padding?: number[] | undefined;
+}>;
 export declare class TextStyle extends ClipStyle<TextSprite> {
     fontSize: number;
     color: string;
@@ -20,17 +94,27 @@ export declare class TextStyle extends ClipStyle<TextSprite> {
     fontStyle: TextStyleFontStyle;
     backgroundColor: string | null;
     wordWrapWidth: number | null;
+    strokeColor: string;
+    strokeThickness: number;
+    padding: number[];
     private isDirty;
+    protected animationColor: string | null;
     constructor(options: TextClipStyleOptions);
     setDirty(): void;
+    setStrokeColor(strokeColor: string): void;
+    getStrokeColor(): string;
+    setStrokeThickness(strokeThickness: number): void;
+    getStrokeThickness(): number;
     setFontSize(fontSize: number): void;
     getFontSize(): number;
     getWordWrapWidth(): number | null;
     setWordWrapWidth(wordWrapWidth: number | null): void;
     setColor(color: string): void;
     getColor(): string;
+    setAnimationColor(color: string | null): void;
+    getAnimationColor(): string | null;
     setFontWeight(fontWeight: TextStyleFontWeight): void;
-    getFontWeight(): "normal" | "bold" | "bolder" | "lighter" | "100" | "200" | "300" | "400" | "500" | "600" | "700" | "800" | "900";
+    getFontWeight(): "bold" | "normal" | "bolder" | "lighter" | "100" | "200" | "300" | "400" | "500" | "600" | "700" | "800" | "900";
     setFontFamily(fontFamily: string): void;
     getFontFamily(): string;
     setTextAlign(textAlign: TextStyleAlign): void;
@@ -39,7 +123,8 @@ export declare class TextStyle extends ClipStyle<TextSprite> {
     getFontStyle(): "normal" | "italic" | "oblique";
     setBackgroundColor(backgroundColor: string | null): void;
     getBackgroundColor(): string | null;
-    setRotation(rotation: number): void;
+    setPadding(padding: number | number[]): void;
+    getPadding(): number[];
     update(container: TextSprite): void;
     serialize(): {
         color: string;
@@ -51,14 +136,18 @@ export declare class TextStyle extends ClipStyle<TextSprite> {
         zIndex: number;
         relativeCornerRadius: boolean;
         fontSize: number;
-        fontWeight: "normal" | "bold" | "bolder" | "lighter" | "100" | "200" | "300" | "400" | "500" | "600" | "700" | "800" | "900";
+        fontWeight: "bold" | "normal" | "bolder" | "lighter" | "100" | "200" | "300" | "400" | "500" | "600" | "700" | "800" | "900";
         fontFamily: string;
-        textAlign: "left" | "center" | "right" | "justify";
         fontStyle: "normal" | "italic" | "oblique";
         backgroundColor: string | null;
-        mediaDataId?: string | undefined;
-        width?: number | undefined;
+        strokeThickness: number;
+        strokeColor: string;
+        padding: number[];
+        wordWrapWidth: number | null;
+        textAlign: "left" | "center" | "right" | "justify";
         height?: number | undefined;
+        width?: number | undefined;
+        mediaDataId?: string | undefined;
         cornerRadius?: [number, number, number, number] | undefined;
     };
     static deserialize(payload: object): TextStyle;

package/dist/modules/clip/clips/video/VideoClip.d.ts

@@ -22,29 +22,34 @@ export declare class VideoClip extends Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>>
     private decoder;
     private frameQueue;
     private isRendering;
+    private decoderFlushed;
     constructor(options: VideoClipOptions);
     init(layerId: string): Promise<void>;
     private getGlobalTimeToClipTime;
     getIsProcessing(): boolean;
     updateMediaData(newMediaId?: string): Promise<boolean>;
     preload(currentTime: number): void;
-    addActionToQueue(action: string, params?: object): void;
-    processNextQueue(): void;
+    private addActionToQueue;
+    private processNextQueue;
     private seekedCallback;
     private playingCallback;
     private pausedCallback;
     private endedCallback;
     private errorCallback;
     private videoLoadedCallback;
+    private isVideoReady;
+    private isAudioReady;
     setVolume(volume: number): void;
     getVolume(): number;
     private play;
     private pause;
     private renderSeek;
     private seek;
-    renderVideoFrameOutputCallback(frame: VideoFrame): void;
-    getNextRenderPacket(): Promise<void>;
-    searchRenderFrame(videoTime: number): Promise<VideoFrame | null>;
+    private renderVideoFrameOutputCallback;
+    private getNextRenderPacket;
+    private searchRenderFrame;
+    private initializeDecoder;
+    private destroyDecoder;
     onRenderStart(options: ExportOptions): Promise<void>;
     onRenderDone(canceled: boolean): Promise<void>;
     onPlay(currentTime: number): Promise<void>;
@@ -57,35 +62,48 @@ export declare class VideoClip extends Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>>
     destroy(): void;
     clone(): VideoClip;
     serialize(): {
-        mediaDataId: string;
         type: string;
         id: string;
+        duration: number;
+        mediaDataId: string;
+        subtitlesOffset: number;
+        startTime: number;
+        leftTrim: number;
+        rightTrim: number;
         filters: {
+            id: string;
             options: {
                 lutUrl: string;
             };
+            sourceId: string;
+        }[];
+        effects: {
             id: string;
+            options: {
+                textureWidth: number;
+                textureHeight: number;
+                frameWidth: number;
+                frameHeight: number;
+                fragmentSrc?: string | undefined;
+                uniforms?: Record<string, unknown> | undefined;
+            };
             sourceId: string;
         }[];
-        effects: unknown[];
-        subtitlesOffset: number;
-        startTime: number;
-        duration: number;
-        leftTrim: number;
-        rightTrim: number;
-        warpMode: import('../../../../types').WarpModeEnum;
+        isVisible: boolean;
         text?: string | undefined;
-        subtitlesId?: string | undefined;
         style?: unknown;
+        customData?: [string, unknown][] | undefined;
+        subtitlesId?: string | undefined;
+        wrapMode?: import('../../../../types').WrapModeEnum | undefined;
         animationController?: {
             animationDataIn?: {
                 name: string;
                 inOutOfRange: import("../../../..").OutOfRangeEnum;
                 outOutOfRange: import("../../../..").OutOfRangeEnum;
                 propertyAnimations: {
-                    property: string;
                     inOutOfRange: import("../../../..").OutOfRangeEnum;
                     outOutOfRange: import("../../../..").OutOfRangeEnum;
+                    property: string;
                     keyframes: {
                         time: number;
                         value: string | number;
@@ -103,9 +121,9 @@ export declare class VideoClip extends Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>>
                 inOutOfRange: import("../../../..").OutOfRangeEnum;
                 outOutOfRange: import("../../../..").OutOfRangeEnum;
                 propertyAnimations: {
-                    property: string;
                     inOutOfRange: import("../../../..").OutOfRangeEnum;
                     outOutOfRange: import("../../../..").OutOfRangeEnum;
+                    property: string;
                     keyframes: {
                         time: number;
                         value: string | number;
@@ -123,9 +141,9 @@ export declare class VideoClip extends Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>>
                 inOutOfRange: import("../../../..").OutOfRangeEnum;
                 outOutOfRange: import("../../../..").OutOfRangeEnum;
                 propertyAnimations: {
-                    property: string;
                     inOutOfRange: import("../../../..").OutOfRangeEnum;
                     outOutOfRange: import("../../../..").OutOfRangeEnum;
+                    property: string;
                     keyframes: {
                         time: number;
                         value: string | number;
@@ -143,7 +161,11 @@ export declare class VideoClip extends Clip<PIXI.Sprite, ClipStyle<PIXI.Sprite>>
             animationLoopCount?: number | undefined;
             loopSmoothing?: number | undefined;
         } | undefined;
-        customData?: [string, unknown][] | undefined;
+        clipMasks?: {
+            id: string;
+            clipId: string;
+            wrapMode: import("../../../filter/MaskFilter").MaskWrapModeEnum;
+        }[] | undefined;
         volume?: number | undefined;
         muted?: boolean | undefined;
     };

package/dist/modules/display/Display.d.ts

@@ -5,12 +5,12 @@ export declare const DisplaySchema: z.ZodObject<{
     height: z.ZodNumber;
     backgroundColor: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    width: number;
     height: number;
+    width: number;
     backgroundColor: string;
 }, {
-    width: number;
     height: number;
+    width: number;
     backgroundColor: string;
 }>;
 export type DisplayOptions = Partial<Omit<PixiRendererInitOptions, "view">> & {
@@ -34,8 +34,8 @@ export declare class Display {
     private hitTest;
     destroy(): void;
     serialize(): {
-        width: number;
         height: number;
+        width: number;
         backgroundColor: string;
     };
     static deserialize(data: object): Display;

package/dist/modules/event-emitter/types/EventEmitter.types.d.ts

@@ -1,3 +1,4 @@
+import { UndoGroup, UndoRecord } from '../../undo';
 export declare enum EventsEnum {
     READY = "ready",
     PLAYING = "playing",
@@ -37,7 +38,11 @@ export declare enum EventsEnum {
     FONT_REMOVED = "font:removed",
     FONT_ERROR = "font:error",
     DISPLAY_RESOLUTION_UPDATED = "display:resolution:updated",
-    DISPLAY_BACKGROUND_UPDATED = "display:background:updated"
+    DISPLAY_BACKGROUND_UPDATED = "display:background:updated",
+    UNDO_REDO_CHANGED = "undo:redo:changed",
+    UNDO_PERFORMED = "undo:performed",
+    REDO_PERFORMED = "redo:performed",
+    UNDO_PROCESS_CUSTOM = "undo:process:custom"
 }
 export type EventPayloadMap = {
     [EventsEnum.READY]: undefined;
@@ -181,6 +186,20 @@ export type EventPayloadMap = {
         width: number;
         height: number;
     };
+    [EventsEnum.UNDO_REDO_CHANGED]: {
+        canUndo: boolean;
+        canRedo: boolean;
+    };
+    [EventsEnum.UNDO_PERFORMED]: {
+        name: string;
+    };
+    [EventsEnum.REDO_PERFORMED]: {
+        name: string;
+    };
+    [EventsEnum.UNDO_PROCESS_CUSTOM]: {
+        undoRecord: UndoRecord;
+        redoGroup: UndoGroup;
+    };
 };
 type EventEmitterValidEventType<T> = T extends undefined ? () => void : (payload: T) => void;
 export type EventEmitterValidEventTypes = {

package/dist/modules/filter/Effect.d.ts

@@ -1,4 +1,53 @@
 import * as PIXI from "pixi.js";
+import { z } from "zod";
+export declare const EffectSchema: z.ZodObject<{
+    id: z.ZodString;
+    sourceId: z.ZodString;
+    options: z.ZodObject<{
+        fragmentSrc: z.ZodOptional<z.ZodString>;
+        uniforms: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        textureWidth: z.ZodNumber;
+        textureHeight: z.ZodNumber;
+        frameWidth: z.ZodNumber;
+        frameHeight: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        textureWidth: number;
+        textureHeight: number;
+        frameWidth: number;
+        frameHeight: number;
+        fragmentSrc?: string | undefined;
+        uniforms?: Record<string, unknown> | undefined;
+    }, {
+        textureWidth: number;
+        textureHeight: number;
+        frameWidth: number;
+        frameHeight: number;
+        fragmentSrc?: string | undefined;
+        uniforms?: Record<string, unknown> | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    options: {
+        textureWidth: number;
+        textureHeight: number;
+        frameWidth: number;
+        frameHeight: number;
+        fragmentSrc?: string | undefined;
+        uniforms?: Record<string, unknown> | undefined;
+    };
+    sourceId: string;
+}, {
+    id: string;
+    options: {
+        textureWidth: number;
+        textureHeight: number;
+        frameWidth: number;
+        frameHeight: number;
+        fragmentSrc?: string | undefined;
+        uniforms?: Record<string, unknown> | undefined;
+    };
+    sourceId: string;
+}>;
 export interface EffectOptions {
     sourceId: string;
     fragmentSrc?: string;
@@ -20,6 +69,7 @@ export declare class Effect {
     updateUniformsFromSprite(sprite: PIXI.Sprite): void;
     update(currentTime: number): void;
     serialize(): {
+        id: string;
         options: {
             textureWidth: number;
             textureHeight: number;
@@ -28,7 +78,6 @@ export declare class Effect {
             fragmentSrc?: string | undefined;
             uniforms?: Record<string, unknown> | undefined;
         };
-        id: string;
         sourceId: string;
     };
     static deserialize(data: object): Effect;