node-av 1.3.0 → 2.1.0

package/dist/api/filter-presets.d.ts

@@ -1,4 +1,5 @@
-import type { AVHWDeviceType, AVPixelFormat, AVSampleFormat } from '../constants/constants.js';
+import type { AVPixelFormat, AVSampleFormat } from '../constants/constants.js';
+import type { HardwareContext } from './hardware.js';
 /**
  * Hardware filter capabilities for different platforms.
  * Maps hardware types to their supported filter operations.
@@ -13,7 +14,7 @@ import type { AVHWDeviceType, AVPixelFormat, AVSampleFormat } from '../constants
  * - Vulkan: Cross-platform with growing filter support
  * - OpenCL: Cross-platform compute-based filtering
  */
-export interface HardwareFilterSupport {
+export interface FilterSupport {
     scale: boolean;
     overlay: boolean;
     transpose: boolean;
@@ -29,140 +30,333 @@ export interface HardwareFilterSupport {
     stack: boolean;
 }
 /**
- * Base class for filter preset implementations.
- * Provides common filter building methods that can be overridden by hardware-specific implementations.
- *
- * This class defines the standard filter operations available in FFmpeg,
- * with each method returning a filter string that can be used in a filter graph.
- * Hardware-specific implementations may override these methods to use optimized
- * hardware filters instead of software implementations.
+ * Filter preset builder for composing filter chains.
+ * Supports both software and hardware-accelerated filters.
+ * Automatically selects appropriate filter implementations based on hardware context.
+ * Uses fluent interface pattern for chaining multiple filters.
  *
  * @example
  * ```typescript
- * class CustomPresets extends FilterPresetBase {
- *   override scale(width: number, height: number): string | null {
- *     return `custom_scale=${width}:${height}`;
- *   }
- * }
+ * // Software filter chain
+ * const filter = FilterPreset.chain()
+ *   .scale(1920, 1080)
+ *   .fps(30)
+ *   .fade('in', 0, 2)
+ *   .build();
+ *
+ * // Hardware-accelerated filter chain
+ * const hw = HardwareContext.auto();
+ * const hwFilter = FilterPreset.chain(hw)
+ *   .scale(1920, 1080)
+ *   .blur('gaussian', 5)
+ *   .build();
  * ```
  */
-export declare abstract class FilterPresetBase {
+export declare class FilterPreset {
+    private hardware?;
+    private filters;
+    private support;
+    private constructor();
+    /**
+     * Checks if a filter is hardware-accelerated.
+     *
+     * @param filterName - Name of the filter to check
+     *
+     * @returns True if the filter uses hardware acceleration
+     *
+     * @example
+     * ```typescript
+     * if (FilterPreset.isHardwareFilter('scale_cuda')) {
+     *   console.log('Hardware accelerated scaling');
+     * }
+     * ```
+     */
+    static isHardwareFilter(filterName: string): boolean;
+    /**
+     * Creates a new filter chain builder.
+     *
+     * @param hardware - Optional hardware context for hardware-accelerated filters
+     *
+     * @returns A new FilterPreset instance for chaining
+     *
+     * @example
+     * ```typescript
+     * // Software filter chain
+     * const filter = FilterPreset.chain()
+     *   .scale(1280, 720)
+     *   .fps(30)
+     *   .build();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Hardware filter chain
+     * const hw = HardwareContext.auto();
+     * const filter = FilterPreset.chain(hw)
+     *   .scale(1280, 720)
+     *   .deinterlace()
+     *   .build();
+     * ```
+     */
+    static chain(hardware?: HardwareContext | null): FilterPreset;
+    /**
+     * Adds a custom filter string to the chain.
+     *
+     * @param filter - Custom filter string
+     *
+     * @returns This instance for chaining
+     *
+     * @example
+     * ```typescript
+     * chain.custom('myfilter=param1:param2')
+     * ```
+     */
+    custom(filter: string): this;
+    /**
+     * Builds the final filter string.
+     *
+     * @param separator - Separator between filters (default: ',')
+     *
+     * @returns Combined filter string
+     *
+     * @example
+     * ```typescript
+     * const filterString = chain.build()  // "scale=1920:1080,fps=30"
+     * ```
+     */
+    build(separator?: string): string;
+    /**
+     * Returns the filters as an array.
+     *
+     * @returns Array of filter strings
+     *
+     * @example
+     * ```typescript
+     * const filters = chain.toArray()  // ["scale=1920:1080", "fps=30"]
+     * ```
+     */
+    toArray(): string[];
     /**
-     * Creates a scale filter string.
+     * Adds a scale filter to the chain.
+     * Automatically selects hardware-specific scaler if hardware context is set.
      *
      * @param width - Target width in pixels
+     *
      * @param height - Target height in pixels
-     * @param options - Additional scaling options (e.g., flags for algorithm)
-     * @returns Filter string or null if not supported
+     *
+     * @param options - Additional scaling options (e.g., flags for algorithm, npp for CUDA)
+     *
+     * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * presets.scale(1920, 1080)  // Scale to Full HD
-     * presets.scale(640, 480, { flags: 'lanczos' })  // With specific algorithm
+     * chain.scale(1920, 1080)  // Scale to Full HD
+     * chain.scale(640, 480, { flags: 'lanczos' })  // With specific algorithm
+     * chain.scale(1920, 1080, { npp: true })  // Use NPP for CUDA
      * ```
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#scale | FFmpeg scale filter}
      */
-    scale(width: number, height: number, options?: Record<string, any>): string | null;
+    scale(width: number, height: number, options?: Record<string, any>): FilterPreset;
     /**
-     * Creates a crop filter string.
+     * Adds a crop filter to the chain.
      *
      * @param width - Width of the cropped area
+     *
      * @param height - Height of the cropped area
+     *
      * @param x - X coordinate of top-left corner (default: 0)
+     *
      * @param y - Y coordinate of top-left corner (default: 0)
-     * @returns Filter string or null if not supported
+     *
+     * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * presets.crop(640, 480, 100, 100)  // Crop 640x480 area starting at (100,100)
-     * presets.crop(1280, 720)  // Crop from top-left corner
+     * chain.crop(640, 480, 100, 100)  // Crop 640x480 area starting at (100,100)
+     * chain.crop(1280, 720)  // Crop from top-left corner
      * ```
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#crop | FFmpeg crop filter}
      */
-    crop(width: number, height: number, x?: number, y?: number): string | null;
+    crop(width: number, height: number, x?: number, y?: number): FilterPreset;
+    /**
+     * Adds a blur filter to the chain (hardware-specific).
+     * Only available for hardware presets that support blur
+     *
+     * @param type - Blur type (default: 'avg')
+     *
+     * @param radius - Blur radius (optional)
+     *
+     * @returns This instance for chaining
+     *
+     * @example
+     * ```typescript
+     * const chain = FilterPresets.chain()
+     *   .blur('gaussian', 5)
+     *   .build();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * const chain = FilterPresets.chain()
+     *   .blur('box')
+     *   .build();
+     * ```
+     */
+    blur(type?: 'avg' | 'gaussian' | 'box', radius?: number): FilterPreset;
+    /**
+     * Adds a sharpen filter to the chain (hardware-specific).
+     * Only available for hardware presets that support sharpening
+     *
+     * @param amount - Sharpen amount (optional)
+     *
+     * @returns This instance for chaining
+     *
+     * @example
+     * ```typescript
+     * const chain = FilterPresets.chain()
+     *   .sharpen(1.5)
+     *   .build();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * const chain = FilterPresets.chain()
+     *   .sharpen()
+     *   .build();
+     * ```
+     */
+    sharpen(amount?: number): FilterPreset;
     /**
-     * Creates an FPS filter string to change frame rate.
+     * Adds an FPS filter to change frame rate.
      *
      * @param fps - Target frames per second
-     * @returns Filter string or null if not supported
+     *
+     * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * presets.fps(30)  // Convert to 30 FPS
-     * presets.fps(23.976)  // Film frame rate
+     * chain.fps(30)  // Convert to 30 FPS
+     * chain.fps(23.976)  // Film frame rate
      * ```
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#fps | FFmpeg fps filter}
      */
-    fps(fps: number): string | null;
+    fps(fps: number): FilterPreset;
     /**
-     * Creates a format filter string to convert pixel format.
+     * Adds a format filter to convert pixel format.
      *
-     * @param pixelFormat - Target pixel format(s) - can be string, AVPixelFormat enum, or array
-     * @returns Filter string or null if not supported
+     * @param pixelFormat - Target pixel format(s) - AVPixelFormat enum, or array
+     *
+     * @returns This instance for chaining
      *
      * @example
      * ```typescript
      * // Single format
-     * presets.format('yuv420p');
-     * presets.format(AV_PIX_FMT_YUV420P);
+     * chain.format(AV_PIX_FMT_YUV420P);
      *
-     * // Multiple formats (creates a chain)
-     * presets.format(['yuv420p', 'rgb24']);
+     * // Multiple formats (tries formats in order)
+     * chain.format([AV_PIX_FMT_YUV420P, AV_PIX_FMT_RGB24]);
      * ```
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#format | FFmpeg format filter}
      */
-    format(pixelFormat: string | AVPixelFormat | (string | AVPixelFormat)[]): string | null;
+    format(pixelFormat: AVPixelFormat | AVPixelFormat[]): FilterPreset;
     /**
-     * Creates a rotate filter string.
+     * Adds a rotate filter to the chain.
      *
      * @param angle - Rotation angle in degrees
-     * @returns Filter string or null if not supported
+     *
+     * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * presets.rotate(90)  // Rotate 90 degrees clockwise
-     * presets.rotate(-45)  // Rotate 45 degrees counter-clockwise
+     * chain.rotate(90)  // Rotate 90 degrees clockwise
+     * chain.rotate(-45)  // Rotate 45 degrees counter-clockwise
      * ```
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#rotate | FFmpeg rotate filter}
      */
-    rotate(angle: number): string | null;
+    rotate(angle: number): FilterPreset;
     /**
-     * Creates a horizontal flip filter string.
+     * Adds a flip filter to the chain (hardware-specific).
+     * Falls back to hflip/vflip if hardware flip not available
      *
-     * @returns Filter string or null if not supported
+     * @param direction - Flip direction ('h' or 'v')
+     *
+     * @returns This instance for chaining
+     *
+     * @example
+     * ```typescript
+     * const chain = FilterPresets.chain()
+     *   .flip('h')
+     *   .build();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * const chain = FilterPresets.chain()
+     *   .flip('v')
+     *   .build();
+     * ```
+     */
+    flip(direction: 'h' | 'v'): FilterPreset;
+    /**
+     * Adds a stack filter to the chain (hardware-specific).
+     * Only available for hardware presets that support stacking
+     *
+     * @param type - Stack type ('h' for horizontal, 'v' for vertical, 'x' for grid)
+     *
+     * @param inputs - Number of inputs (default: 2)
+     *
+     * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * presets.hflip()  // Mirror horizontally
+     * const chain = FilterPresets.chain()
+     *   .stack('h', 2)
+     *   .build();
      * ```
      *
-     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#hflip | FFmpeg hflip filter}
+     * @example
+     * ```typescript
+     * const chain = FilterPresets.chain()
+     *   .stack('x', 4)
+     *   .build();
+     * ```
      */
-    hflip(): string | null;
+    stack(type: 'h' | 'v' | 'x', inputs?: number): FilterPreset;
     /**
-     * Creates a vertical flip filter string.
+     * Creates a tonemap filter.
+     * Used for HDR to SDR conversion with hardware acceleration.
      *
-     * @returns Filter string or null if not supported
+     * @param alg - Tonemapping algorithm (e.g., 'hable', 'reinhard', 'mobius', etc.)
+     *
+     * @param options - Tonemapping options
+     *
+     * @returns Hardware tonemap filter string or null if not supported
      *
      * @example
      * ```typescript
-     * presets.vflip()  // Flip upside down
+     * const filter = hwPresets.tonemap();
      * ```
      *
-     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#vflip | FFmpeg vflip filter}
+     * @example
+     * ```typescript
+     * const filter = hwPresets.tonemap({ tonemap: 'hable', desat: '0' });
+     * ```
      */
-    vflip(): string | null;
+    tonemap(alg: string, options: Record<string, string | number>): FilterPreset;
     /**
      * Creates a fade filter string for video.
      *
      * @param type - Fade type ('in' or 'out')
+     *
      * @param start - Start time in seconds
+     *
      * @param duration - Fade duration in seconds
+     *
      * @returns Filter string or null if not supported
      *
      * @example
@@ -173,13 +367,16 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#fade | FFmpeg fade filter}
      */
-    fade(type: 'in' | 'out', start: number, duration: number): string | null;
+    fade(type: 'in' | 'out', start: number, duration: number): FilterPreset;
     /**
      * Creates an overlay filter string to composite two video streams.
      *
      * @param x - X position for overlay (default: 0)
+     *
      * @param y - Y position for overlay (default: 0)
+     *
      * @param options - Additional overlay options
+     *
      * @returns Filter string or null if not supported
      *
      * @example
@@ -193,11 +390,12 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#overlay | FFmpeg overlay filter}
      */
-    overlay(x?: number, y?: number, options?: Record<string, string>): string | null;
+    overlay(x?: number, y?: number, options?: Record<string, string>): FilterPreset;
     /**
      * Creates a volume filter string for audio.
      *
      * @param factor - Volume multiplication factor (1.0 = unchanged, 2.0 = double)
+     *
      * @returns Filter string or null if not supported
      *
      * @example
@@ -208,13 +406,16 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#volume | FFmpeg volume filter}
      */
-    volume(factor: number): string | null;
+    volume(factor: number): FilterPreset;
     /**
      * Creates an audio format filter string.
      *
      * @param sampleFormat - Target sample format (e.g., 's16', 'fltp')
+     *
      * @param sampleRate - Target sample rate in Hz (optional)
+     *
      * @param channelLayout - Target channel layout (optional)
+     *
      * @returns Filter string or null if not supported
      *
      * @example
@@ -231,122 +432,155 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#aformat | FFmpeg aformat filter}
      */
-    aformat(sampleFormat: string | AVSampleFormat, sampleRate?: number, channelLayout?: string): string | null;
+    aformat(sampleFormat: AVSampleFormat | AVSampleFormat[], sampleRate?: number, channelLayout?: string): FilterPreset;
     /**
-     * Creates an asetnsamples filter string to set the number of samples per frame.
+     * Adds an asetnsamples filter to set the number of samples per frame.
      * This is crucial for encoders like Opus that require specific frame sizes.
      *
      * @param samples - Number of samples per frame
+     *
      * @param padding - Whether to pad or drop samples (default: true)
-     * @returns Filter string or null if not supported
+     *
+     * @returns This instance for chaining
      *
      * @example
      * ```typescript
      * // For Opus encoder (requires 960 samples)
-     * presets.asetnsamples(960);
+     * chain.asetnsamples(960);
      *
      * // Drop samples instead of padding
-     * presets.asetnsamples(1024, false);
+     * chain.asetnsamples(1024, false);
      * ```
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#asetnsamples | FFmpeg asetnsamples filter}
      */
-    asetnsamples(samples: number, padding?: boolean): string | null;
+    asetnsamples(samples: number, padding?: boolean): FilterPreset;
+    /**
+     * Adds an aresample filter to change audio sample rate.
+     *
+     * @param rate - Target sample rate in Hz
+     *
+     * @returns This instance for chaining
+     *
+     * @example
+     * ```typescript
+     * chain.aresample(44100)  // Convert to 44.1 kHz
+     * chain.aresample(48000)  // Convert to 48 kHz
+     * ```
+     *
+     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#aresample | FFmpeg aresample filter}
+     */
+    aresample(rate: number): FilterPreset;
     /**
-     * Creates an atempo filter string to change audio playback speed.
+     * Adds an atempo filter to change audio playback speed.
      * Factor must be between 0.5 and 2.0. For larger changes, chain multiple atempo filters.
      *
      * @param factor - Tempo factor (0.5 = half speed, 2.0 = double speed)
-     * @returns Filter string or null if not supported
+     *
+     * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * presets.atempo(1.5)  // 1.5x speed
-     * presets.atempo(0.8)  // Slow down to 80% speed
+     * chain.atempo(1.5)  // 1.5x speed
+     * chain.atempo(0.8)  // Slow down to 80% speed
      * ```
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#atempo | FFmpeg atempo filter}
      */
-    atempo(factor: number): string | null;
+    atempo(factor: number): FilterPreset;
     /**
-     * Creates an audio fade filter string.
+     * Adds an audio fade filter.
      *
      * @param type - Fade type ('in' or 'out')
+     *
      * @param start - Start time in seconds
+     *
      * @param duration - Fade duration in seconds
-     * @returns Filter string or null if not supported
+     *
+     * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * presets.afade('in', 0, 3)  // 3-second audio fade in
-     * presets.afade('out', 20, 2)  // 2-second fade out at 20s
+     * chain.afade('in', 0, 3)  // 3-second audio fade in
+     * chain.afade('out', 20, 2)  // 2-second fade out at 20s
      * ```
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#afade | FFmpeg afade filter}
      */
-    afade(type: 'in' | 'out', start: number, duration: number): string | null;
+    afade(type: 'in' | 'out', start: number, duration: number): FilterPreset;
     /**
-     * Creates an amix filter string to mix multiple audio streams.
+     * Adds an amix filter to mix multiple audio streams.
      *
      * @param inputs - Number of input streams to mix (default: 2)
+     *
      * @param duration - How to determine output duration (default: 'longest')
-     * @returns Filter string or null if not supported
+     *
+     * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * presets.amix(3, 'longest')  // Mix 3 audio streams
-     * presets.amix(2, 'first')  // Mix 2 streams, use first's duration
+     * chain.amix(3, 'longest')  // Mix 3 audio streams
+     * chain.amix(2, 'first')  // Mix 2 streams, use first's duration
      * ```
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#amix | FFmpeg amix filter}
      */
-    amix(inputs?: number, duration?: 'first' | 'longest' | 'shortest'): string | null;
+    amix(inputs?: number, duration?: 'first' | 'longest' | 'shortest'): FilterPreset;
     /**
-     * Creates a pad filter string to add padding to video.
+     * Adds a pad filter to add padding to video.
      * Essential for aspect ratio adjustments and letterboxing.
      *
      * @param width - Output width (can use expressions like 'iw+100')
+     *
      * @param height - Output height (can use expressions like 'ih+100')
+     *
      * @param x - X position of input video (default: '(ow-iw)/2' for center)
+     *
      * @param y - Y position of input video (default: '(oh-ih)/2' for center)
+     *
      * @param color - Padding color (default: 'black')
-     * @returns Filter string or null if not supported
+     *
+     * @returns This instance for chaining
      *
      * @example
      * ```typescript
      * // Add black bars for 16:9 aspect ratio
-     * presets.pad('iw', 'iw*9/16');
+     * chain.pad('iw', 'iw*9/16');
      *
      * // Add 50px padding on all sides
-     * presets.pad('iw+100', 'ih+100');
+     * chain.pad('iw+100', 'ih+100');
      * ```
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#pad | FFmpeg pad filter}
      */
-    pad(width: string | number, height: string | number, x?: string, y?: string, color?: string): string | null;
+    pad(width: string | number, height: string | number, x?: string, y?: string, color?: string): FilterPreset;
     /**
-     * Creates a trim filter string to cut a portion of the stream.
+     * Adds a trim filter to cut a portion of the stream.
      * Crucial for cutting segments from media.
      *
      * @param start - Start time in seconds
+     *
      * @param end - End time in seconds (optional)
+     *
      * @param duration - Duration in seconds (optional, alternative to end)
-     * @returns Filter string or null if not supported
+     *
+     * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * presets.trim(10, 30)  // Extract from 10s to 30s
-     * presets.trim(5, undefined, 10)  // Extract 10s starting at 5s
+     * chain.trim(10, 30)  // Extract from 10s to 30s
+     * chain.trim(5, undefined, 10)  // Extract 10s starting at 5s
      * ```
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#trim | FFmpeg trim filter}
      */
-    trim(start: number, end?: number, duration?: number): string | null;
+    trim(start: number, end?: number, duration?: number): FilterPreset;
     /**
      * Creates a setpts filter string to change presentation timestamps.
      * Essential for speed changes and timestamp manipulation.
      *
      * @param expression - PTS expression (e.g., 'PTS*2' for half speed, 'PTS/2' for double speed)
+     *
      * @returns Filter string or null if not supported
      *
      * @example
@@ -363,11 +597,12 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#setpts | FFmpeg setpts filter}
      */
-    setpts(expression: string): string | null;
+    setpts(expression: string): FilterPreset;
     /**
      * Creates an asetpts filter string for audio timestamp manipulation.
      *
      * @param expression - PTS expression
+     *
      * @returns Filter string or null if not supported
      *
      * @example
@@ -377,12 +612,13 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#asetpts | FFmpeg asetpts filter}
      */
-    asetpts(expression: string): string | null;
+    asetpts(expression: string): FilterPreset;
     /**
      * Creates a transpose filter string for rotation/flipping.
      * More efficient than rotate for 90-degree rotations.
      *
      * @param mode - Transpose mode (0-3, or named constants)
+     *
      * @returns Filter string or null if not supported
      *
      * @example
@@ -393,12 +629,13 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#transpose | FFmpeg transpose filter}
      */
-    transpose(mode: number | 'clock' | 'cclock' | 'clock_flip' | 'cclock_flip'): string | null;
+    transpose(mode: number | 'clock' | 'cclock' | 'clock_flip' | 'cclock_flip'): FilterPreset;
     /**
      * Creates a setsar filter string to set sample aspect ratio.
      * Important for correcting aspect ratio issues.
      *
      * @param ratio - Aspect ratio (e.g., '1:1', '16:9', or number)
+     *
      * @returns Filter string or null if not supported
      *
      * @example
@@ -409,11 +646,12 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#setsar | FFmpeg setsar/setdar filter}
      */
-    setsar(ratio: string | number): string | null;
+    setsar(ratio: string | number): FilterPreset;
     /**
      * Creates a setdar filter string to set display aspect ratio.
      *
      * @param ratio - Aspect ratio (e.g., '16:9', '4:3')
+     *
      * @returns Filter string or null if not supported
      *
      * @example
@@ -424,30 +662,35 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#setsar | FFmpeg setsar/setdar filter}
      */
-    setdar(ratio: string | number): string | null;
+    setdar(ratio: string | number): FilterPreset;
     /**
-     * Creates an apad filter string to add audio padding.
+     * Adds an apad filter to add audio padding.
      * Useful for ensuring minimum audio duration.
      *
      * @param wholeDuration - Minimum duration in seconds (optional)
+     *
      * @param padDuration - Amount of padding to add in seconds (optional)
-     * @returns Filter string or null if not supported
+     *
+     * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * presets.apad(30)  // Ensure at least 30 seconds total
-     * presets.apad(undefined, 5)  // Add 5 seconds of padding
+     * chain.apad(30)  // Ensure at least 30 seconds total
+     * chain.apad(undefined, 5)  // Add 5 seconds of padding
      * ```
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#apad | FFmpeg apad filter}
      */
-    apad(wholeDuration?: number, padDuration?: number): string | null;
+    apad(wholeDuration?: number, padDuration?: number): FilterPreset;
     /**
      * Creates a deinterlace filter string.
      * Essential for processing interlaced content.
      *
      * @param mode - Deinterlace mode (default: 'yadif')
-     * @returns Filter string or null if not supported
+     *
+     * @param options - Additional options for the filter
+     *
+     * @returns Filter string or null if not supported
      *
      * @example
      * ```typescript
@@ -457,12 +700,13 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#yadif | FFmpeg yadif filter}
      */
-    deinterlace(mode?: 'yadif' | 'bwdif' | 'w3fdif'): string | null;
+    deinterlace(mode?: 'yadif' | 'bwdif' | 'w3fdif', options?: Record<string, any>): FilterPreset;
     /**
      * Creates a select filter string to select specific frames.
      * Powerful for extracting keyframes, specific frame types, etc.
      *
      * @param expression - Selection expression
+     *
      * @returns Filter string or null if not supported
      *
      * @example
@@ -473,11 +717,12 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#select | FFmpeg select filter}
      */
-    select(expression: string): string | null;
+    select(expression: string): FilterPreset;
     /**
      * Creates an aselect filter string for audio selection.
      *
      * @param expression - Selection expression
+     *
      * @returns Filter string or null if not supported
      *
      * @example
@@ -487,14 +732,17 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#aselect | FFmpeg aselect filter}
      */
-    aselect(expression: string): string | null;
+    aselect(expression: string): FilterPreset;
     /**
      * Creates a concat filter string to concatenate multiple inputs.
      * Essential for joining multiple video/audio segments.
      *
      * @param n - Number of input segments
+     *
      * @param v - Number of output video streams (0 or 1)
+     *
      * @param a - Number of output audio streams (0 or 1)
+     *
      * @returns Filter string or null if not supported
      *
      * @example
@@ -505,12 +753,13 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#concat | FFmpeg concat filter}
      */
-    concat(n: number, v?: number, a?: number): string | null;
+    concat(n: number, v?: number, a?: number): FilterPreset;
     /**
      * Creates an amerge filter string to merge multiple audio streams into one.
      * Different from amix - this creates multi-channel output.
      *
      * @param inputs - Number of input streams
+     *
      * @returns Filter string or null if not supported
      *
      * @example
@@ -521,12 +770,13 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#amerge | FFmpeg amerge filter}
      */
-    amerge(inputs?: number): string | null;
+    amerge(inputs?: number): FilterPreset;
     /**
      * Creates a channelmap filter string to remap audio channels.
      * Critical for audio channel manipulation.
      *
      * @param map - Channel mapping (e.g., '0-0|1-1' or 'FL-FR|FR-FL' to swap stereo)
+     *
      * @returns Filter string or null if not supported
      *
      * @example
@@ -537,11 +787,12 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#channelmap | FFmpeg channelmap filter}
      */
-    channelmap(map: string): string | null;
+    channelmap(map: string): FilterPreset;
     /**
      * Creates a channelsplit filter string to split audio channels.
      *
      * @param channelLayout - Channel layout to split (optional)
+     *
      * @returns Filter string or null if not supported
      *
      * @example
@@ -552,14 +803,17 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#channelsplit | FFmpeg channelsplit filter}
      */
-    channelsplit(channelLayout?: string): string | null;
+    channelsplit(channelLayout?: string): FilterPreset;
     /**
      * Creates a loudnorm filter string for loudness normalization.
      * Essential for broadcast compliance and consistent audio levels.
      *
      * @param I - Integrated loudness target (default: -24 LUFS)
+     *
      * @param TP - True peak (default: -2 dBTP)
+     *
      * @param LRA - Loudness range (default: 7 LU)
+     *
      * @returns Filter string or null if not supported
      *
      * @example
@@ -570,15 +824,19 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#loudnorm | FFmpeg loudnorm filter}
      */
-    loudnorm(I?: number, TP?: number, LRA?: number): string | null;
+    loudnorm(I?: number, TP?: number, LRA?: number): FilterPreset;
     /**
      * Creates a compand filter string for audio compression/expansion.
      * Important for dynamic range control.
      *
      * @param attacks - Attack times
+     *
      * @param decays - Decay times
+     *
      * @param points - Transfer function points
+     *
      * @param gain - Output gain
+     *
      * @returns Filter string or null if not supported
      *
      * @example
@@ -588,1577 +846,285 @@ export declare abstract class FilterPresetBase {
      *
      * @see {@link https://ffmpeg.org/ffmpeg-filters.html#compand | FFmpeg compand filter}
      */
-    compand(attacks: string, decays: string, points: string, gain?: number): string | null;
-}
-/**
- * Filter chain builder for composing multiple filters.
- * Allows fluent API for building complex filter graphs by chaining filter operations.
- *
- * @example
- * ```typescript
- * const chain = new FilterChain()
- *   .add('scale=1920:1080')
- *   .add('fps=30')
- *   .custom('rotate=45*PI/180')
- *   .build();
- * // Result: "scale=1920:1080,fps=30,rotate=45*PI/180"
- * ```
- */
-export declare class FilterChain {
-    private filters;
+    compand(attacks: string, decays: string, points: string, gain?: number): FilterPreset;
     /**
-     * Adds a filter to the chain.
+     * Adds a drawtext filter to overlay text on video.
      *
-     * @param filter - Filter string to add (ignored if null/undefined)
-     * @returns This instance for chaining
+     * @param text - Text to display
      *
-     * @example
-     * ```typescript
-     * chain.add('scale=1920:1080')
-     * ```
-     */
-    add(filter: string | null | undefined): this;
-    /**
-     * Adds a custom filter string to the chain.
+     * @param options - Text rendering options
      *
-     * @param filter - Custom filter string
      * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * chain.custom('myfilter=param1:param2')
-     * ```
-     */
-    custom(filter: string): this;
-    /**
-     * Builds the final filter string.
-     *
-     * @param separator - Separator between filters (default: ',')
-     * @returns Combined filter string
-     *
-     * @example
-     * ```typescript
-     * const filterString = chain.build()  // "scale=1920:1080,fps=30"
+     * chain.drawtext('Hello World', { x: 10, y: 10, fontsize: 24 })
+     * chain.drawtext('Timestamp', {
+     *   x: 10,
+     *   y: 10,
+     *   fontsize: 24,
+     *   fontcolor: 'white',
+     *   fontfile: '/path/to/font.ttf'
+     * })
      * ```
-     */
-    build(separator?: string): string;
-    /**
-     * Returns the filters as an array.
-     *
-     * @returns Array of filter strings
      *
-     * @example
-     * ```typescript
-     * const filters = chain.toArray()  // ["scale=1920:1080", "fps=30"]
-     * ```
-     */
-    toArray(): string[];
-}
-/**
- * Base chain builder with common filter methods.
- * Provides a fluent API for building filter chains using preset methods.
- *
- * @template T The preset type this builder uses
- *
- * @example
- * ```typescript
- * const chain = new ChainBuilderBase(presets)
- *   .scale(1920, 1080)
- *   .fps(30)
- *   .fade('in', 0, 2)
- *   .build();
- * ```
- */
-export declare abstract class ChainBuilderBase<T extends FilterPresetBase> extends FilterChain {
-    protected readonly presets: T;
-    /**
-     * @param presets - The filter presets to use
-     * @internal
+     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#drawtext | FFmpeg drawtext filter}
      */
-    constructor(presets: T);
+    drawtext(text: string, options: Record<string, any>): FilterPreset;
     /**
-     * Adds a scale filter to the chain.
+     * Adds a split filter to duplicate a video stream.
      *
-     * @param width - Target width
-     * @param height - Target height
-     * @param options - Additional scaling options
+     * @param outputs - Number of output streams (default: 2)
      *
      * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .scale(1920, 1080)
-     *   .build();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .scale(1280, 720, { flags: 'lanczos' })
-     *   .build();
+     * chain.split()    // Split into 2 outputs
+     * chain.split(3)   // Split into 3 outputs
      * ```
      *
-     * @see {@link FilterPresetBase.scale}
+     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#split | FFmpeg split filter}
      */
-    scale(width: number, height: number, options?: Record<string, any>): this;
+    split(outputs?: number): FilterPreset;
     /**
-     * Adds a crop filter to the chain.
+     * Adds an asplit filter to duplicate an audio stream.
      *
-     * @param width - Crop width
-     * @param height - Crop height
-     * @param x - X position (default: 0)
-     * @param y - Y position (default: 0)
+     * @param outputs - Number of output streams (default: 2)
      *
      * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .crop(640, 480)
-     *   .build();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .crop(1920, 1080, 100, 50)
-     *   .build();
+     * chain.asplit()   // Split into 2 outputs
+     * chain.asplit(3)  // Split into 3 outputs
      * ```
      *
-     * @see {@link FilterPresetBase.crop}
+     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#asplit | FFmpeg asplit filter}
      */
-    crop(width: number, height: number, x?: number, y?: number): this;
+    asplit(outputs?: number): FilterPreset;
     /**
-     * Adds an FPS filter to the chain.
+     * Adds an adelay filter to delay audio by specified milliseconds.
      *
-     * @param fps - Target frame rate
+     * @param delays - Delay in milliseconds (single value or array for multiple channels)
      *
      * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .fps(30)
-     *   .build();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .fps(23.976)
-     *   .build();
+     * chain.adelay(100)        // Delay all channels by 100ms
+     * chain.adelay([100, 200]) // Delay first channel by 100ms, second by 200ms
      * ```
      *
-     * @see {@link FilterPresetBase.fps}
+     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#adelay | FFmpeg adelay filter}
      */
-    fps(fps: number): this;
+    adelay(delays: number | number[]): FilterPreset;
     /**
-     * Adds a format filter to the chain.
-     *
-     * @param pixelFormat - Target pixel format(s)
-     *
-     * @returns This instance for chaining
+     * Adds an aecho filter for audio echo effect.
      *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .format('yuv420p')
-     *   .build();
-     * ```
+     * @param in_gain - Input gain (0-1)
      *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .format(AV_PIX_FMT_RGB24)
-     *   .build();
-     * ```
+     * @param out_gain - Output gain (0-1)
      *
-     * @see {@link FilterPresetBase.format}
-     */
-    format(pixelFormat: string | AVPixelFormat | (string | AVPixelFormat)[]): this;
-    /**
-     * Adds a rotate filter to the chain.
+     * @param delays - Delay in milliseconds
      *
-     * @param angle - Rotation angle in degrees
+     * @param decays - Decay factor (0-1)
      *
      * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .rotate(45)
-     *   .build();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .rotate(-90)
-     *   .build();
+     * chain.aecho(0.8, 0.9, 1000, 0.3)  // Echo with 1 second delay
      * ```
      *
-     * @see {@link FilterPresetBase.rotate}
+     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#aecho | FFmpeg aecho filter}
      */
-    rotate(angle: number): this;
+    aecho(in_gain: number, out_gain: number, delays: number, decays: number): FilterPreset;
     /**
-     * Adds a horizontal flip filter to the chain.
-     *
-     * @returns This instance for chaining
+     * Adds a highpass filter to remove low frequencies.
      *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .hflip()
-     *   .build();
-     * ```
+     * @param frequency - Cutoff frequency in Hz
      *
-     * @see {@link FilterPresetBase.hflip}
-     */
-    hflip(): this;
-    /**
-     * Adds a vertical flip filter to the chain.
+     * @param options - Additional filter options
      *
      * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .vflip()
-     *   .build();
+     * chain.highpass(200)  // Remove frequencies below 200Hz
+     * chain.highpass(200, { width_type: 'q', width: 1 })
      * ```
      *
-     * @see {@link FilterPresetBase.vflip}
+     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#highpass | FFmpeg highpass filter}
      */
-    vflip(): this;
+    highpass(frequency: number, options?: Record<string, any>): FilterPreset;
     /**
-     * Adds a fade filter to the chain.
+     * Adds a lowpass filter to remove high frequencies.
      *
-     * @param type - Fade type ('in' or 'out')
-     * @param start - Start time in seconds
-     * @param duration - Fade duration in seconds
+     * @param frequency - Cutoff frequency in Hz
      *
-     * @returns This instance for chaining
+     * @param options - Additional filter options
      *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .fade('in', 0, 2)
-     *   .build();
-     * ```
+     * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .fade('out', 10, 1.5)
-     *   .build();
+     * chain.lowpass(5000)  // Remove frequencies above 5000Hz
      * ```
      *
-     * @see {@link FilterPresetBase.fade}
+     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#lowpass | FFmpeg lowpass filter}
      */
-    fade(type: 'in' | 'out', start: number, duration: number): this;
+    lowpass(frequency: number, options?: Record<string, any>): FilterPreset;
     /**
-     * Adds an overlay filter to the chain.
+     * Adds a bandpass filter to keep only a frequency band.
      *
-     * @param x - X position (default: 0)
-     * @param y - Y position (default: 0)
-     * @param options - Additional overlay options
+     * @param frequency - Center frequency in Hz
      *
-     * @returns This instance for chaining
+     * @param options - Additional filter options
      *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .overlay(100, 50)
-     *   .build();
-     * ```
+     * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .overlay(10, 10, { enable: 'between(t,5,10)' })
-     *   .build();
+     * chain.bandpass(1000)  // Keep frequencies around 1000Hz
      * ```
      *
-     * @see {@link FilterPresetBase.overlay}
+     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#bandpass | FFmpeg bandpass filter}
      */
-    overlay(x?: number, y?: number, options?: Record<string, string>): this;
+    bandpass(frequency: number, options?: Record<string, any>): FilterPreset;
     /**
-     * Adds a volume filter to the chain.
+     * Adds an equalizer filter for frequency band adjustment.
      *
-     * @param factor - Volume factor
+     * @param frequency - Center frequency in Hz
      *
-     * @returns This instance for chaining
+     * @param width - Band width
      *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .volume(0.5)
-     *   .build();
-     * ```
+     * @param gain - Gain in dB
+     *
+     * @param width_type - Width type (optional)
+     *
+     * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .volume(2.0)
-     *   .build();
+     * chain.equalizer(1000, 2, 5)        // Boost 1000Hz by 5dB
+     * chain.equalizer(1000, 2, 5, 'q')   // Use Q factor for width
      * ```
      *
-     * @see {@link FilterPresetBase.volume}
+     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#equalizer | FFmpeg equalizer filter}
      */
-    volume(factor: number): this;
+    equalizer(frequency: number, width: number, gain: number, width_type?: string): FilterPreset;
     /**
-     * Adds an audio format filter to the chain.
+     * Adds a compressor filter for dynamic range compression.
      *
-     * @param sampleFormat - Target sample format
-     * @param sampleRate - Target sample rate (optional)
-     * @param channelLayout - Target channel layout (optional)
+     * @param options - Compressor parameters
      *
      * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .aformat(AV_SAMPLE_FMT_FLT, 48000, 'stereo')
-     *   .build();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .aformat('s16', 44100)
-     *   .build();
+     * chain.compressor()  // Default compression
+     * chain.compressor({
+     *   threshold: 0.5,
+     *   ratio: 4,
+     *   attack: 5,
+     *   release: 50
+     * })
      * ```
      *
-     * @see {@link FilterPresetBase.aformat}
+     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#acompressor | FFmpeg acompressor filter}
      */
-    aformat(sampleFormat: string | AVSampleFormat, sampleRate?: number, channelLayout?: string): this;
+    compressor(options?: Record<string, any>): FilterPreset;
     /**
-     * Adds an asetnsamples filter to the chain.
+     * Adds an atrim filter to trim audio.
      *
-     * @param samples - Number of samples per frame
-     * @param padding - Whether to pad or drop samples (default: true)
+     * @param start - Start time in seconds
      *
-     * @returns This instance for chaining
+     * @param end - End time in seconds (optional)
      *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .asetnsamples(960)
-     *   .build();
-     * ```
+     * @param duration - Duration in seconds (optional)
+     *
+     * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .asetnsamples(1024, false)
-     *   .build();
+     * chain.atrim(10, 20)  // Extract audio from 10s to 20s
      * ```
      *
-     * @see {@link FilterPresetBase.asetnsamples}
+     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#atrim | FFmpeg atrim filter}
      */
-    asetnsamples(samples: number, padding?: boolean): this;
+    atrim(start: number, end?: number, duration?: number): FilterPreset;
     /**
-     * Adds an atempo filter to the chain.
-     *
-     * @param factor - Tempo factor (0.5 to 2.0)
+     * Adds a hwupload filter to upload frames to hardware.
      *
      * @returns This instance for chaining
      *
      * @example
      * ```typescript
      * const chain = FilterPresets.chain()
-     *   .atempo(1.5)
-     *   .build();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .atempo(0.8)
+     *   .hwupload()
+     *   .scale(1920, 1080)
      *   .build();
      * ```
-     *
-     * @see {@link FilterPresetBase.atempo}
      */
-    atempo(factor: number): this;
+    hwupload(): FilterPreset;
     /**
-     * Adds an audio fade filter to the chain.
-     *
-     * @param type - Fade type ('in' or 'out')
-     * @param start - Start time in seconds
-     * @param duration - Fade duration in seconds
+     * Adds a hwdownload filter to download frames from hardware.
      *
      * @returns This instance for chaining
      *
      * @example
      * ```typescript
      * const chain = FilterPresets.chain()
-     *   .afade('in', 0, 3)
-     *   .build();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .afade('out', 25, 2)
+     *   .scale(1920, 1080)
+     *   .hwdownload()
      *   .build();
      * ```
-     *
-     * @see {@link FilterPresetBase.afade}
      */
-    afade(type: 'in' | 'out', start: number, duration: number): this;
+    hwdownload(): FilterPreset;
     /**
-     * Adds an amix filter to the chain.
+     * Adds a hwmap filter to map frames between hardware devices.
      *
-     * @param inputs - Number of inputs (default: 2)
-     * @param duration - Duration mode (default: 'longest')
+     * @param derive - Device to derive from (optional)
      *
      * @returns This instance for chaining
      *
      * @example
      * ```typescript
      * const chain = FilterPresets.chain()
-     *   .amix(3, 'longest')
+     *   .hwmap('cuda')
      *   .build();
      * ```
      *
      * @example
      * ```typescript
      * const chain = FilterPresets.chain()
-     *   .amix(2, 'first')
+     *   .hwmap()
      *   .build();
      * ```
-     *
-     * @see {@link FilterPresetBase.amix}
-     */
-    amix(inputs?: number, duration?: 'first' | 'longest' | 'shortest'): this;
-    /**
-     * Adds a pad filter to the chain.
-     *
-     * @param width - Target width
-     * @param height - Target height
-     * @param x - X position of input
-     * @param y - Y position of input
-     * @param color - Padding color
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * chain.pad('iw*2', 'ih*2')  // Double the canvas size
-     * ```
-     *
-     * @see {@link FilterPresetBase.pad}
      */
-    pad(width: string | number, height: string | number, x?: string, y?: string, color?: string): this;
+    hwmap(derive?: string): FilterPreset;
     /**
-     * Adds a trim filter to the chain.
+     * Adds a filter to the chain.
      *
-     * @param start - Start time in seconds
-     * @param end - End time in seconds
-     * @param duration - Duration in seconds
+     * @param filter - Filter string to add (ignored if null/undefined)
      *
      * @returns This instance for chaining
      *
      * @example
      * ```typescript
-     * chain.trim(10, 20)  // Extract 10 seconds from t=10 to t=20
+     * chain.add('scale=1920:1080')
      * ```
      *
-     * @see {@link FilterPresetBase.trim}
+     * @internal
      */
-    trim(start: number, end?: number, duration?: number): this;
+    private add;
     /**
-     * Adds a setpts filter to the chain.
-     *
-     * @param expression - PTS expression
-     *
-     * @returns This instance for chaining
+     * Determines filter support for the hardware type.
      *
-     * @example
-     * ```typescript
-     * chain.setpts('PTS/2')  // Double playback speed
-     * ```
+     * @returns Hardware filter support configuration
      *
-     * @see {@link FilterPresetBase.setpts}
-     */
-    setpts(expression: string): this;
-    /**
-     * Adds an asetpts filter to the chain.
-     *
-     * @param expression - PTS expression
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * chain.asetpts('PTS-STARTPTS')  // Reset audio timestamps
-     * ```
-     *
-     * @see {@link FilterPresetBase.asetpts}
-     */
-    asetpts(expression: string): this;
-    /**
-     * Adds a setsar filter to the chain.
-     *
-     * @param ratio - Sample aspect ratio
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * chain.setsar('1:1')  // Square pixels
-     * ```
-     *
-     * @see {@link FilterPresetBase.setsar}
-     */
-    setsar(ratio: string | number): this;
-    /**
-     * Adds a setdar filter to the chain.
-     *
-     * @param ratio - Display aspect ratio
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * chain.setdar('16:9')  // Set widescreen aspect
-     * ```
-     *
-     * @see {@link FilterPresetBase.setdar}
-     */
-    setdar(ratio: string | number): this;
-    /**
-     * Adds an apad filter to the chain.
-     *
-     * @param wholeDuration - Minimum total duration
-     * @param padDuration - Padding duration to add
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * chain.apad(10)  // Ensure at least 10 seconds of audio
-     * ```
-     *
-     * @see {@link FilterPresetBase.apad}
-     */
-    apad(wholeDuration?: number, padDuration?: number): this;
-    /**
-     * Adds a select filter to the chain.
-     *
-     * @param expression - Selection expression
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * chain.select('eq(pict_type,I)')  // Select only I-frames
-     * ```
-     *
-     * @see {@link FilterPresetBase.select}
-     */
-    select(expression: string): this;
-    /**
-     * Adds an aselect filter to the chain.
-     *
-     * @param expression - Selection expression
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * chain.aselect('between(t,10,20)')  // Select audio between 10-20s
-     * ```
-     *
-     * @see {@link FilterPresetBase.aselect}
-     */
-    aselect(expression: string): this;
-    /**
-     * Adds a concat filter to the chain.
-     *
-     * @param n - Number of input segments
-     * @param v - Number of video streams
-     * @param a - Number of audio streams
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * chain.concat(3, 1, 1)  // Concatenate 3 segments with video and audio
-     * ```
-     *
-     * @see {@link FilterPresetBase.concat}
-     */
-    concat(n: number, v?: number, a?: number): this;
-    /**
-     * Adds an amerge filter to the chain.
-     *
-     * @param inputs - Number of input streams
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * chain.amerge(2)  // Merge 2 audio streams
-     * ```
-     *
-     * @see {@link FilterPresetBase.amerge}
-     */
-    amerge(inputs?: number): this;
-    /**
-     * Adds a channelmap filter to the chain.
-     *
-     * @param map - Channel mapping string
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * chain.channelmap('FL-FR|FR-FL')  // Swap stereo channels
-     * ```
-     *
-     * @see {@link FilterPresetBase.channelmap}
-     */
-    channelmap(map: string): this;
-    /**
-     * Adds a channelsplit filter to the chain.
-     *
-     * @param channelLayout - Channel layout to split
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * chain.channelsplit('stereo')  // Split stereo into two mono streams
-     * ```
-     *
-     * @see {@link FilterPresetBase.channelsplit}
-     */
-    channelsplit(channelLayout?: string): this;
-    /**
-     * Adds a loudnorm filter to the chain.
-     *
-     * @param I - Integrated loudness target (LUFS)
-     * @param TP - True peak (dBTP)
-     * @param LRA - Loudness range (LU)
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * chain.loudnorm(-16, -1.5, 11)  // Streaming loudness standard
-     * ```
-     *
-     * @see {@link FilterPresetBase.loudnorm}
-     */
-    loudnorm(I?: number, TP?: number, LRA?: number): this;
-    /**
-     * Adds a compand filter to the chain.
-     *
-     * @param attacks - Attack times
-     * @param decays - Decay times
-     * @param points - Transfer function points
-     * @param gain - Output gain
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * chain.compand('0.3|0.3', '1|1', '-90/-60|-60/-40|-40/-30|-20/-20', 6)
-     * ```
-     *
-     * @see {@link FilterPresetBase.compand}
-     */
-    compand(attacks: string, decays: string, points: string, gain?: number): this;
-    /**
-     * Adds a transpose filter to the chain (hardware-specific).
-     * Only available for hardware presets that support transpose
-     *
-     * @param mode - Transpose mode (number or string)
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .transpose('clock')
-     *   .build();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .transpose('cclock_flip')
-     *   .build();
-     * ```
-     */
-    transpose(mode?: number | 'clock' | 'cclock' | 'clock_flip' | 'cclock_flip'): this;
-    /**
-     * Adds a tonemap filter to the chain (hardware-specific).
-     * Only available for hardware presets that support tonemapping
-     *
-     * @param options - Tonemapping options
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .tonemap()
-     *   .build();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .tonemap({ tonemap: 'hable', desat: '0' })
-     *   .build();
-     * ```
-     */
-    tonemap(options?: Record<string, string>): this;
-    /**
-     * Adds a deinterlace filter to the chain (hardware-specific).
-     * Only available for hardware presets that support deinterlacing
-     *
-     * @param mode - Deinterlace mode (optional)
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .deinterlace()
-     *   .build();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .deinterlace('yadif')
-     *   .build();
-     * ```
-     */
-    deinterlace(mode?: string): this;
-    /**
-     * Adds a flip filter to the chain (hardware-specific).
-     * Falls back to hflip/vflip if hardware flip not available
-     *
-     * @param direction - Flip direction ('h' or 'v')
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .flip('h')
-     *   .build();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .flip('v')
-     *   .build();
-     * ```
-     */
-    flip(direction: 'h' | 'v'): this;
-    /**
-     * Adds a blur filter to the chain (hardware-specific).
-     * Only available for hardware presets that support blur
-     *
-     * @param type - Blur type (default: 'avg')
-     * @param radius - Blur radius (optional)
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .blur('gaussian', 5)
-     *   .build();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .blur('box')
-     *   .build();
-     * ```
-     */
-    blur(type?: 'avg' | 'gaussian' | 'box', radius?: number): this;
-    /**
-     * Adds a sharpen filter to the chain (hardware-specific).
-     * Only available for hardware presets that support sharpening
-     *
-     * @param amount - Sharpen amount (optional)
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .sharpen(1.5)
-     *   .build();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .sharpen()
-     *   .build();
-     * ```
-     */
-    sharpen(amount?: number): this;
-    /**
-     * Adds a stack filter to the chain (hardware-specific).
-     * Only available for hardware presets that support stacking
-     *
-     * @param type - Stack type ('h' for horizontal, 'v' for vertical, 'x' for grid)
-     * @param inputs - Number of inputs (default: 2)
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .stack('h', 2)
-     *   .build();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .stack('x', 4)
-     *   .build();
-     * ```
-     */
-    stack(type: 'h' | 'v' | 'x', inputs?: number): this;
-    /**
-     * Adds a hwupload filter to upload frames to hardware.
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .hwupload()
-     *   .scale(1920, 1080)
-     *   .build();
-     * ```
-     */
-    hwupload(): this;
-    /**
-     * Adds a hwdownload filter to download frames from hardware.
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .scale(1920, 1080)
-     *   .hwdownload()
-     *   .build();
-     * ```
-     */
-    hwdownload(): this;
-    /**
-     * Adds a hwmap filter to map frames between hardware devices.
-     *
-     * @param derive - Device to derive from (optional)
-     *
-     * @returns This instance for chaining
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .hwmap('cuda')
-     *   .build();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const chain = FilterPresets.chain()
-     *   .hwmap()
-     *   .build();
-     * ```
-     */
-    hwmap(derive?: string): this;
-}
-/**
- * Fluent filter chain builder with preset methods.
- * Provides a convenient API for building filter chains using standard presets.
- *
- * @example
- * ```typescript
- * const filter = FilterPresets.chain()
- *   .scale(1920, 1080)
- *   .fps(30)
- *   .fade('in', 0, 2)
- *   .format('yuv420p')
- *   .build();
- * ```
- */
-export declare class FilterChainBuilder extends ChainBuilderBase<FilterPresets> {
-}
-/**
- * Standard filter presets for software filtering.
- * Provides static methods for creating common filter strings and
- * a chain builder for composing complex filter graphs.
- *
- * @example
- * ```typescript
- * // Static methods for individual filters
- * const scaleFilter = FilterPresets.scale(1920, 1080);
- * const fpsFilter = FilterPresets.fps(30);
- *
- * // Chain builder for complex graphs
- * const chain = FilterPresets.chain()
- *   .scale(1920, 1080)
- *   .fps(30)
- *   .fade('in', 0, 2)
- *   .build();
- * ```
- */
-export declare class FilterPresets extends FilterPresetBase {
-    private static instance;
-    /**
-     * Creates a new filter chain builder.
-     *
-     * @returns A new FilterChainBuilder instance
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.chain()
-     *   .scale(1280, 720)
-     *   .fps(30)
-     *   .build();
-     * ```
-     */
-    static chain(): FilterChainBuilder;
-    /**
-     * Creates a scale filter string.
-     *
-     * @param width - Target width
-     * @param height - Target height
-     * @param flags - Scaling algorithm flags (optional)
-     *
-     * @returns Scale filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.scale(1920, 1080);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.scale(1280, 720, 'lanczos');
-     * ```
-     */
-    static scale(width: number, height: number, flags?: string): string;
-    /**
-     * Creates a crop filter string.
-     *
-     * @param width - Crop width
-     * @param height - Crop height
-     * @param x - X position (default: 0)
-     * @param y - Y position (default: 0)
-     *
-     * @returns Crop filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.crop(640, 480);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.crop(1920, 1080, 100, 50);
-     * ```
-     */
-    static crop(width: number, height: number, x?: number, y?: number): string;
-    /**
-     * Creates an FPS filter string.
-     *
-     * @param fps - Target frame rate
-     *
-     * @returns FPS filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.fps(30);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.fps(23.976);
-     * ```
-     */
-    static fps(fps: number): string;
-    /**
-     * Creates a format filter string.
-     *
-     * @param pixelFormat - Target pixel format(s)
-     *
-     * @returns Format filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.format('yuv420p');
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.format(AV_PIX_FMT_RGB24);
-     * ```
-     */
-    static format(pixelFormat: string | AVPixelFormat | (string | AVPixelFormat)[]): string;
-    /**
-     * Creates a rotate filter string.
-     *
-     * @param angle - Rotation angle in degrees
-     *
-     * @returns Rotate filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.rotate(45);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.rotate(-90);
-     * ```
-     */
-    static rotate(angle: number): string;
-    /**
-     * Creates a horizontal flip filter string.
-     *
-     * @returns Horizontal flip filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.hflip();
-     * ```
-     */
-    static hflip(): string;
-    /**
-     * Creates a vertical flip filter string.
-     *
-     * @returns Vertical flip filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.vflip();
-     * ```
-     */
-    static vflip(): string;
-    /**
-     * Creates a fade filter string.
-     *
-     * @param type - Fade type ('in' or 'out')
-     * @param start - Start time in seconds
-     * @param duration - Fade duration in seconds
-     *
-     * @returns Fade filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.fade('in', 0, 2);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.fade('out', 10, 1.5);
-     * ```
-     */
-    static fade(type: 'in' | 'out', start: number, duration: number): string;
-    /**
-     * Creates an overlay filter string.
-     *
-     * @param x - X position (default: 0)
-     * @param y - Y position (default: 0)
-     *
-     * @returns Overlay filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.overlay(100, 50);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.overlay();
-     * ```
-     */
-    static overlay(x?: number, y?: number): string;
-    /**
-     * Creates a volume filter string.
-     *
-     * @param factor - Volume multiplication factor
-     *
-     * @returns Volume filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.volume(0.5);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.volume(2.0);
-     * ```
-     */
-    static volume(factor: number): string;
-    /**
-     * Creates an audio format filter string.
-     *
-     * @param sampleFormat - Target sample format
-     * @param sampleRate - Target sample rate (optional)
-     * @param channelLayout - Target channel layout (optional)
-     *
-     * @returns Audio format filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.aformat(AV_SAMPLE_FMT_FLT, 48000, 'stereo');
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.aformat('s16', 44100);
-     * ```
-     */
-    static aformat(sampleFormat: string | AVSampleFormat, sampleRate?: number, channelLayout?: string): string;
-    /**
-     * Creates an asetnsamples filter string.
-     *
-     * @param samples - Number of samples per frame
-     * @param padding - Whether to pad or drop samples (default: true)
-     *
-     * @returns Asetnsamples filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.asetnsamples(960);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.asetnsamples(1024, false);
-     * ```
-     */
-    static asetnsamples(samples: number, padding?: boolean): string;
-    /**
-     * Creates an atempo filter string.
-     *
-     * @param factor - Tempo factor (0.5 to 2.0)
-     *
-     * @returns Atempo filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.atempo(1.5);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.atempo(0.8);
-     * ```
-     */
-    static atempo(factor: number): string;
-    /**
-     * Creates an audio fade filter string.
-     *
-     * @param type - Fade type ('in' or 'out')
-     * @param start - Start time in seconds
-     * @param duration - Fade duration in seconds
-     *
-     * @returns Audio fade filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.afade('in', 0, 3);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.afade('out', 25, 2);
-     * ```
-     */
-    static afade(type: 'in' | 'out', start: number, duration: number): string;
-    /**
-     * Creates an amix filter string.
-     *
-     * @param inputs - Number of inputs (default: 2)
-     * @param duration - Duration mode (default: 'longest')
-     *
-     * @returns Amix filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.amix(3, 'longest');
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = FilterPresets.amix(2, 'first');
-     * ```
-     */
-    static amix(inputs?: number, duration?: 'first' | 'longest' | 'shortest'): string;
-}
-/**
- * Hardware-accelerated filter presets.
- * Provides optimized filter implementations for specific hardware types,
- * with automatic fallback when operations aren't supported.
- *
- * @example
- * ```typescript
- * // Create hardware presets for CUDA
- * const hw = new HardwareFilterPresets(AV_HWDEVICE_TYPE_CUDA);
- *
- * // Check capabilities
- * if (hw.support.scale) {
- *   const scaleFilter = hw.scale(1920, 1080);
- * }
- *
- * // Use chain builder
- * const chain = hw.chain()
- *   .hwupload()
- *   .scale(1920, 1080)
- *   .tonemap()
- *   .hwdownload()
- *   .build();
- * ```
- */
-export declare class HardwareFilterPresets extends FilterPresetBase {
-    private readonly deviceType;
-    private readonly deviceTypeName;
-    readonly support: HardwareFilterSupport;
-    /**
-     * @param deviceType - Hardware device type enum
-     * @param deviceTypeName - Optional hardware device type name (e.g., 'cuda', 'vaapi')
-     */
-    constructor(deviceType: AVHWDeviceType, deviceTypeName?: string);
-    /**
-     * Checks if a filter is hardware-accelerated.
-     *
-     * @param filterName - Name of the filter to check
-     * @returns True if the filter uses hardware acceleration
-     *
-     * @example
-     * ```typescript
-     * if (HardwareFilterPresets.isHardwareFilter('scale_cuda')) {
-     *   console.log('Hardware accelerated scaling');
-     * }
-     * ```
-     */
-    static isHardwareFilter(filterName: string): boolean;
-    /**
-     * Creates a hardware filter chain builder.
-     *
-     * @returns A new HardwareFilterChainBuilder instance
-     *
-     * @example
-     * ```typescript
-     * const filter = hw.chain()
-     *   .hwupload()
-     *   .scale(1920, 1080)
-     *   .hwdownload()
-     *   .build();
-     * ```
-     */
-    chain(): HardwareFilterChainBuilder;
-    /**
-     * Creates a hardware-accelerated scale filter.
-     *
-     * Different hardware types use different scale filters:
-     * - CUDA: scale_cuda or scale_npp (with npp option)
-     * - VAAPI: scale_vaapi
-     * - QSV: scale_qsv
-     * - VideoToolbox: scale_vt
-     * - RKMPP: scale_rkrga
-     *
-     * @param width - Target width
-     * @param height - Target height
-     * @param options - Hardware-specific scaling options
-     *
-     * @returns Hardware scale filter string or null if not supported
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.scale(1920, 1080);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.scale(1280, 720, { npp: true });
-     * ```
-     *
-     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#scale_005fcuda | FFmpeg scale_cuda filter}
-     */
-    scale(width: number, height: number, options?: Record<string, any>): string | null;
-    /**
-     * Creates a hardware-accelerated overlay filter.
-     *
-     * @param x - X position (default: 0)
-     * @param y - Y position (default: 0)
-     * @param options - Hardware-specific overlay options
-     *
-     * @returns Hardware overlay filter string or null if not supported
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.overlay(100, 50);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.overlay(0, 0, { eof_action: 'pass' });
-     * ```
-     *
-     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#overlay_005fcuda | FFmpeg overlay_cuda filter}
-     */
-    overlay(x?: number, y?: number, options?: Record<string, string>): string | null;
-    /**
-     * Creates a hardware-accelerated transpose filter.
-     *
-     * Direction values:
-     * - 0: 90 degrees counter-clockwise and vertical flip
-     * - 1 / 'clock': 90 degrees clockwise
-     * - 2 / 'cclock': 90 degrees counter-clockwise
-     * - 3 / 'clock_flip': 90 degrees clockwise and vertical flip
-     *
-     * @param mode - Transpose mode (number or string)
-     *
-     * @returns Hardware transpose filter string or null if not supported
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.transpose('clock');
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.transpose(2);
-     * ```
-     */
-    transpose(mode: number | 'clock' | 'cclock' | 'clock_flip' | 'cclock_flip'): string | null;
-    /**
-     * Creates a hardware-accelerated tonemap filter.
-     * Used for HDR to SDR conversion with hardware acceleration.
-     *
-     * @param options - Tonemapping options (algorithm, parameters)
-     *
-     * @returns Hardware tonemap filter string or null if not supported
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.tonemap();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.tonemap({ tonemap: 'hable', desat: '0' });
-     * ```
-     */
-    tonemap(options?: Record<string, string>): string | null;
-    /**
-     * Creates a hardware-accelerated deinterlace filter.
-     *
-     * Different hardware types use different deinterlacers:
-     * - CUDA: yadif_cuda
-     * - VAAPI: deinterlace_vaapi
-     * - QSV: deinterlace_qsv
-     * - Vulkan: bwdif_vulkan
-     * - VideoToolbox: yadif_videotoolbox
-     *
-     * @param mode - Deinterlacing mode (optional)
-     *
-     * @returns Hardware deinterlace filter string or null if not supported
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.deinterlace();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.deinterlace('send_field');
-     * ```
-     */
-    deinterlace(mode?: string): string | null;
-    /**
-     * Creates a hardware-accelerated flip filter.
-     * Currently only Vulkan supports hardware flip filters.
-     *
-     * @param direction - Flip direction ('h' for horizontal, 'v' for vertical)
-     *
-     * @returns Hardware flip filter string or null if not supported
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.flip('h');
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.flip('v');
-     * ```
-     */
-    flip(direction: 'h' | 'v'): string | null;
-    /**
-     * Creates a hardware-accelerated blur filter.
-     *
-     * Different hardware types support different blur filters:
-     * - CUDA: bilateral_cuda
-     * - Vulkan: avgblur_vulkan, gblur_vulkan
-     * - OpenCL: avgblur_opencl, boxblur_opencl
-     *
-     * @param type - Blur type ('avg', 'gaussian', or 'box', default: 'avg')
-     * @param radius - Blur radius (optional)
-     *
-     * @returns Hardware blur filter string or null if not supported
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.blur('gaussian', 5);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.blur('avg');
-     * ```
-     */
-    blur(type?: 'avg' | 'gaussian' | 'box', radius?: number): string | null;
-    /**
-     * Creates a hardware-accelerated sharpen filter.
-     *
-     * Hardware sharpening support:
-     * - VAAPI: sharpness_vaapi
-     * - OpenCL: unsharp_opencl
-     * - CUDA: sharpen_npp (NPP-based)
-     *
-     * @param amount - Sharpening amount (optional)
-     *
-     * @returns Hardware sharpen filter string or null if not supported
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.sharpen(1.5);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.sharpen();
-     * ```
-     */
-    sharpen(amount?: number): string | null;
-    /**
-     * Creates a hardware-accelerated stack filter.
-     * Only VAAPI and QSV support hardware stacking.
-     *
-     * @param type - Stack type ('h' for horizontal, 'v' for vertical, 'x' for grid)
-     * @param inputs - Number of inputs to stack (default: 2)
-     *
-     * @returns Hardware stack filter string or null if not supported
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.stack('h', 2);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.stack('x', 4);
-     * ```
-     */
-    stack(type: 'h' | 'v' | 'x', inputs?: number): string | null;
-    /**
-     * Creates a hwupload filter to upload frames to hardware memory.
-     * CUDA uses hwupload_cuda, others use generic hwupload.
-     *
-     * @returns Hardware upload filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.hwupload();
-     * ```
-     *
-     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#hwupload | FFmpeg hwupload filter}
-     */
-    hwupload(): string | null;
-    /**
-     * Creates a hwdownload filter to download frames from hardware memory.
-     *
-     * @returns Hardware download filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.hwdownload();
-     * ```
-     *
-     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#hwdownload | FFmpeg hwdownload filter}
-     */
-    hwdownload(): string | null;
-    /**
-     * Creates a hwmap filter to map frames between hardware devices.
-     *
-     * @param derive - Device to derive from (optional)
-     *
-     * @returns Hardware map filter string
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.hwmap('cuda');
-     * ```
-     *
-     * @example
-     * ```typescript
-     * const filter = hwPresets.hwmap();
-     * ```
-     *
-     * @see {@link https://ffmpeg.org/ffmpeg-filters.html#hwmap | FFmpeg hwmap filter}
-     */
-    hwmap(derive?: string): string | null;
-    /**
-     * Gets the filter capabilities for this hardware type.
-     *
-     * @returns Object describing which filters are supported
-     *
-     * @example
-     * ```typescript
-     * const caps = hw.getCapabilities();
-     * if (caps.scale && caps.overlay) {
-     *   console.log('Hardware supports scaling and overlay');
-     * }
-     * ```
-     */
-    getCapabilities(): HardwareFilterSupport;
-    /**
-     * Determines filter support for the hardware type.
-     *
-     * @returns Hardware filter support configuration
-     *
-     * @internal
+     * @internal
      */
     private getSupport;
 }
-/**
- * Hardware filter chain builder with fluent API.
- * Automatically skips unsupported filters (returns null) allowing graceful fallback.
- *
- * @example
- * ```typescript
- * const hw = new HardwareFilterPresets(AV_HWDEVICE_TYPE_CUDA, 'cuda');
- * const chain = hw.chain()
- *   .hwupload()
- *   .scale(1920, 1080)
- *   .tonemap()  // Skipped if not supported
- *   .hwdownload()
- *   .build();
- * ```
- */
-export declare class HardwareFilterChainBuilder extends ChainBuilderBase<HardwareFilterPresets> {
-}