@omnimedia/omnitool/x/timeline/sugar/helpers.d.ts

open source video processing tools

import { TextStyleOptions } from "pixi.js";
import { O } from "./o.js";
import { Media } from "../parts/media.js";
import { TimelineFile } from "../parts/basics.js";
import { TransitionName } from "../parts/transitions.js";
import { filters, FilterParams, FilterType } from "../parts/filters.js";
import { CaptionOptions, CaptionSourceItem } from "../parts/captions.js";
import { Transcription } from "../../features/speech/transcribe/types.js";
import { AnimationPreset, PresetOptions } from "../parts/animations/types.js";
import { Crop, FilterableItem, Item, ItemBase, VisualAnimatableItem } from "../parts/item.js";
import { Anim, Interpolation, Keyframes, TrackTransform, Transform, Vec2, VisualAnimationInput, VisualAnimations } from "../types.js";
export type Build<T extends Item.Any = Item.Any> = (o: O) => T;
type BuildPresetAnimateActions = {
    [TKey in AnimationPreset]: BuildPresetAnimateAction;
};
type BuildTransitionActions = {
    [TKey in TransitionName]: (duration: number, options?: ItemBase) => Build<Item.Transition>;
};
type ContainerInput = [label: string, ...items: Build[]] | Build[];
export declare function timeline(root: Build): TimelineFile;
export declare function sequence(...input: ContainerInput): Build<Item.Sequence>;
export declare function stack(...input: ContainerInput): Build<Item.Stack>;
export declare function video(media: Media, options?: {
    start?: number;
    duration?: number;
    label?: string;
    enabled?: boolean;
}): Build<Item.Video>;
export declare function image(media: Media, options?: {
    duration?: number;
    label?: string;
    enabled?: boolean;
}): Build<Item.Image>;
export declare function audio(media: Media, options?: {
    start?: number;
    duration?: number;
    gain?: number;
    label?: string;
    enabled?: boolean;
}): Build<Item.Audio>;
export declare function text(content: string, options?: {
    duration?: number;
    styles?: TextStyleOptions;
    label?: string;
    enabled?: boolean;
}): Build<Item.Text>;
export declare function captions(item: Build<CaptionSourceItem>, transcript: Transcription, options?: CaptionOptions): Build<Item.Stack>;
export declare function gap(duration: number, options?: ItemBase): Build<Item.Gap>;
export declare function spatial(transform?: Transform, crop?: Crop): Build<Item.Spatial>;
export declare const anim: {
    scalar(terp: Interpolation, track: Keyframes): Anim<Keyframes>;
    vec2(terp: Interpolation, source: Keyframes<Vec2>): Anim<{
        x: Keyframes;
        y: Keyframes;
    }>;
    transform: (terp: Interpolation, source: Keyframes<Transform>) => Anim<TrackTransform>;
};
interface BuildFilterAction<TFilter extends FilterType> {
    <T extends FilterableItem>(item: Build<T>, params?: FilterParams<TFilter>): Build<T>;
    make(params?: FilterParams<TFilter>): Build<Item.Filter<TFilter>>;
}
interface BuildAnimateAction<TKey extends keyof VisualAnimations = keyof VisualAnimations> {
    <T extends VisualAnimatableItem>(item: Build<T>, terp: Interpolation, track: VisualAnimationInput<TKey>): Build<T>;
    make(terp: Interpolation, track: VisualAnimationInput<TKey>): Build<Item.Animation>;
}
interface BuildPresetAnimateAction {
    <T extends VisualAnimatableItem>(item: Build<T>, options?: PresetOptions): Build<T>;
    make(options?: PresetOptions): Build<Item.Animation>;
}
type BuildFilterActions = {
    [TName in keyof typeof filters]: BuildFilterAction<(typeof filters)[TName]["type"]>;
};
export declare const filter: BuildFilterActions;
export declare const animate: {
    presets: BuildPresetAnimateActions;
    opacity: BuildAnimateAction<"opacity">;
    transform: BuildAnimateAction<"transform">;
};
export declare function textStyle(style: TextStyleOptions): Build<Item.TextStyle>;
export declare const transition: BuildTransitionActions;
export {};