visualfries 0.1.0

package/dist/builders/_ComponentState.svelte.d.ts

@@ -0,0 +1,795 @@
+import type { ComponentData, ComponentProps } from '..';
+import type { Appearance, AppearanceInput } from '..';
+import { EventManager } from '../managers/EventManager.js';
+import { StateManager } from '../managers/StateManager.svelte.js';
+export declare class ComponentState implements ComponentProps {
+    #private;
+    private eventManager;
+    private sceneState;
+    private refreshCallback?;
+    constructor(cradle: {
+        componentData: ComponentData;
+        eventManager: EventManager;
+        stateManager: StateManager;
+    });
+    setRefreshCallback(callback: () => Promise<void>): void;
+    private maybeAutoRefresh;
+    get id(): string;
+    get type(): "IMAGE" | "GIF" | "VIDEO" | "TEXT" | "SHAPE" | "AUDIO" | "COLOR" | "GRADIENT" | "SUBTITLES";
+    get name(): string;
+    get start_at(): number;
+    get end_at(): number;
+    set start_at(time: number);
+    set end_at(time: number);
+    set name(name: string);
+    get order(): number;
+    get visible(): true;
+    get duration(): number;
+    get asset_id(): string;
+    get timeline(): {
+        startAt: number;
+        endAt: number;
+    };
+    get appearance(): Appearance;
+    get animations(): {
+        enabled: boolean;
+        list: {
+            id: string;
+            name: string;
+            animation: string | {
+                id: string;
+                timeline: {
+                    tweens: {
+                        method: "set" | "to" | "from" | "fromTo";
+                        vars: {
+                            duration?: string | number | boolean | {
+                                fromData: string;
+                                mode: "cycle" | "useFallback" | "clamp";
+                                fallbackValue?: any;
+                            } | {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            } | null | undefined;
+                            from?: import("zod").objectOutputType<{
+                                opacity: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                    fromData: import("zod").ZodString;
+                                    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    fromData: string;
+                                    mode: "cycle" | "useFallback" | "clamp";
+                                    fallbackValue?: any;
+                                }, {
+                                    fromData: string;
+                                    mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                    fallbackValue?: any;
+                                }>, import("zod").ZodObject<{
+                                    type: import("zod").ZodLiteral<"byIndex">;
+                                    expression: import("zod").ZodString;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }>]>>;
+                                x: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                    fromData: import("zod").ZodString;
+                                    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    fromData: string;
+                                    mode: "cycle" | "useFallback" | "clamp";
+                                    fallbackValue?: any;
+                                }, {
+                                    fromData: string;
+                                    mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                    fallbackValue?: any;
+                                }>, import("zod").ZodObject<{
+                                    type: import("zod").ZodLiteral<"byIndex">;
+                                    expression: import("zod").ZodString;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }>]>>;
+                                y: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                    fromData: import("zod").ZodString;
+                                    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    fromData: string;
+                                    mode: "cycle" | "useFallback" | "clamp";
+                                    fallbackValue?: any;
+                                }, {
+                                    fromData: string;
+                                    mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                    fallbackValue?: any;
+                                }>, import("zod").ZodObject<{
+                                    type: import("zod").ZodLiteral<"byIndex">;
+                                    expression: import("zod").ZodString;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }>]>>;
+                                scale: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                    fromData: import("zod").ZodString;
+                                    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    fromData: string;
+                                    mode: "cycle" | "useFallback" | "clamp";
+                                    fallbackValue?: any;
+                                }, {
+                                    fromData: string;
+                                    mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                    fallbackValue?: any;
+                                }>, import("zod").ZodObject<{
+                                    type: import("zod").ZodLiteral<"byIndex">;
+                                    expression: import("zod").ZodString;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }>]>>;
+                                scaleX: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                    fromData: import("zod").ZodString;
+                                    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    fromData: string;
+                                    mode: "cycle" | "useFallback" | "clamp";
+                                    fallbackValue?: any;
+                                }, {
+                                    fromData: string;
+                                    mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                    fallbackValue?: any;
+                                }>, import("zod").ZodObject<{
+                                    type: import("zod").ZodLiteral<"byIndex">;
+                                    expression: import("zod").ZodString;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }>]>>;
+                                scaleY: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                    fromData: import("zod").ZodString;
+                                    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    fromData: string;
+                                    mode: "cycle" | "useFallback" | "clamp";
+                                    fallbackValue?: any;
+                                }, {
+                                    fromData: string;
+                                    mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                    fallbackValue?: any;
+                                }>, import("zod").ZodObject<{
+                                    type: import("zod").ZodLiteral<"byIndex">;
+                                    expression: import("zod").ZodString;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }>]>>;
+                                rotation: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                    fromData: import("zod").ZodString;
+                                    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    fromData: string;
+                                    mode: "cycle" | "useFallback" | "clamp";
+                                    fallbackValue?: any;
+                                }, {
+                                    fromData: string;
+                                    mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                    fallbackValue?: any;
+                                }>, import("zod").ZodObject<{
+                                    type: import("zod").ZodLiteral<"byIndex">;
+                                    expression: import("zod").ZodString;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }>]>>;
+                                width: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                    fromData: import("zod").ZodString;
+                                    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    fromData: string;
+                                    mode: "cycle" | "useFallback" | "clamp";
+                                    fallbackValue?: any;
+                                }, {
+                                    fromData: string;
+                                    mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                    fallbackValue?: any;
+                                }>, import("zod").ZodObject<{
+                                    type: import("zod").ZodLiteral<"byIndex">;
+                                    expression: import("zod").ZodString;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }>]>>;
+                                height: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                    fromData: import("zod").ZodString;
+                                    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    fromData: string;
+                                    mode: "cycle" | "useFallback" | "clamp";
+                                    fallbackValue?: any;
+                                }, {
+                                    fromData: string;
+                                    mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                    fallbackValue?: any;
+                                }>, import("zod").ZodObject<{
+                                    type: import("zod").ZodLiteral<"byIndex">;
+                                    expression: import("zod").ZodString;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }>]>>;
+                                color: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                    fromData: import("zod").ZodString;
+                                    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    fromData: string;
+                                    mode: "cycle" | "useFallback" | "clamp";
+                                    fallbackValue?: any;
+                                }, {
+                                    fromData: string;
+                                    mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                    fallbackValue?: any;
+                                }>, import("zod").ZodObject<{
+                                    type: import("zod").ZodLiteral<"byIndex">;
+                                    expression: import("zod").ZodString;
+                                    fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                                }, "strip", import("zod").ZodTypeAny, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }, {
+                                    type: "byIndex";
+                                    expression: string;
+                                    fallbackValue?: any;
+                                }>]>>;
+                            }, import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                fromData: import("zod").ZodString;
+                                mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                fromData: string;
+                                mode: "cycle" | "useFallback" | "clamp";
+                                fallbackValue?: any;
+                            }, {
+                                fromData: string;
+                                mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                fallbackValue?: any;
+                            }>, import("zod").ZodObject<{
+                                type: import("zod").ZodLiteral<"byIndex">;
+                                expression: import("zod").ZodString;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }>]>, "strip"> | undefined;
+                            ease?: string | undefined;
+                            delay?: string | number | boolean | {
+                                fromData: string;
+                                mode: "cycle" | "useFallback" | "clamp";
+                                fallbackValue?: any;
+                            } | {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            } | null | undefined;
+                            stagger?: number | {
+                                type?: "fromData" | undefined;
+                                from?: string | number | undefined;
+                                ease?: string | undefined;
+                                dataKey?: string | undefined;
+                                referencePoint?: "tweenStart" | undefined;
+                                each?: number | undefined;
+                                grid?: [number | "auto", number | "auto"] | undefined;
+                                axis?: "x" | "y" | undefined;
+                                amount?: number | undefined;
+                            } | undefined;
+                        } & {
+                            [k: string]: any;
+                        };
+                        position?: string | number | {
+                            anchor: string;
+                            alignTween: "center" | "start" | "end";
+                            offset: string;
+                            anchorPoint?: "start" | "end" | undefined;
+                        } | undefined;
+                    }[];
+                    id?: string | undefined;
+                    position?: string | number | {
+                        anchor: string;
+                        alignTween: "center" | "start" | "end";
+                        offset: string;
+                        anchorPoint?: "start" | "end" | undefined;
+                    } | undefined;
+                    target?: string | undefined;
+                }[];
+                presetId?: string | undefined;
+                version?: string | undefined;
+                description?: string | undefined;
+                duration?: number | undefined;
+                data?: Record<string, any> | undefined;
+                setup?: ({
+                    type: "style";
+                    properties: {} & {
+                        [k: string]: string | number | boolean | {
+                            fromData: string;
+                            mode: "cycle" | "useFallback" | "clamp";
+                            fallbackValue?: any;
+                        } | {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        } | null;
+                    };
+                } | {
+                    type: "splitText";
+                    by: "words" | "lines" | "chars";
+                })[] | undefined;
+                revertAfterComplete?: boolean | undefined;
+            } | {
+                tween: {
+                    method: "set" | "to" | "from" | "fromTo";
+                    vars: {
+                        duration?: string | number | boolean | {
+                            fromData: string;
+                            mode: "cycle" | "useFallback" | "clamp";
+                            fallbackValue?: any;
+                        } | {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        } | null | undefined;
+                        from?: import("zod").objectOutputType<{
+                            opacity: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                fromData: import("zod").ZodString;
+                                mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                fromData: string;
+                                mode: "cycle" | "useFallback" | "clamp";
+                                fallbackValue?: any;
+                            }, {
+                                fromData: string;
+                                mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                fallbackValue?: any;
+                            }>, import("zod").ZodObject<{
+                                type: import("zod").ZodLiteral<"byIndex">;
+                                expression: import("zod").ZodString;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }>]>>;
+                            x: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                fromData: import("zod").ZodString;
+                                mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                fromData: string;
+                                mode: "cycle" | "useFallback" | "clamp";
+                                fallbackValue?: any;
+                            }, {
+                                fromData: string;
+                                mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                fallbackValue?: any;
+                            }>, import("zod").ZodObject<{
+                                type: import("zod").ZodLiteral<"byIndex">;
+                                expression: import("zod").ZodString;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }>]>>;
+                            y: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                fromData: import("zod").ZodString;
+                                mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                fromData: string;
+                                mode: "cycle" | "useFallback" | "clamp";
+                                fallbackValue?: any;
+                            }, {
+                                fromData: string;
+                                mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                fallbackValue?: any;
+                            }>, import("zod").ZodObject<{
+                                type: import("zod").ZodLiteral<"byIndex">;
+                                expression: import("zod").ZodString;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }>]>>;
+                            scale: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                fromData: import("zod").ZodString;
+                                mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                fromData: string;
+                                mode: "cycle" | "useFallback" | "clamp";
+                                fallbackValue?: any;
+                            }, {
+                                fromData: string;
+                                mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                fallbackValue?: any;
+                            }>, import("zod").ZodObject<{
+                                type: import("zod").ZodLiteral<"byIndex">;
+                                expression: import("zod").ZodString;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }>]>>;
+                            scaleX: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                fromData: import("zod").ZodString;
+                                mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                fromData: string;
+                                mode: "cycle" | "useFallback" | "clamp";
+                                fallbackValue?: any;
+                            }, {
+                                fromData: string;
+                                mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                fallbackValue?: any;
+                            }>, import("zod").ZodObject<{
+                                type: import("zod").ZodLiteral<"byIndex">;
+                                expression: import("zod").ZodString;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }>]>>;
+                            scaleY: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                fromData: import("zod").ZodString;
+                                mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                fromData: string;
+                                mode: "cycle" | "useFallback" | "clamp";
+                                fallbackValue?: any;
+                            }, {
+                                fromData: string;
+                                mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                fallbackValue?: any;
+                            }>, import("zod").ZodObject<{
+                                type: import("zod").ZodLiteral<"byIndex">;
+                                expression: import("zod").ZodString;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }>]>>;
+                            rotation: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                fromData: import("zod").ZodString;
+                                mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                fromData: string;
+                                mode: "cycle" | "useFallback" | "clamp";
+                                fallbackValue?: any;
+                            }, {
+                                fromData: string;
+                                mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                fallbackValue?: any;
+                            }>, import("zod").ZodObject<{
+                                type: import("zod").ZodLiteral<"byIndex">;
+                                expression: import("zod").ZodString;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }>]>>;
+                            width: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                fromData: import("zod").ZodString;
+                                mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                fromData: string;
+                                mode: "cycle" | "useFallback" | "clamp";
+                                fallbackValue?: any;
+                            }, {
+                                fromData: string;
+                                mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                fallbackValue?: any;
+                            }>, import("zod").ZodObject<{
+                                type: import("zod").ZodLiteral<"byIndex">;
+                                expression: import("zod").ZodString;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }>]>>;
+                            height: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                fromData: import("zod").ZodString;
+                                mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                fromData: string;
+                                mode: "cycle" | "useFallback" | "clamp";
+                                fallbackValue?: any;
+                            }, {
+                                fromData: string;
+                                mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                fallbackValue?: any;
+                            }>, import("zod").ZodObject<{
+                                type: import("zod").ZodLiteral<"byIndex">;
+                                expression: import("zod").ZodString;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }>]>>;
+                            color: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                                fromData: import("zod").ZodString;
+                                mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                fromData: string;
+                                mode: "cycle" | "useFallback" | "clamp";
+                                fallbackValue?: any;
+                            }, {
+                                fromData: string;
+                                mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                                fallbackValue?: any;
+                            }>, import("zod").ZodObject<{
+                                type: import("zod").ZodLiteral<"byIndex">;
+                                expression: import("zod").ZodString;
+                                fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }, {
+                                type: "byIndex";
+                                expression: string;
+                                fallbackValue?: any;
+                            }>]>>;
+                        }, import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                            fromData: import("zod").ZodString;
+                            mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            fromData: string;
+                            mode: "cycle" | "useFallback" | "clamp";
+                            fallbackValue?: any;
+                        }, {
+                            fromData: string;
+                            mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                            fallbackValue?: any;
+                        }>, import("zod").ZodObject<{
+                            type: import("zod").ZodLiteral<"byIndex">;
+                            expression: import("zod").ZodString;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }>]>, "strip"> | undefined;
+                        ease?: string | undefined;
+                        delay?: string | number | boolean | {
+                            fromData: string;
+                            mode: "cycle" | "useFallback" | "clamp";
+                            fallbackValue?: any;
+                        } | {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        } | null | undefined;
+                        stagger?: number | {
+                            type?: "fromData" | undefined;
+                            from?: string | number | undefined;
+                            ease?: string | undefined;
+                            dataKey?: string | undefined;
+                            referencePoint?: "tweenStart" | undefined;
+                            each?: number | undefined;
+                            grid?: [number | "auto", number | "auto"] | undefined;
+                            axis?: "x" | "y" | undefined;
+                            amount?: number | undefined;
+                        } | undefined;
+                    } & {
+                        [k: string]: any;
+                    };
+                    position?: string | number | {
+                        anchor: string;
+                        alignTween: "center" | "start" | "end";
+                        offset: string;
+                        anchorPoint?: "start" | "end" | undefined;
+                    } | undefined;
+                };
+                id?: string | undefined;
+                target?: string | undefined;
+            };
+            startAt?: number | undefined;
+            enabled?: boolean | undefined;
+        }[];
+        subtitlesSeed?: number | undefined;
+    };
+    get effects(): {
+        map: Record<string, {
+            type: "blur";
+            radius: number;
+            intensity: number;
+            blendMode: "color" | "normal" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "luminosity";
+            enabled?: boolean | undefined;
+        } | {
+            type: "colorAdjustment";
+            intensity: number;
+            hue: number;
+            saturation: number;
+            blendMode: "color" | "normal" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "luminosity";
+            brightness: number;
+            contrast: number;
+            enabled?: boolean | undefined;
+        } | {
+            type: "layoutSplit";
+            intensity: number;
+            blendMode: "color" | "normal" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "luminosity";
+            enabled?: boolean | undefined;
+            pieces?: number | undefined;
+            sceneWidth?: number | undefined;
+            sceneHeight?: number | undefined;
+            chunks?: Record<string, any>[] | undefined;
+        } | {
+            type: "rotationRandomizer";
+            intensity: number;
+            blendMode: "color" | "normal" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "luminosity";
+            maxRotation: number;
+            animate: boolean;
+            enabled?: boolean | undefined;
+            seed?: number | undefined;
+        } | {
+            type: "fillBackgroundBlur";
+            enabled: boolean;
+            blurAmount: number;
+        } | {
+            type: "textShadow";
+            intensity: number;
+            blendMode: "color" | "normal" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "luminosity";
+            offsetX?: number | undefined;
+            offsetY?: number | undefined;
+            opacity?: number | undefined;
+            enabled?: boolean | undefined;
+            color?: string | undefined;
+            preset?: string | undefined;
+            blur?: number | undefined;
+            size?: number | undefined;
+        } | {
+            type: "textOutline";
+            color: string;
+            intensity: number;
+            blendMode: "color" | "normal" | "multiply" | "screen" | "overlay" | "darken" | "lighten" | "color-dodge" | "color-burn" | "hard-light" | "soft-light" | "difference" | "exclusion" | "hue" | "saturation" | "luminosity";
+            opacity?: number | undefined;
+            enabled?: boolean | undefined;
+            preset?: string | undefined;
+            size?: number | undefined;
+            style?: "solid" | "dashed" | "dotted" | undefined;
+            dashArray?: number[] | undefined;
+        }>;
+        enabled: boolean;
+    };
+    get checksum(): string;
+    getData(): ComponentData;
+    setData(data: ComponentData): void;
+    setStart(start: number): void;
+    setEnd(end: number): void;
+    setStreamPath(path: string): void;
+    updateText(text: string): Promise<void>;
+    update(data: Partial<AppearanceInput>): void;
+    updateAppearance(appearance: Partial<AppearanceInput>): Promise<void>;
+    setVisible(visible: boolean): Promise<void>;
+    setOrder(order: number): Promise<void>;
+}