@jtdigital/renderbox-sdk 0.2.0

package/dist/ops/video.d.ts

@@ -0,0 +1,695 @@
+import type { Stream } from '../types.js';
+export declare function alphaextract(): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface AutoEnhanceOpts {
+    model: string;
+    /** @range [0, 1] */
+    strength?: number;
+}
+export declare function autoEnhance(opts: AutoEnhanceOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface BackgroundkeyOpts {
+    threshold?: number;
+    similarity?: number;
+    blend?: number;
+}
+export declare function backgroundkey(opts?: BackgroundkeyOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface BilateralOpts {
+    sigmaS?: number;
+    sigmaR?: number;
+    planes?: number;
+}
+export declare function bilateral(opts?: BilateralOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface BlackdetectOpts {
+    d?: number;
+    pix_th?: number;
+    pic_th?: number;
+}
+export declare function blackdetect(opts?: BlackdetectOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface Bm3dOpts {
+    sigma?: number;
+    block?: number;
+    bstep?: number;
+    group?: number;
+    range?: number;
+    mstep?: number;
+    thmse?: number;
+    hdthr?: number;
+    estim?: 'basic' | 'final';
+}
+export declare function bm3d(opts?: Bm3dOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface BoxblurOpts {
+    luma_radius?: string;
+    chroma_radius?: string;
+    luma_power?: number;
+    chroma_power?: number;
+}
+export declare function boxblur(opts?: BoxblurOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface CasOpts {
+    /** @range [0, 1] */
+    strength?: number;
+    planes?: number;
+}
+export declare function cas(opts?: CasOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface ChromakeyOpts {
+    color: string;
+    /** @range [0, 1] */
+    similarity?: number;
+    /** @range [0, 1] */
+    blend?: number;
+}
+export declare function chromakey(opts: ChromakeyOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface ColorCorrectOpts {
+    model: string;
+    /** @range [0, 1] */
+    strength?: number;
+}
+export declare function colorCorrect(opts: ColorCorrectOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface ColorbalanceOpts {
+    rs?: number;
+    gs?: number;
+    bs?: number;
+    rm?: number;
+    gm?: number;
+    bm?: number;
+    rh?: number;
+    gh?: number;
+    bh?: number;
+}
+export declare function colorbalance(opts?: ColorbalanceOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface ColorchannelmixerOpts {
+    rr?: number;
+    rg?: number;
+    rb?: number;
+    ra?: number;
+    gr?: number;
+    gg?: number;
+    gb?: number;
+    ga?: number;
+    br?: number;
+    bg?: number;
+    bb?: number;
+    ba?: number;
+    ar?: number;
+    ag?: number;
+    ab?: number;
+    aa?: number;
+}
+export declare function colorchannelmixer(opts?: ColorchannelmixerOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface ColorgradeOpts {
+    lut?: string;
+}
+export declare function colorgrade(opts?: ColorgradeOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface ColorholdOpts {
+    color: string;
+    similarity?: number;
+    blend?: number;
+}
+export declare function colorhold(opts: ColorholdOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface ColorizeOpts {
+    model: string;
+    /** @range greater than 0 */
+    saturation?: number;
+    /** @range [0, 1] */
+    temporal_stability?: number;
+}
+export declare function colorize(opts: ColorizeOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface ColorkeyOpts {
+    color: string;
+    /** @range [0, 1] */
+    similarity?: number;
+    /** @range [0, 1] */
+    blend?: number;
+}
+export declare function colorkey(opts: ColorkeyOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface ColorspaceOpts {
+    all?: 'bt470m' | 'bt470bg' | 'bt601-6-525' | 'bt601-6-625' | 'bt709' | 'smpte170m' | 'smpte240m' | 'bt2020';
+    space?: string;
+    trc?: string;
+    primaries?: string;
+    range?: 'tv' | 'mpeg' | 'pc' | 'jpeg';
+    format?: string;
+    fast?: number;
+    iall?: string;
+    ispace?: string;
+    itrc?: string;
+    iprimaries?: string;
+    irange?: 'tv' | 'mpeg' | 'pc' | 'jpeg';
+}
+export declare function colorspace(opts?: ColorspaceOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface ColortemperatureOpts {
+    temperature: number;
+}
+export declare function colortemperature(opts: ColortemperatureOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface CropOpts {
+    /** @range greater than 0 */
+    w?: number | string;
+    /** @range greater than 0 */
+    h?: number | string;
+    x?: number | string;
+    y?: number | string;
+}
+export declare function crop(opts?: CropOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface CurvesOpts {
+    preset: 'none' | 'color_negative' | 'cross_process' | 'darker' | 'increase_contrast' | 'lighter' | 'linear_contrast' | 'medium_contrast' | 'negative' | 'strong_contrast' | 'vintage';
+}
+export declare function curves(opts: CurvesOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface DebandOpts {
+    '1thr'?: number;
+    range?: number;
+    blur?: boolean;
+}
+export declare function deband(opts?: DebandOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface DeblockOpts {
+    strong?: boolean;
+}
+export declare function deblock(opts?: DeblockOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface DeblurOpts {
+    model: string;
+    /** @range [0, 1] */
+    strength?: number;
+}
+export declare function deblur(opts: DeblurOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface DeflickerOpts {
+    size?: number;
+    mode?: string;
+}
+export declare function deflicker(opts?: DeflickerOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface DeinterlaceOpts {
+    model: string;
+}
+export declare function deinterlace(opts: DeinterlaceOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface DelogoOpts {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export declare function delogo(opts: DelogoOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface DenoiseOpts {
+    model: string;
+    /** @range [0, 1] */
+    strength?: number;
+}
+export declare function denoise(opts: DenoiseOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface DenoiseHqdn3dOpts {
+    strength?: number;
+}
+export declare function denoiseHqdn3d(opts?: DenoiseHqdn3dOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface DeshakeOpts {
+    rx?: number;
+    ry?: number;
+}
+export declare function deshake(opts?: DeshakeOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface DilationOpts {
+    threshold0?: number;
+    threshold1?: number;
+    threshold2?: number;
+    threshold3?: number;
+    coordinates?: number;
+}
+export declare function dilation(opts?: DilationOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface DrawboxOpts {
+    x?: number | string;
+    y?: number | string;
+    w?: number | string;
+    h?: number | string;
+    color?: string;
+    t?: string;
+    enable?: string;
+}
+export declare function drawbox(opts?: DrawboxOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface DrawgridOpts {
+    x?: string;
+    y?: string;
+    w?: string;
+    h?: string;
+    color?: string;
+    t?: string;
+    replace?: number;
+}
+export declare function drawgrid(opts?: DrawgridOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface DrawtextOpts {
+    text?: string;
+    textfile?: string;
+    fontfile?: string;
+    fontsize?: number | string;
+    fontcolor?: string;
+    x?: number | string;
+    y?: number | string;
+    boxcolor?: string;
+    borderw?: number;
+    shadowcolor?: string;
+    shadowx?: number;
+    shadowy?: number;
+    alpha?: number | string;
+    font?: string;
+    line_spacing?: number;
+    enable?: string;
+    expansion?: 'none' | 'normal' | 'strftime';
+}
+export declare function drawtext(opts?: DrawtextOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface EdgedetectOpts {
+    low?: number;
+    high?: number;
+    mode?: 'wires' | 'colormix' | 'canny';
+}
+export declare function edgedetect(opts?: EdgedetectOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface EqOpts {
+    /** @range [-1, 1] */
+    brightness?: number;
+    /** @range [-1000, 1000] */
+    contrast?: number;
+    /** @range [0, 3] */
+    saturation?: number;
+    /** @range [0.1, 10] */
+    gamma?: number;
+}
+export declare function eq(opts?: EqOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface ErosionOpts {
+    threshold0?: number;
+    threshold1?: number;
+    threshold2?: number;
+    threshold3?: number;
+    coordinates?: number;
+}
+export declare function erosion(opts?: ErosionOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface FadeOpts {
+    type: 'in' | 'out';
+    /** @range at least 0 */
+    st?: number;
+    /** @range greater than 0 */
+    d?: number;
+    color?: string;
+    alpha?: number;
+}
+export declare function fade(opts: FadeOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface FillbordersOpts {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+    mode?: 'smear' | 'mirror' | 'fixed' | 'reflect' | 'wrap' | 'fade' | 'margins';
+    color?: string;
+}
+export declare function fillborders(opts?: FillbordersOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface FormatOpts {
+    pix_fmts: string;
+}
+export declare function format(opts: FormatOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface FpsOpts {
+    /** @range greater than 0 */
+    fps: number;
+}
+export declare function fps(opts: FpsOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface FrameInterpolateOpts {
+    model: string;
+    /** @range greater than 0 */
+    factor?: number;
+}
+export declare function frameInterpolate(opts: FrameInterpolateOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface FramestepOpts {
+    /** @range at least 1 */
+    step: number;
+}
+export declare function framestep(opts: FramestepOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface FreezedetectOpts {
+    noise?: number;
+    duration?: number;
+}
+export declare function freezedetect(opts?: FreezedetectOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface GblurOpts {
+    /** @range greater than 0 */
+    sigma: number;
+}
+export declare function gblur(opts: GblurOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface GeqOpts {
+    r?: string;
+    g?: string;
+    b?: string;
+    a?: string;
+    lum_expr?: string;
+}
+export declare function geq(opts?: GeqOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export declare function hflip(): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface HistogramOpts {
+    level_height?: number;
+    display_mode?: 'stack' | 'parade' | 'overlay';
+    levels_mode?: 'logarithmic' | 'linear';
+}
+export declare function histogram(opts?: HistogramOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface Hqdn3dOpts {
+    luma_spatial?: number;
+    chroma_spatial?: number;
+    luma_tmp?: number;
+    chroma_tmp?: number;
+}
+export declare function hqdn3d(opts?: Hqdn3dOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface HueOpts {
+    h?: number | string;
+    s?: number | string;
+    b?: number | string;
+}
+export declare function hue(opts?: HueOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export declare function hwdownload(): (input: Stream<'Video'>) => Stream<'Video'>;
+export declare function hwupload(): (input: Stream<'Video'>) => Stream<'Video'>;
+export declare function hwuploadCuda(): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface LagfunOpts {
+    decay?: number;
+    planes?: number;
+}
+export declare function lagfun(opts?: LagfunOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface LenscorrectionOpts {
+    cx?: number;
+    cy?: number;
+    k1?: number;
+    k2?: number;
+    i?: 'nearest' | 'bilinear';
+}
+export declare function lenscorrection(opts?: LenscorrectionOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface LoopOpts {
+    loop: number;
+    size?: number;
+    start?: number;
+}
+export declare function loop(opts: LoopOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface Lut1dOpts {
+    file: string;
+}
+export declare function lut1d(opts: Lut1dOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface Lut3dOpts {
+    file: string;
+}
+export declare function lut3d(opts: Lut3dOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface MinterpolateOpts {
+    fps?: number;
+    mi_mode?: 'dup' | 'blend' | 'mci';
+    mc_mode?: 'obmc' | 'aobmc';
+    me_mode?: 'bidir' | 'bilat';
+    me?: 'esa' | 'tss' | 'tdls' | 'ntss' | 'fss' | 'ds' | 'hexbs' | 'epzs' | 'umh';
+    mb_size?: number;
+    search_param?: number;
+    scd?: 'none' | 'fdiff';
+    scd_threshold?: number;
+}
+export declare function minterpolate(opts?: MinterpolateOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface MpdecimateOpts {
+    max?: number;
+    lo?: number;
+    hi?: number;
+    frac?: number;
+}
+export declare function mpdecimate(opts?: MpdecimateOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface NegateOpts {
+    negate?: number;
+    alpha?: number;
+}
+export declare function negate(opts?: NegateOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface NlmeansOpts {
+    s?: number;
+}
+export declare function nlmeans(opts?: NlmeansOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface NoiseOpts {
+    /** @range [0, 100] */
+    alls?: number;
+    allf?: string;
+    seed?: number;
+}
+export declare function noise(opts?: NoiseOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface PadOpts {
+    /** @range greater than 0 */
+    w?: number | string;
+    /** @range greater than 0 */
+    h?: number | string;
+    x?: number | string;
+    y?: number | string;
+    color?: string;
+}
+export declare function pad(opts?: PadOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface PalettegenOpts {
+    max_colors?: number;
+    reserve_transparent?: number;
+    stats_mode?: 'full' | 'diff' | 'single';
+}
+export declare function palettegen(opts?: PalettegenOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface PaletteuseOpts {
+    dither?: 'bayer' | 'heckbert' | 'floyd_steinberg' | 'sierra2' | 'sierra2_4a' | 'sierra3' | 'burkes' | 'atkinson' | 'none';
+    bayer_scale?: number;
+    diff_mode?: 'rectangle' | 'none';
+    new?: number;
+}
+export declare function paletteuse(opts?: PaletteuseOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface PerspectiveOpts {
+    x0?: string;
+    y0?: string;
+    x1?: string;
+    y1?: string;
+    x2?: string;
+    y2?: string;
+    x3?: string;
+    y3?: string;
+    interpolation?: 'linear' | 'cubic';
+    sense?: 'source' | 'destination';
+}
+export declare function perspective(opts?: PerspectiveOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface PhotosensitivityOpts {
+    threshold?: number;
+    frames?: number;
+    skip?: number;
+}
+export declare function photosensitivity(opts?: PhotosensitivityOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface PseudocolorOpts {
+    preset?: string;
+    c0?: string;
+    c1?: string;
+    c2?: string;
+    c3?: string;
+    index?: number;
+    opacity?: number;
+}
+export declare function pseudocolor(opts?: PseudocolorOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface PsnrOpts {
+    stats_file?: string;
+}
+export declare function psnr(opts?: PsnrOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface RedactTracksOpts {
+    tracks: string;
+}
+export declare function redactTracks(opts: RedactTracksOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface ResizeOpts {
+    w: number;
+    h: number;
+}
+export declare function resize(opts: ResizeOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export declare function reverse(): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface RgbashiftOpts {
+    rh?: number;
+    rv?: number;
+    gh?: number;
+    gv?: number;
+    bh?: number;
+    bv?: number;
+    ah?: number;
+    av?: number;
+    edge?: 'smear' | 'wrap';
+    enable?: string;
+}
+export declare function rgbashift(opts?: RgbashiftOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface RotateOpts {
+    angle?: number | string;
+    a?: number | string;
+    fillcolor?: string;
+    bilinear?: number;
+}
+export declare function rotate(opts?: RotateOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface ScaleOpts {
+    /** @range greater than 0 */
+    w: number;
+    /** @range greater than 0 */
+    h: number;
+    force_original_aspect_ratio?: string;
+    flags?: string;
+}
+export declare function scale(opts: ScaleOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface ScaleCudaOpts {
+    w?: string;
+    h?: string;
+    interp_algo?: 'nearest' | 'bilinear' | 'bicubic' | 'lanczos';
+}
+export declare function scaleCuda(opts?: ScaleCudaOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface SelectOpts {
+    expr: string;
+}
+export declare function select(opts: SelectOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface SelectivecolorOpts {
+    correction_method?: 'absolute' | 'relative';
+    reds?: string;
+    yellows?: string;
+    greens?: string;
+    cyans?: string;
+    blues?: string;
+    magentas?: string;
+    whites?: string;
+    neutrals?: string;
+    blacks?: string;
+}
+export declare function selectivecolor(opts?: SelectivecolorOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface SendcmdOpts {
+    filename?: string;
+    commands?: string;
+}
+export declare function sendcmd(opts?: SendcmdOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface SetdarOpts {
+    dar: string;
+}
+export declare function setdar(opts: SetdarOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface SetptsOpts {
+    expr: string;
+}
+export declare function setpts(opts: SetptsOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface SetsarOpts {
+    sar: string;
+}
+export declare function setsar(opts: SetsarOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface SsimOpts {
+    stats_file?: string;
+}
+export declare function ssim(opts?: SsimOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface SubtitlesOpts {
+    filename: string;
+    fontsdir?: string;
+    force_style?: string;
+    charenc?: string;
+    stream_index?: number;
+}
+export declare function subtitles(opts: SubtitlesOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface TblendOpts {
+    all_mode?: string;
+    all_opacity?: number;
+    all_expr?: string;
+}
+export declare function tblend(opts?: TblendOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface ThumbnailOpts {
+    n?: number;
+}
+export declare function thumbnail(opts?: ThumbnailOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface TileOpts {
+    layout?: string;
+    nb_frames?: number;
+    padding?: number;
+    margin?: number;
+    color?: string;
+}
+export declare function tile(opts?: TileOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface TmixOpts {
+    frames?: number;
+    weights?: string;
+    scale?: number;
+    planes?: number;
+}
+export declare function tmix(opts?: TmixOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface TpadOpts {
+    start?: number;
+    stop?: number;
+    start_mode?: 'add' | 'clone';
+    stop_mode?: 'add' | 'clone';
+    start_duration?: number;
+    stop_duration?: number;
+    color?: string;
+}
+export declare function tpad(opts?: TpadOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface TransposeOpts {
+    /** @range [0, 3] */
+    dir: number;
+}
+export declare function transpose(opts: TransposeOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface TrimOpts {
+    /** @range at least 0 */
+    start?: number;
+    /** @range greater than 0 */
+    end?: number;
+}
+export declare function trim(opts?: TrimOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface UnsharpOpts {
+    luma_msize_x?: number;
+    luma_msize_y?: number;
+    luma_amount?: number;
+}
+export declare function unsharp(opts?: UnsharpOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface UpscaleOpts {
+    model: string;
+    /** @range greater than 0 */
+    scale?: number;
+    /** @range greater than 0 */
+    tileSize?: number;
+}
+export declare function upscale(opts: UpscaleOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface V360Opts {
+    input?: string;
+    output?: string;
+    interp?: string;
+    w?: number;
+    h?: number;
+    yaw?: number;
+    pitch?: number;
+    roll?: number;
+    d_fov?: number;
+    id_fov?: number;
+    h_flip?: boolean;
+    v_flip?: boolean;
+    in_stereo?: string;
+    out_stereo?: string;
+}
+export declare function v360(opts?: V360Opts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface VectorscopeOpts {
+    mode?: 'gray' | 'tint' | 'color' | 'color2' | 'color3' | 'color4' | 'color5';
+    intensity?: number;
+    envelope?: number;
+}
+export declare function vectorscope(opts?: VectorscopeOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export declare function vflip(): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface VidstabOpts {
+    shakiness?: number;
+    smoothing?: number;
+}
+export declare function vidstab(opts?: VidstabOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface VidstabdetectOpts {
+    shakiness?: number;
+    accuracy?: number;
+    stepsize?: number;
+    mincontrast?: number;
+    result?: string;
+}
+export declare function vidstabdetect(opts?: VidstabdetectOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface VidstabtransformOpts {
+    input?: string;
+    smoothing?: number;
+    optalgo?: 'opt' | 'gauss' | 'avg';
+    maxshift?: number;
+    maxangle?: number;
+    crop?: 'keep' | 'black';
+    zoom?: number;
+    optzoom?: number;
+    interpol?: 'no' | 'linear' | 'bilinear' | 'bicubic';
+}
+export declare function vidstabtransform(opts?: VidstabtransformOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface VignetteOpts {
+    /** @range [0, 1.5707963267948966] */
+    angle?: number;
+}
+export declare function vignette(opts?: VignetteOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface WaveformOpts {
+    mode?: 'row' | 'column' | 'color' | 'color2' | 'acolor';
+    intensity?: number;
+    mirror?: number;
+}
+export declare function waveform(opts?: WaveformOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+export declare function yadif(): (input: Stream<'Video'>) => Stream<'Video'>;
+export interface ZoompanOpts {
+    z?: string;
+    x?: string;
+    y?: string;
+    d: number;
+    fps?: number;
+    s?: string;
+}
+export declare function zoompan(opts: ZoompanOpts): (input: Stream<'Video'>) => Stream<'Video'>;
+//# sourceMappingURL=video.d.ts.map