@nodetool-ai/video-nodes 0.8.1

package/dist/nodes/video.d.ts

@@ -0,0 +1,705 @@
+import { BaseNode } from "@nodetool-ai/node-sdk";
+import type { Entity, InputMode, FolderRef } from "@nodetool-ai/protocol";
+import type { VideoRef, ImageRef, AudioRef, StreamingInputs, StreamingOutputs } from "@nodetool-ai/node-sdk";
+import type { ProcessingContext } from "@nodetool-ai/runtime";
+/** Structural type for the `video_model` prop (provider + model id). */
+interface VideoModelRef {
+    type: "video_model";
+    provider?: string;
+    id?: string;
+    name?: string;
+    path?: string | null;
+    supported_tasks?: unknown[];
+}
+/** Structural type for the `color` prop. */
+interface ColorRef {
+    type: "color";
+    value?: string;
+}
+/** Structural type for the `font` prop. */
+interface FontLike {
+    type: "font";
+    name?: string;
+    source?: string;
+    url?: string;
+    weight?: string;
+}
+/** Structural type for a subtitle `audio_chunk`. */
+interface SubtitleChunk {
+    text?: string;
+    content?: string;
+    timestamp?: unknown[];
+    start?: number;
+    end?: number;
+}
+/**
+ * Parse cropdetect's suggested crop from ffmpeg stderr. cropdetect logs one
+ * `crop=w:h:x:y` per analyzed frame; the last suggestion reflects the full
+ * analysis, so return that. Null when no suggestion is present.
+ */
+export declare function parseCropDetectCrop(stderr: string): string | null;
+/**
+ * Base for every ffmpeg-backed node. Carries only the runtime gate; each node
+ * declares its own props and `process()`.
+ */
+declare abstract class VideoTransformNode extends BaseNode {
+    static readonly requiredRuntimes: string[];
+}
+/** Output handles TextToVideoNode.process() emits. */
+type TextToVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class TextToVideoNode extends BaseNode {
+    static readonly nodeType = "nodetool.video.TextToVideo";
+    static readonly body = "content_card";
+    static readonly title = "Text To Video";
+    static readonly description = "Generate videos from text prompts using any supported video provider. Automatically routes to the appropriate backend (Gemini Veo, HuggingFace).\n    video, generation, AI, text-to-video, t2v";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    static readonly inlineFields: string[];
+    static readonly inputFields: string[];
+    static readonly autoSaveAsset = true;
+    model: VideoModelRef;
+    prompt: string;
+    negative_prompt: string;
+    entities: Entity[];
+    aspect_ratio: string;
+    resolution: string;
+    duration: number;
+    timeout_seconds: number;
+    process(context?: ProcessingContext): Promise<TextToVideoNodeOutputs>;
+}
+/** Output handles ImageToVideoNode.process() emits. */
+type ImageToVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class ImageToVideoNode extends BaseNode {
+    static readonly nodeType = "nodetool.video.ImageToVideo";
+    static readonly body = "content_card";
+    static readonly title = "Image To Video";
+    static readonly description = "Animate static images into video with AI-powered motion using any supported video provider.\n    video, image-to-video, i2v, animation, ai, generation, sora, veo";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    static readonly inlineFields: string[];
+    static readonly inputFields: string[];
+    static readonly autoSaveAsset = true;
+    image: ImageRef[];
+    model: VideoModelRef;
+    prompt: string;
+    negative_prompt: string;
+    entities: Entity[];
+    aspect_ratio: string;
+    resolution: string;
+    duration: number;
+    timeout_seconds: number;
+    process(context?: ProcessingContext): Promise<ImageToVideoNodeOutputs>;
+}
+/** Output handles ReferenceToVideoNode.process() emits. */
+type ReferenceToVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class ReferenceToVideoNode extends BaseNode {
+    static readonly nodeType = "nodetool.video.ReferenceToVideo";
+    static readonly body = "content_card";
+    static readonly title = "Reference To Video";
+    static readonly description = "Generate video using ordered image and video references for identity, style, scene, motion, or audio conditioning.\n    video, reference-to-video, r2v, generation, ai";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    static readonly inlineFields: string[];
+    static readonly inputFields: string[];
+    static readonly autoSaveAsset = true;
+    reference_images: ImageRef[];
+    reference_videos: VideoRef[];
+    model: VideoModelRef;
+    prompt: string;
+    use_reference_video_audio: boolean;
+    negative_prompt: string;
+    entities: Entity[];
+    aspect_ratio: string;
+    resolution: string;
+    duration: number;
+    timeout_seconds: number;
+    process(context?: ProcessingContext): Promise<ReferenceToVideoNodeOutputs>;
+}
+/** Output handles LoadVideoFileNode.process() emits. */
+type LoadVideoFileNodeOutputs = {
+    output: VideoRef;
+};
+export declare class LoadVideoFileNode extends BaseNode {
+    static readonly nodeType = "nodetool.video.LoadVideoFile";
+    static readonly title = "Load Video File";
+    static readonly description = "Read a video file from disk.\n    video, input, load, file";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    static readonly inlineFields: string[];
+    static readonly inputFields: string[];
+    path: string;
+    process(): Promise<LoadVideoFileNodeOutputs>;
+}
+/** Output handles SaveVideoFileVideoNode.process() emits. */
+type SaveVideoFileVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class SaveVideoFileVideoNode extends BaseNode {
+    static readonly nodeType = "nodetool.video.SaveVideoFile";
+    static readonly title = "Save Video File";
+    static readonly description = "Write a video file to disk.\n    video, output, save, file\n\n    The filename can include time and date variables:\n    %Y - Year, %m - Month, %d - Day\n    %H - Hour, %M - Minute, %S - Second";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    static readonly inlineFields: string[];
+    static readonly inputFields: string[];
+    video: VideoRef;
+    save_to_workspace: boolean;
+    folder: string;
+    filename: string;
+    process(context?: ProcessingContext): Promise<SaveVideoFileVideoNodeOutputs>;
+}
+export declare class LoadVideoAssetsNode extends BaseNode {
+    static readonly nodeType = "nodetool.video.LoadVideoAssets";
+    static readonly title = "Load Video Folder";
+    static readonly description = "Load video files from an asset folder.\n    load, video, file, import";
+    static readonly metadataOutputTypes: {
+        video: string;
+        name: string;
+        videos: string;
+        names: string;
+    };
+    static readonly inlineFields: string[];
+    static readonly inputFields: string[];
+    static readonly inputMode: InputMode;
+    static readonly outputCorrelation: {
+        video: {
+            kind: "iteration";
+            source: string;
+            group: string;
+        };
+        name: {
+            kind: "iteration";
+            source: string;
+            group: string;
+        };
+        videos: {
+            kind: "single";
+            source: string;
+        };
+        names: {
+            kind: "single";
+            source: string;
+        };
+    };
+    folder: FolderRef;
+    process(): Promise<Record<string, unknown>>;
+    private _loadVideos;
+    genProcess(): AsyncGenerator<Record<string, unknown>>;
+}
+/** Output handles SaveVideoNode.process() emits. */
+type SaveVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class SaveVideoNode extends BaseNode {
+    static readonly nodeType = "nodetool.video.SaveVideo";
+    static readonly title = "Save Video Asset";
+    static readonly description = "Save a video to an asset folder.\n    video, save, file, output";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    static readonly inlineFields: string[];
+    static readonly inputFields: string[];
+    video: VideoRef;
+    folder: FolderRef;
+    name: string;
+    process(context?: ProcessingContext): Promise<SaveVideoNodeOutputs>;
+}
+/** Output handles ForEachFrameNode.genProcess() emits. */
+type ForEachFrameNodeStreamOutputs = {
+    frame: {
+        type: string;
+        data: string;
+    };
+    index: number;
+    fps: number;
+};
+export declare class ForEachFrameNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.ForEachFrame";
+    static readonly title = "For Each Frame";
+    static readonly description = "Extract frames from a video file with ffmpeg.\n    video, frames, extract, sequence";
+    static readonly metadataOutputTypes: {
+        frame: string;
+        index: string;
+        fps: string;
+    };
+    static readonly inlineFields: string[];
+    static readonly inputFields: string[];
+    static readonly inputMode: InputMode;
+    static readonly outputCorrelation: {
+        frame: {
+            kind: "iteration";
+            source: string;
+            group: string;
+        };
+        index: {
+            kind: "iteration";
+            source: string;
+            group: string;
+        };
+        fps: {
+            kind: "single";
+            source: string;
+        };
+    };
+    video: VideoRef;
+    start: number;
+    end: number;
+    process(context?: ProcessingContext): Promise<Record<string, unknown>>;
+    genProcess(context?: ProcessingContext): AsyncGenerator<ForEachFrameNodeStreamOutputs>;
+}
+/** Output handles FpsNode.process() emits. */
+type FpsNodeOutputs = {
+    output: number;
+};
+export declare class FpsNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.Fps";
+    static readonly title = "Fps";
+    static readonly description = "Get the frames per second (FPS) of a video file.\n    video, analysis, frames, fps";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    static readonly inlineFields: string[];
+    static readonly inputFields: string[];
+    video: VideoRef;
+    process(context?: ProcessingContext): Promise<FpsNodeOutputs>;
+}
+/** Output handles FrameToVideoNode.process() emits. */
+type FrameToVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class FrameToVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.FrameToVideo";
+    static readonly title = "Frame To Video";
+    static readonly description = "Combine a sequence of frames into a single video file.\n    video, frames, combine, sequence";
+    static readonly isStreamingInput = true;
+    static readonly inputMode: InputMode;
+    static readonly outputCorrelation: {
+        output: {
+            kind: "aggregate";
+            source: string;
+            collapse: "innermost";
+        };
+    };
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    static readonly inlineFields: string[];
+    static readonly inputFields: string[];
+    frame: ImageRef | ImageRef[];
+    fps: number;
+    run(inputs: StreamingInputs, outputs: StreamingOutputs, _context?: ProcessingContext): Promise<void>;
+    process(): Promise<FrameToVideoNodeOutputs>;
+}
+/** Output handles ConcatVideoNode.process() emits. */
+type ConcatVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class ConcatVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.Concat";
+    static readonly body = "content_card";
+    static readonly title = "Concatenate Video";
+    static readonly description = "Concatenate multiple video files into a single video, including audio when available. Add inputs dynamically with the \u201Cadd video input\u201D button, or wire a list of videos into a single input.\n    video, concat, merge, combine, audio, +";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    static readonly inlineFields: string[];
+    static readonly inputFields: string[];
+    static readonly supportsDynamicInputs = true;
+    process(context?: ProcessingContext): Promise<ConcatVideoNodeOutputs>;
+}
+/** Output handles TrimVideoNode.process() emits. */
+type TrimVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class TrimVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.Trim";
+    static readonly title = "Trim";
+    static readonly description = "Trim a video to a specific start and end time.\n    video, trim, cut, segment";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    static readonly inputFields: string[];
+    video: VideoRef;
+    start_time: number;
+    end_time: number;
+    accurate: boolean;
+    process(context?: ProcessingContext): Promise<TrimVideoNodeOutputs>;
+}
+/** Output handles ResizeVideoNode.process() emits. */
+type ResizeVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class ResizeVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.Resize";
+    static readonly title = "Resize";
+    static readonly description = "Resize a video to a specific width and height.\n    video, resize, scale, dimensions";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    video: VideoRef;
+    width: number;
+    height: number;
+    process(context?: ProcessingContext): Promise<ResizeVideoNodeOutputs>;
+}
+/** Output handles RotateVideoNode.process() emits. */
+type RotateVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class RotateVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.Rotate";
+    static readonly title = "Rotate";
+    static readonly description = "Rotate a video by a specified angle.\n    video, rotate, orientation, transform";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    video: VideoRef;
+    angle: number;
+    process(context?: ProcessingContext): Promise<RotateVideoNodeOutputs>;
+}
+/** Output handles SetSpeedVideoNode.process() emits. */
+type SetSpeedVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class SetSpeedVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.SetSpeed";
+    static readonly title = "Set Speed";
+    static readonly description = "Adjust the playback speed of a video.\n    video, speed, tempo, time";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    video: VideoRef;
+    speed_factor: number;
+    process(context?: ProcessingContext): Promise<SetSpeedVideoNodeOutputs>;
+}
+/** Output handles OverlayVideoNode.process() emits. */
+type OverlayVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class OverlayVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.Overlay";
+    static readonly title = "Overlay";
+    static readonly description = "Overlay one video on top of another, including audio overlay when available.\n    video, overlay, composite, picture-in-picture, audio";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    main_video: VideoRef;
+    overlay_video: VideoRef;
+    x: number;
+    y: number;
+    scale: number;
+    overlay_audio_volume: number;
+    process(context?: ProcessingContext): Promise<OverlayVideoNodeOutputs>;
+}
+/** Output handles ColorBalanceVideoNode.process() emits. */
+type ColorBalanceVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class ColorBalanceVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.ColorBalance";
+    static readonly title = "Color Balance";
+    static readonly description = "Adjust the color balance of a video.\n    video, color, balance, adjustment";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    video: VideoRef;
+    red_adjust: number;
+    green_adjust: number;
+    blue_adjust: number;
+    process(context?: ProcessingContext): Promise<ColorBalanceVideoNodeOutputs>;
+}
+/** Output handles DenoiseVideoNode.process() emits. */
+type DenoiseVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class DenoiseVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.Denoise";
+    static readonly title = "Denoise";
+    static readonly description = "Apply noise reduction to a video.\n    video, denoise, clean, enhance";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    video: VideoRef;
+    strength: number;
+    process(context?: ProcessingContext): Promise<DenoiseVideoNodeOutputs>;
+}
+/** Output handles StabilizeVideoNode.process() emits. */
+type StabilizeVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class StabilizeVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.Stabilize";
+    static readonly title = "Stabilize";
+    static readonly description = "Apply video stabilization to reduce camera shake and jitter.\n    video, stabilize, smooth, shake-reduction";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    video: VideoRef;
+    smoothing: number;
+    crop_black: boolean;
+    process(context?: ProcessingContext): Promise<StabilizeVideoNodeOutputs>;
+}
+/** Output handles SharpnessVideoNode.process() emits. */
+type SharpnessVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class SharpnessVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.Sharpness";
+    static readonly title = "Sharpness";
+    static readonly description = "Adjust the sharpness of a video.\n    video, sharpen, enhance, detail";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    video: VideoRef;
+    luma_amount: number;
+    chroma_amount: number;
+    process(context?: ProcessingContext): Promise<SharpnessVideoNodeOutputs>;
+}
+/** Output handles BlurVideoNode.process() emits. */
+type BlurVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class BlurVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.Blur";
+    static readonly title = "Blur";
+    static readonly description = "Apply a blur effect to a video.\n    video, blur, smooth, soften";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    video: VideoRef;
+    strength: number;
+    process(context?: ProcessingContext): Promise<BlurVideoNodeOutputs>;
+}
+/** Output handles SaturationVideoNode.process() emits. */
+type SaturationVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class SaturationVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.Saturation";
+    static readonly title = "Saturation";
+    static readonly description = "Adjust the color saturation of a video.\n    video, saturation, color, enhance";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    video: VideoRef;
+    saturation: number;
+    process(context?: ProcessingContext): Promise<SaturationVideoNodeOutputs>;
+}
+/** Output handles AddSubtitlesVideoNode.process() emits. */
+type AddSubtitlesVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class AddSubtitlesVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.AddSubtitles";
+    static readonly title = "Add Subtitles";
+    static readonly description = "Add subtitles to a video.\n    video, subtitles, text, caption";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    video: VideoRef;
+    chunks: SubtitleChunk[];
+    font: FontLike;
+    align: string;
+    font_size: number;
+    font_color: ColorRef;
+    process(context?: ProcessingContext): Promise<AddSubtitlesVideoNodeOutputs>;
+}
+/** Output handles ReverseVideoNode.process() emits. */
+type ReverseVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class ReverseVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.Reverse";
+    static readonly title = "Reverse";
+    static readonly description = "Reverse the playback of a video.\n    video, reverse, backwards, effect";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    static readonly inputFields: string[];
+    video: VideoRef;
+    process(context?: ProcessingContext): Promise<ReverseVideoNodeOutputs>;
+}
+/** Output handles TransitionVideoNode.process() emits. */
+type TransitionVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class TransitionVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.Transition";
+    static readonly title = "Transition";
+    static readonly description = "Create a transition effect between two videos, including audio transition when available.\n    video, transition, effect, merge, audio";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    video_a: VideoRef;
+    video_b: VideoRef;
+    transition_type: string;
+    duration: number;
+    process(context?: ProcessingContext): Promise<TransitionVideoNodeOutputs>;
+}
+/** Output handles AddAudioVideoNode.process() emits. */
+type AddAudioVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class AddAudioVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.AddAudio";
+    static readonly title = "Add Audio";
+    static readonly description = "Add an audio track to a video, replacing or mixing with existing audio.\n    video, audio, soundtrack, merge";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    static readonly inputFields: string[];
+    video: VideoRef;
+    audio: AudioRef;
+    volume: number;
+    mix: boolean;
+    output_length: string;
+    process(context?: ProcessingContext): Promise<AddAudioVideoNodeOutputs>;
+}
+/** Output handles ChromaKeyVideoNode.process() emits. */
+type ChromaKeyVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class ChromaKeyVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.ChromaKey";
+    static readonly title = "Chroma Key";
+    static readonly description = "Apply chroma key (green screen) effect to a video. The MP4 output has no alpha channel, so the keyed-out area renders black \u2014 composite it over a background with the Overlay node.\n    video, chroma key, green screen, compositing";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    video: VideoRef;
+    key_color: ColorRef;
+    similarity: number;
+    blend: number;
+    process(context?: ProcessingContext): Promise<ChromaKeyVideoNodeOutputs>;
+}
+/** Output handles ExtractAudioVideoNode.process() emits. */
+type ExtractAudioVideoNodeOutputs = {
+    output: {
+        type: string;
+        data: null;
+        uri: string;
+        asset_id: null;
+        metadata: null;
+    } | {
+        type: string;
+        data: string;
+        uri: string;
+        asset_id: null;
+        metadata: null;
+    };
+};
+export declare class ExtractAudioVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.ExtractAudio";
+    static readonly title = "Extract Audio";
+    static readonly description = "Separate and extract audio track from a video file.\n    video, audio, extract, separate, split";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    static readonly inputFields: string[];
+    video: VideoRef;
+    process(context?: ProcessingContext): Promise<ExtractAudioVideoNodeOutputs>;
+}
+/** Output handles ExtractFrameVideoNode.process() emits. */
+type ExtractFrameVideoNodeOutputs = {
+    output: {
+        type: string;
+        data: null;
+    } | {
+        type: string;
+        data: string;
+    };
+};
+export declare class ExtractFrameVideoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.ExtractFrame";
+    static readonly title = "Extract Video Frame";
+    static readonly description = "Extract a single frame from a video at a specific time position.\n    video, frame, extract, screenshot, thumbnail, capture";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    static readonly inputFields: string[];
+    video: VideoRef;
+    time: number;
+    process(context?: ProcessingContext): Promise<ExtractFrameVideoNodeOutputs>;
+}
+/** Output handles GetVideoInfoNode.process() emits. */
+type GetVideoInfoNodeOutputs = {
+    duration: number;
+    width: number;
+    height: number;
+    fps: number;
+    frame_count: number;
+    codec: string;
+    has_audio: boolean;
+};
+export declare class GetVideoInfoNode extends VideoTransformNode {
+    static readonly nodeType = "nodetool.video.GetVideoInfo";
+    static readonly title = "Get Video Info";
+    static readonly description = "Get metadata about a video file including duration, resolution, frame rate, and codec.\n    video, info, metadata, duration, resolution, fps, codec, analysis";
+    static readonly metadataOutputTypes: {
+        duration: string;
+        width: string;
+        height: string;
+        fps: string;
+        frame_count: string;
+        codec: string;
+        has_audio: string;
+    };
+    static readonly inputFields: string[];
+    video: VideoRef;
+    process(context?: ProcessingContext): Promise<GetVideoInfoNodeOutputs>;
+}
+/** Output handles VideoToVideoNode.process() emits. */
+type VideoToVideoNodeOutputs = {
+    output: VideoRef;
+};
+export declare class VideoToVideoNode extends BaseNode {
+    static readonly nodeType = "nodetool.video.VideoToVideo";
+    static readonly body = "content_card";
+    static readonly title = "Video To Video";
+    static readonly description = "Restyle or edit an existing video with a text prompt using any supported video provider.\n    video, video-to-video, v2v, restyle, style-transfer, AI";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    static readonly inlineFields: string[];
+    static readonly inputFields: string[];
+    static readonly autoSaveAsset = true;
+    model: VideoModelRef;
+    video: VideoRef;
+    prompt: string;
+    negative_prompt: string;
+    strength: number;
+    process(context?: ProcessingContext): Promise<VideoToVideoNodeOutputs>;
+}
+/** Output handles LipSyncNode.process() emits. */
+type LipSyncNodeOutputs = {
+    output: VideoRef;
+};
+export declare class LipSyncNode extends BaseNode {
+    static readonly nodeType = "nodetool.video.LipSync";
+    static readonly body = "content_card";
+    static readonly title = "Lip Sync";
+    static readonly description = "Drive a face in a video to match speech in an audio track using any supported lip-sync provider.\n    video, lip-sync, lipsync, talking-head, dubbing, AI";
+    static readonly metadataOutputTypes: {
+        output: string;
+    };
+    static readonly inlineFields: string[];
+    static readonly inputFields: string[];
+    static readonly autoSaveAsset = true;
+    model: VideoModelRef;
+    video: VideoRef;
+    audio: AudioRef;
+    process(context?: ProcessingContext): Promise<LipSyncNodeOutputs>;
+}
+export declare const VIDEO_NODES: readonly [typeof TextToVideoNode, typeof ImageToVideoNode, typeof ReferenceToVideoNode, typeof LoadVideoFileNode, typeof SaveVideoFileVideoNode, typeof LoadVideoAssetsNode, typeof SaveVideoNode, typeof ForEachFrameNode, typeof FpsNode, typeof FrameToVideoNode, typeof ConcatVideoNode, typeof TrimVideoNode, typeof ResizeVideoNode, typeof RotateVideoNode, typeof SetSpeedVideoNode, typeof OverlayVideoNode, typeof ColorBalanceVideoNode, typeof DenoiseVideoNode, typeof StabilizeVideoNode, typeof SharpnessVideoNode, typeof BlurVideoNode, typeof SaturationVideoNode, typeof AddSubtitlesVideoNode, typeof ReverseVideoNode, typeof TransitionVideoNode, typeof AddAudioVideoNode, typeof ChromaKeyVideoNode, typeof ExtractAudioVideoNode, typeof ExtractFrameVideoNode, typeof GetVideoInfoNode, typeof VideoToVideoNode, typeof LipSyncNode];
+export {};
+//# sourceMappingURL=video.d.ts.map