diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 39a95a19..273bbc25 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -18,33 +18,16 @@ repos:
       - id: pretty-format-json
         args: [--autofix]
         exclude: "__snapshots__/"
-  # this is not technically always safe but usually is
-  # use comments `# isort: off` and `# isort: on` to disable/re-enable isort
-  - repo: https://github.com/pycqa/isort
-    rev: 5.12.0
-    hooks:
-      - id: isort
-        args: [--line-length=120, --profile=black]
-
-  # this is slightly dangerous because python imports have side effects
-  # and this tool removes unused imports, which may be providing
-  # necessary side effects for the code to run
-  - repo: https://github.com/PyCQA/autoflake
-    rev: v1.6.1
-    hooks:
-      - id: autoflake
-        args:
-          - "--in-place"
-          - "--expand-star-imports"
-          - "--remove-duplicate-keys"
-          - "--remove-unused-variables"
-          - "--remove-all-unused-imports"
 
-  - repo: https://github.com/psf/black
-    rev: 22.8.0
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    # Ruff version.
+    rev: v0.9.1
     hooks:
-      - id: black
-        args: [--line-length=120, --exclude=""]
+      # Run the linter.
+      - id: ruff
+        args: [--fix]
+      # Run the formatter.
+      - id: ruff-format
 
   - repo: https://github.com/pre-commit/mirrors-mypy
     rev: v1.8.0
diff --git a/pyproject.toml b/pyproject.toml
index 70843c5f..8e2720c5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -111,13 +111,13 @@ src = ["src"]
 [tool.ruff.lint]  # https://docs.astral.sh/ruff/settings/#lint
 select = [
     "E",   # pycodestyle errors
-    "W",   # pycodestyle warnings
-    "F",   # pyflakes
-    "I",   # isort
+#    "W",   # pycodestyle warnings
+#    "F",   # pyflakes
+#    "I",   # isort
     # "B",   # flake8-bugbear
-    "B006",   # flake8-bugbear: Do not use mutable data structures for argument defaults
-    "C4",  # flake8-comprehensions
-    "UP",  # pyupgrade
+#    "B006",   # flake8-bugbear: Do not use mutable data structures for argument defaults
+#    "C4",  # flake8-comprehensions
+#    "UP",  # pyupgrade
 ]
 ignore = [
     "E741",  # Ambiguous variable name: `I`
@@ -126,8 +126,6 @@ ignore = [
     "E712",  # not work for pandas
     "F811",  # FIXME: we relay on it to share fixture across app
 ]
-[tool.ruff.lint.isort]
-required-imports = ["from __future__ import annotations"]
 
 [tool.ruff.format]  # https://docs.astral.sh/ruff/settings/#format
 quote-style = "double"  # 引號風格，雙引號是預設值
diff --git a/src/ffmpeg/base.py b/src/ffmpeg/base.py
index 491baa42..6eb80b4f 100644
--- a/src/ffmpeg/base.py
+++ b/src/ffmpeg/base.py
@@ -6,7 +6,13 @@
 
 from .dag.io._input import input
 from .dag.io._output import output
-from .dag.nodes import FilterableStream, FilterNode, GlobalNode, GlobalStream, OutputStream
+from .dag.nodes import (
+    FilterableStream,
+    FilterNode,
+    GlobalNode,
+    GlobalStream,
+    OutputStream,
+)
 from .schema import StreamType
 from .streams.audio import AudioStream
 from .streams.video import VideoStream
@@ -26,7 +32,10 @@ def merge_outputs(*streams: OutputStream) -> GlobalStream:
 
 
 def vfilter(
-    *streams: FilterableStream, name: str, input_typings: tuple[StreamType, ...] = (StreamType.video,), **kwargs: Any
+    *streams: FilterableStream,
+    name: str,
+    input_typings: tuple[StreamType, ...] = (StreamType.video,),
+    **kwargs: Any,
 ) -> VideoStream:
     """
     Apply a custom video filter which has only one output to this stream
@@ -53,7 +62,10 @@ def vfilter(
 
 
 def afilter(
-    *streams: FilterableStream, name: str, input_typings: tuple[StreamType, ...] = (StreamType.audio,), **kwargs: Any
+    *streams: FilterableStream,
+    name: str,
+    input_typings: tuple[StreamType, ...] = (StreamType.audio,),
+    **kwargs: Any,
 ) -> AudioStream:
     """
     Apply a custom audio filter which has only one output to this stream
@@ -84,7 +96,7 @@ def filter_multi_output(
     name: str,
     input_typings: tuple[StreamType, ...] = (),
     output_tyings: tuple[StreamType, ...] = (),
-    **kwargs: Any
+    **kwargs: Any,
 ) -> FilterNode:
     """
     Apply a custom filter which has multiple outputs to this stream
@@ -111,4 +123,11 @@ def filter_multi_output(
     )
 
 
-__all__ = ["input", "output", "merge_outputs", "vfilter", "afilter", "filter_multi_output"]
+__all__ = [
+    "input",
+    "output",
+    "merge_outputs",
+    "vfilter",
+    "afilter",
+    "filter_multi_output",
+]
diff --git a/src/ffmpeg/dag/context.py b/src/ffmpeg/dag/context.py
index 73ffdd36..f775f671 100644
--- a/src/ffmpeg/dag/context.py
+++ b/src/ffmpeg/dag/context.py
@@ -105,7 +105,10 @@ def all_streams(self) -> list[Stream]:
         """
         All streams in the graph sorted by the number of upstream nodes and the index of the stream.
         """
-        return sorted(self.streams, key=lambda stream: (len(stream.node.upstream_nodes), stream.index))
+        return sorted(
+            self.streams,
+            key=lambda stream: (len(stream.node.upstream_nodes), stream.index),
+        )
 
     @cached_property
     def outgoing_nodes(self) -> dict[Stream, list[tuple[Node, int]]]:
@@ -180,7 +183,9 @@ def get_node_label(self, node: Node) -> str:
             The label of the node.
         """
 
-        assert isinstance(node, (InputNode, FilterNode)), "Only input and filter nodes have labels"
+        assert isinstance(node, (InputNode, FilterNode)), (
+            "Only input and filter nodes have labels"
+        )
         return self.node_labels[node]
 
     @override
diff --git a/src/ffmpeg/dag/io/_output.py b/src/ffmpeg/dag/io/_output.py
index dacb4d82..0d401fff 100644
--- a/src/ffmpeg/dag/io/_output.py
+++ b/src/ffmpeg/dag/io/_output.py
@@ -316,5 +316,7 @@ def output(
     }
 
     return OutputNode(
-        inputs=streams, filename=str(filename), kwargs=tuple((options | (extra_options or {})).items())
+        inputs=streams,
+        filename=str(filename),
+        kwargs=tuple((options | (extra_options or {})).items()),
     ).stream()
diff --git a/src/ffmpeg/dag/io/tests/test_input.py b/src/ffmpeg/dag/io/tests/test_input.py
index 684c98c4..713e25d8 100644
--- a/src/ffmpeg/dag/io/tests/test_input.py
+++ b/src/ffmpeg/dag/io/tests/test_input.py
@@ -7,13 +7,20 @@
 def test_input(snapshot: SnapshotAssertion) -> None:
     assert (
         snapshot(extension_class=JSONSnapshotExtension)
-        == input("input.mp4", c="copy", accurate_seek=True, display_vflip=False, ss=5, display_rotation=1.0)
+        == input(
+            "input.mp4",
+            c="copy",
+            accurate_seek=True,
+            display_vflip=False,
+            ss=5,
+            display_rotation=1.0,
+        )
         .output(filename="output.mp4")
         .compile()
     )
 
 
 def test_input_with_filter(snapshot: SnapshotAssertion) -> None:
-    assert input("anullsrc", f="lavfi", t=10).output(filename="output.mp4").compile() == snapshot(
-        extension_class=JSONSnapshotExtension
-    )
+    assert input("anullsrc", f="lavfi", t=10).output(
+        filename="output.mp4"
+    ).compile() == snapshot(extension_class=JSONSnapshotExtension)
diff --git a/src/ffmpeg/dag/io/tests/test_output.py b/src/ffmpeg/dag/io/tests/test_output.py
index 311bf961..6717122a 100644
--- a/src/ffmpeg/dag/io/tests/test_output.py
+++ b/src/ffmpeg/dag/io/tests/test_output.py
@@ -9,6 +9,11 @@ def test_output(snapshot: SnapshotAssertion) -> None:
     assert (
         snapshot(extension_class=JSONSnapshotExtension)
         == output(
-            input("input.mp4"), filename="output.mp4", c="copy", shortest=True, force_fps=False, ar=44100
+            input("input.mp4"),
+            filename="output.mp4",
+            c="copy",
+            shortest=True,
+            force_fps=False,
+            ar=44100,
         ).compile()
     )
diff --git a/src/ffmpeg/dag/nodes.py b/src/ffmpeg/dag/nodes.py
index 22002cc6..36ad991c 100644
--- a/src/ffmpeg/dag/nodes.py
+++ b/src/ffmpeg/dag/nodes.py
@@ -67,9 +67,13 @@ def video(self, index: int) -> "VideoStream":
         """
         from ..streams.video import VideoStream
 
-        video_outputs = [i for i, k in enumerate(self.output_typings) if k == StreamType.video]
+        video_outputs = [
+            i for i, k in enumerate(self.output_typings) if k == StreamType.video
+        ]
         if not len(video_outputs) > index:
-            raise FFMpegValueError(f"Specified index {index} is out of range for video outputs {len(video_outputs)}")
+            raise FFMpegValueError(
+                f"Specified index {index} is out of range for video outputs {len(video_outputs)}"
+            )
         return VideoStream(node=self, index=video_outputs[index])
 
     def audio(self, index: int) -> "AudioStream":
@@ -84,9 +88,13 @@ def audio(self, index: int) -> "AudioStream":
         """
         from ..streams.audio import AudioStream
 
-        audio_outputs = [i for i, k in enumerate(self.output_typings) if k == StreamType.audio]
+        audio_outputs = [
+            i for i, k in enumerate(self.output_typings) if k == StreamType.audio
+        ]
         if not len(audio_outputs) > index:
-            raise FFMpegValueError(f"Specified index {index} is out of range for audio outputs {len(audio_outputs)}")
+            raise FFMpegValueError(
+                f"Specified index {index} is out of range for audio outputs {len(audio_outputs)}"
+            )
 
         return AudioStream(node=self, index=audio_outputs[index])
 
@@ -97,12 +105,16 @@ def __post_init__(self) -> None:
         super().__post_init__()
 
         if len(self.inputs) != len(self.input_typings):
-            raise FFMpegValueError(f"Expected {len(self.input_typings)} inputs, got {len(self.inputs)}")
+            raise FFMpegValueError(
+                f"Expected {len(self.input_typings)} inputs, got {len(self.inputs)}"
+            )
 
         stream: FilterableStream
         expected_type: StreamType
 
-        for i, (stream, expected_type) in enumerate(zip(self.inputs, self.input_typings)):
+        for i, (stream, expected_type) in enumerate(
+            zip(self.inputs, self.input_typings)
+        ):
             if expected_type == StreamType.video:
                 if not isinstance(stream, VideoStream):
                     raise FFMpegTypeError(
@@ -132,7 +144,9 @@ def get_args(self, context: DAGContext = None) -> list[str]:
 
         commands = []
         for key, value in self.kwargs:
-            assert not isinstance(value, LazyValue), f"LazyValue should have been evaluated: {key}={value}"
+            assert not isinstance(value, LazyValue), (
+                f"LazyValue should have been evaluated: {key}={value}"
+            )
 
             # Note: the -nooption syntax cannot be used for boolean AVOptions, use -option 0/-option 1.
             if isinstance(value, bool):
@@ -142,7 +156,12 @@ def get_args(self, context: DAGContext = None) -> list[str]:
                 commands += [f"{key}={escape(value)}"]
 
         if commands:
-            return [incoming_labels] + [f"{self.name}="] + [escape(":".join(commands), "\\'[],;")] + [outgoing_labels]
+            return (
+                [incoming_labels]
+                + [f"{self.name}="]
+                + [escape(":".join(commands), "\\'[],;")]
+                + [outgoing_labels]
+            )
         return [incoming_labels] + [f"{self.name}"] + [outgoing_labels]
 
 
@@ -155,7 +174,9 @@ class FilterableStream(Stream, OutputArgs):
     node: "FilterNode | InputNode"
 
     @override
-    def _output_node(self, *streams: FilterableStream, filename: str | Path, **kwargs: Any) -> OutputNode:
+    def _output_node(
+        self, *streams: FilterableStream, filename: str | Path, **kwargs: Any
+    ) -> OutputNode:
         """
         Output the streams to a file URL
 
@@ -167,7 +188,11 @@ def _output_node(self, *streams: FilterableStream, filename: str | Path, **kwarg
         Returns:
             the output stream
         """
-        return OutputNode(inputs=(self, *streams), filename=str(filename), kwargs=tuple(kwargs.items()))
+        return OutputNode(
+            inputs=(self, *streams),
+            filename=str(filename),
+            kwargs=tuple(kwargs.items()),
+        )
 
     def vfilter(
         self,
@@ -277,13 +302,17 @@ def label(self, context: DAGContext = None) -> str:
                 return f"{context.get_node_label(self.node)}:v"
             elif isinstance(self, AudioStream):
                 return f"{context.get_node_label(self.node)}:a"
-            raise FFMpegValueError(f"Unknown stream type: {self.__class__.__name__}")  # pragma: no cover
+            raise FFMpegValueError(
+                f"Unknown stream type: {self.__class__.__name__}"
+            )  # pragma: no cover
 
         if isinstance(self.node, FilterNode):
             if len(self.node.output_typings) > 1:
                 return f"{context.get_node_label(self.node)}#{self.index}"
             return f"{context.get_node_label(self.node)}"
-        raise FFMpegValueError(f"Unknown node type: {self.node.__class__.__name__}")  # pragma: no cover
+        raise FFMpegValueError(
+            f"Unknown node type: {self.node.__class__.__name__}"
+        )  # pragma: no cover
 
     def __post_init__(self) -> None:
         if isinstance(self.node, InputNode):
diff --git a/src/ffmpeg/dag/tests/test_factory.py b/src/ffmpeg/dag/tests/test_factory.py
index 0c5913f7..165c1313 100644
--- a/src/ffmpeg/dag/tests/test_factory.py
+++ b/src/ffmpeg/dag/tests/test_factory.py
@@ -10,13 +10,16 @@ def test_filter_node_factory(snapshot: SnapshotAssertion) -> None:
     in_file = input("foo.mp4")
 
     f = filter_node_factory(
-        FFMpegFilterDef(name="foo", typings_input="[StreamType.video]*n"), **{"n": Auto("len(streams)")}
+        FFMpegFilterDef(name="foo", typings_input="[StreamType.video]*n"),
+        **{"n": Auto("len(streams)")},
     )
     assert snapshot == f
     assert f.kwargs == tuple({"n": 0}.items())
 
     f = filter_node_factory(
-        FFMpegFilterDef(name="foo", typings_input="[StreamType.video]*n"), in_file.video, **{"n": Auto("len(streams)")}
+        FFMpegFilterDef(name="foo", typings_input="[StreamType.video]*n"),
+        in_file.video,
+        **{"n": Auto("len(streams)")},
     )
     assert snapshot == f
     assert f.kwargs == tuple({"n": 1}.items())
@@ -25,7 +28,7 @@ def test_filter_node_factory(snapshot: SnapshotAssertion) -> None:
         FFMpegFilterDef(name="foo", typings_input="[StreamType.video]*n"),
         in_file.video,
         in_file.video,
-        **{"n": Auto("len(streams)")}
+        **{"n": Auto("len(streams)")},
     )
     assert snapshot == f
     assert f.kwargs == tuple({"n": 2}.items())
diff --git a/src/ffmpeg/dag/tests/test_nodes.py b/src/ffmpeg/dag/tests/test_nodes.py
index 392a8d7c..d2e38690 100644
--- a/src/ffmpeg/dag/tests/test_nodes.py
+++ b/src/ffmpeg/dag/tests/test_nodes.py
@@ -10,7 +10,14 @@
 from ...schema import StreamType
 from ...utils.snapshot import DAGSnapshotExtenstion
 from ..context import DAGContext
-from ..nodes import FilterNode, GlobalNode, GlobalStream, InputNode, OutputNode, OutputStream
+from ..nodes import (
+    FilterNode,
+    GlobalNode,
+    GlobalStream,
+    InputNode,
+    OutputNode,
+    OutputStream,
+)
 from ..schema import Node
 
 
@@ -53,11 +60,13 @@
         ),
     ],
 )
-def test_node_prop(node: Node, expected_type: type[Node], snapshot: SnapshotAssertion) -> None:
+def test_node_prop(
+    node: Node, expected_type: type[Node], snapshot: SnapshotAssertion
+) -> None:
     assert snapshot(name="f.repr") == node.repr()
     assert snapshot(name="__repr__") == repr(node)
     assert snapshot(name="get_args") == node.get_args()
-    assert type(node) == expected_type
+    assert type(node) is expected_type
     assert snapshot(extension_class=DAGSnapshotExtenstion, name="graph") == node
 
 
@@ -73,16 +82,34 @@ def base_stream() -> OutputStream:
     "stream,expected_overwrite",
     [
         pytest.param(base_stream(), None, id="not config"),
-        pytest.param(base_stream().global_args(y=True), True, id="set y is True with global args"),
-        pytest.param(base_stream().global_args(y=False), None, id="set y is True with global args"),
-        pytest.param(base_stream().global_args(n=True), False, id="set n is True with global args"),
-        pytest.param(base_stream().global_args(n=False), None, id="set n is False with global args"),
-        pytest.param(base_stream().overwrite_output(), True, id="set y with overwrite_output"),
+        pytest.param(
+            base_stream().global_args(y=True), True, id="set y is True with global args"
+        ),
+        pytest.param(
+            base_stream().global_args(y=False),
+            None,
+            id="set y is True with global args",
+        ),
+        pytest.param(
+            base_stream().global_args(n=True),
+            False,
+            id="set n is True with global args",
+        ),
+        pytest.param(
+            base_stream().global_args(n=False),
+            None,
+            id="set n is False with global args",
+        ),
+        pytest.param(
+            base_stream().overwrite_output(), True, id="set y with overwrite_output"
+        ),
         pytest.param(base_stream().global_args(), None, id="not set with global args"),
     ],
 )
 def test_global_node_with_args_overwrite(
-    snapshot: SnapshotAssertion, stream: OutputStream | GlobalStream, expected_overwrite: bool | None
+    snapshot: SnapshotAssertion,
+    stream: OutputStream | GlobalStream,
+    expected_overwrite: bool | None,
 ) -> None:
     context = DAGContext.build(stream.node)
 
@@ -94,15 +121,23 @@ def test_global_node_with_args_overwrite(
         assert "-y" not in stream.compile()
         assert "-n" not in stream.compile()
 
-    assert snapshot(name="get-args", extension_class=JSONSnapshotExtension) == stream.node.get_args(context)
-    assert snapshot(name="compile", extension_class=JSONSnapshotExtension) == stream.compile()
-    assert snapshot(name="compile with overwrite", extension_class=JSONSnapshotExtension) == stream.compile(
-        overwrite_output=True
+    assert snapshot(
+        name="get-args", extension_class=JSONSnapshotExtension
+    ) == stream.node.get_args(context)
+    assert (
+        snapshot(name="compile", extension_class=JSONSnapshotExtension)
+        == stream.compile()
     )
-    assert snapshot(name="compile without overwrite", extension_class=JSONSnapshotExtension) == stream.compile(
-        overwrite_output=False
+    assert snapshot(
+        name="compile with overwrite", extension_class=JSONSnapshotExtension
+    ) == stream.compile(overwrite_output=True)
+    assert snapshot(
+        name="compile without overwrite", extension_class=JSONSnapshotExtension
+    ) == stream.compile(overwrite_output=False)
+    assert (
+        snapshot(name="compile-line", extension_class=JSONSnapshotExtension)
+        == stream.compile_line()
     )
-    assert snapshot(name="compile-line", extension_class=JSONSnapshotExtension) == stream.compile_line()
     assert snapshot(extension_class=DAGSnapshotExtenstion, name="graph") == stream.node
 
 
@@ -199,15 +234,26 @@ def test_filter_node_with_inputs(snapshot: SnapshotAssertion) -> None:
 def test_custom_filter(snapshot: SnapshotAssertion) -> None:
     in_file = input("test.mp4")
 
-    assert snapshot == in_file.audio.afilter(name="volume", v=0.5, a=0.3).node.get_args()
-    assert snapshot == in_file.video.vfilter(name="rotate", angle=90, xx=30).node.get_args()
+    assert (
+        snapshot == in_file.audio.afilter(name="volume", v=0.5, a=0.3).node.get_args()
+    )
+    assert (
+        snapshot
+        == in_file.video.vfilter(name="rotate", angle=90, xx=30).node.get_args()
+    )
 
 
 def test_input_selector(snapshot: SnapshotAssertion) -> None:
     node = InputNode(filename="test.mp4", kwargs=(("f", "mp4"),))
 
-    assert snapshot(extension_class=JSONSnapshotExtension) == node.audio.areverse().node.get_args()
-    assert snapshot(extension_class=JSONSnapshotExtension) == node.video.reverse().node.get_args()
+    assert (
+        snapshot(extension_class=JSONSnapshotExtension)
+        == node.audio.areverse().node.get_args()
+    )
+    assert (
+        snapshot(extension_class=JSONSnapshotExtension)
+        == node.video.reverse().node.get_args()
+    )
 
 
 def test_filterable_stream(snapshot: SnapshotAssertion) -> None:
diff --git a/src/ffmpeg/dag/tests/test_schema.py b/src/ffmpeg/dag/tests/test_schema.py
index ea86371b..6774293f 100644
--- a/src/ffmpeg/dag/tests/test_schema.py
+++ b/src/ffmpeg/dag/tests/test_schema.py
@@ -87,7 +87,9 @@ def update_node() -> Any:
     return pytest.param(d, [(b, b_new), (c, c_new), (c, c_new_new)], id="update_node")
 
 
-@pytest.mark.parametrize("graph, replace_pattern", [linear(), simple_loop(), multi_loop(), update_node()])
+@pytest.mark.parametrize(
+    "graph, replace_pattern", [linear(), simple_loop(), multi_loop(), update_node()]
+)
 def test_replace(
     graph: Node,
     replace_pattern: list[tuple[Node, Node]],
@@ -97,7 +99,13 @@ def test_replace(
 
     for node, replaced_node in replace_pattern:
         new_g = graph.replace(node, replaced_node)
-        assert snapshot(name=f"replace {node} -> {replaced_node}", extension_class=DAGSnapshotExtenstion) == new_g
+        assert (
+            snapshot(
+                name=f"replace {node} -> {replaced_node}",
+                extension_class=DAGSnapshotExtenstion,
+            )
+            == new_g
+        )
 
 
 @pytest.mark.skip("Not stable")
diff --git a/src/ffmpeg/dag/tests/test_validate.py b/src/ffmpeg/dag/tests/test_validate.py
index 634ffd8e..66d27b5b 100644
--- a/src/ffmpeg/dag/tests/test_validate.py
+++ b/src/ffmpeg/dag/tests/test_validate.py
@@ -14,7 +14,10 @@
 def not_utilize_split() -> Any:
     input1 = input("input1.mp4")
 
-    return pytest.param(input1.reverse().split(outputs=2).video(0).output(filename="tmp.mp4"), id="not-utilize-split")
+    return pytest.param(
+        input1.reverse().split(outputs=2).video(0).output(filename="tmp.mp4"),
+        id="not-utilize-split",
+    )
 
 
 def redundant_split_outputs_1() -> Any:
@@ -38,7 +41,11 @@ def reduntant_split_duplicate() -> Any:
 
 def reuse_input() -> Any:
     input_stream = input("input.mp4")
-    graph = concat(input_stream.video, input_stream.video).video(0).output(filename="tmp.mp4")
+    graph = (
+        concat(input_stream.video, input_stream.video)
+        .video(0)
+        .output(filename="tmp.mp4")
+    )
     return pytest.param(graph, id="reuse-input")
 
 
@@ -64,18 +71,18 @@ def complex_stream() -> Any:
 def amix_stream() -> Any:
     input1 = input("input1.mp4")
 
-    graph = amix(input1.audio.areverse().areverse(), input1.audio.areverse(), duration="first").output(
-        filename="tmp.mp4"
-    )
+    graph = amix(
+        input1.audio.areverse().areverse(), input1.audio.areverse(), duration="first"
+    ).output(filename="tmp.mp4")
     return pytest.param(graph, id="amix-stream")
 
 
 def amix_stream_2() -> Any:
     input1 = input("input1.mp4")
 
-    graph = amix(input1.audio.areverse(), input1.audio.areverse().areverse(), duration="first").output(
-        filename="tmp.mp4"
-    )
+    graph = amix(
+        input1.audio.areverse(), input1.audio.areverse().areverse(), duration="first"
+    ).output(filename="tmp.mp4")
     return pytest.param(graph, id="amix-stream-2")
 
 
@@ -102,12 +109,19 @@ def test_rebuild_graph(graph: Stream, snapshot: SnapshotAssertion) -> None:
 
     assert snapshot(name="before", extension_class=DAGSnapshotExtenstion) == graph.node
     removed_split = remove_split(graph)
-    assert snapshot(name="remove-split", extension_class=DAGSnapshotExtenstion) == removed_split[0].node
+    assert (
+        snapshot(name="remove-split", extension_class=DAGSnapshotExtenstion)
+        == removed_split[0].node
+    )
 
     added_split = add_split(removed_split[0])
-    assert snapshot(name="add-split", extension_class=DAGSnapshotExtenstion) == added_split[0].node
+    assert (
+        snapshot(name="add-split", extension_class=DAGSnapshotExtenstion)
+        == added_split[0].node
+    )
 
 
 class Validator(Protocol):
-    def __call__(self, context: DAGContext = ..., auto_fix: bool = False) -> DAGContext:
-        ...
+    def __call__(
+        self, context: DAGContext = ..., auto_fix: bool = False
+    ) -> DAGContext: ...
diff --git a/src/ffmpeg/dag/validate.py b/src/ffmpeg/dag/validate.py
index d03b2f72..1e236076 100644
--- a/src/ffmpeg/dag/validate.py
+++ b/src/ffmpeg/dag/validate.py
@@ -10,7 +10,9 @@
 from .schema import Node, Stream
 
 
-def remove_split(current_stream: Stream, mapping: dict[Stream, Stream] = None) -> tuple[Stream, dict[Stream, Stream]]:
+def remove_split(
+    current_stream: Stream, mapping: dict[Stream, Stream] = None
+) -> tuple[Stream, dict[Stream, Stream]]:
     """
     Rebuild the graph with the given mapping.
 
@@ -37,20 +39,28 @@ def remove_split(current_stream: Stream, mapping: dict[Stream, Stream] = None) -
     if isinstance(current_stream.node, FilterNode):
         # if the current node is a split node, we need to remove it
         if current_stream.node.name in ("split", "asplit"):
-            new_stream, _mapping = remove_split(current_stream=current_stream.node.inputs[0], mapping=mapping)
+            new_stream, _mapping = remove_split(
+                current_stream=current_stream.node.inputs[0], mapping=mapping
+            )
             mapping[current_stream] = mapping[current_stream.node.inputs[0]]
             return mapping[current_stream.node.inputs[0]], mapping
 
     inputs = {}
     for idx, input_stream in sorted(
-        enumerate(current_stream.node.inputs), key=lambda idx_stream: -len(idx_stream[1].node.upstream_nodes)
+        enumerate(current_stream.node.inputs),
+        key=lambda idx_stream: -len(idx_stream[1].node.upstream_nodes),
     ):
-        new_stream, _mapping = remove_split(current_stream=input_stream, mapping=mapping)
+        new_stream, _mapping = remove_split(
+            current_stream=input_stream, mapping=mapping
+        )
         inputs[idx] = new_stream
         mapping |= _mapping
 
     new_node = replace(
-        current_stream.node, inputs=tuple(stream for idx, stream in sorted(inputs.items(), key=lambda x: x[0]))
+        current_stream.node,
+        inputs=tuple(
+            stream for idx, stream in sorted(inputs.items(), key=lambda x: x[0])
+        ),
     )
     new_stream = replace(current_stream, node=new_node)
 
@@ -91,16 +101,24 @@ def add_split(
     inputs = {}
 
     for idx, input_stream in sorted(
-        enumerate(current_stream.node.inputs), key=lambda idx_stream: -len(idx_stream[1].node.upstream_nodes)
+        enumerate(current_stream.node.inputs),
+        key=lambda idx_stream: -len(idx_stream[1].node.upstream_nodes),
     ):
         new_stream, _mapping = add_split(
-            current_stream=input_stream, down_node=current_stream.node, down_index=idx, mapping=mapping, context=context
+            current_stream=input_stream,
+            down_node=current_stream.node,
+            down_index=idx,
+            mapping=mapping,
+            context=context,
         )
         inputs[idx] = new_stream
         mapping |= _mapping
 
     new_node = replace(
-        current_stream.node, inputs=tuple(stream for idx, stream in sorted(inputs.items(), key=lambda x: x[0]))
+        current_stream.node,
+        inputs=tuple(
+            stream for idx, stream in sorted(inputs.items(), key=lambda x: x[0])
+        ),
     )
     new_stream = replace(current_stream, node=new_node)
 
diff --git a/src/ffmpeg/filters.py b/src/ffmpeg/filters.py
index 20c20ce7..c3d4acae 100644
--- a/src/ffmpeg/filters.py
+++ b/src/ffmpeg/filters.py
@@ -7,7 +7,19 @@
 from .schema import Auto, Default
 from .streams.audio import AudioStream
 from .streams.video import VideoStream
-from .types import Boolean, Color, Double, Duration, Flags, Float, Image_size, Int, Int64, Pix_fmt, String
+from .types import (
+    Boolean,
+    Color,
+    Double,
+    Duration,
+    Flags,
+    Float,
+    Image_size,
+    Int,
+    Int64,
+    Pix_fmt,
+    String,
+)
 
 
 def acrossfade(
@@ -94,7 +106,11 @@ def acrossfade(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="acrossfade", typings_input=("audio", "audio"), typings_output=("audio",)),
+        FFMpegFilterDef(
+            name="acrossfade",
+            typings_input=("audio", "audio"),
+            typings_output=("audio",),
+        ),
         _crossfade0,
         _crossfade1,
         **{
@@ -112,7 +128,9 @@ def acrossfade(
 def ainterleave(
     *streams: AudioStream,
     nb_inputs: Int = Auto("len(streams)"),
-    duration: Int | Literal["longest", "shortest", "first"] | Default = Default("longest"),
+    duration: Int | Literal["longest", "shortest", "first"] | Default = Default(
+        "longest"
+    ),
     extra_options: dict[str, Any] = None,
 ) -> AudioStream:
     """
@@ -132,7 +150,9 @@ def ainterleave(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(
-            name="ainterleave", typings_input="[StreamType.audio] * int(nb_inputs)", typings_output=("audio",)
+            name="ainterleave",
+            typings_input="[StreamType.audio] * int(nb_inputs)",
+            typings_output=("audio",),
         ),
         *streams,
         **{
@@ -174,7 +194,11 @@ def alphamerge(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="alphamerge", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="alphamerge",
+            typings_input=("video", "video"),
+            typings_output=("video",),
+        ),
         _main,
         _alpha,
         **{
@@ -209,7 +233,11 @@ def amerge(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="amerge", typings_input="[StreamType.audio] * int(inputs)", typings_output=("audio",)),
+        FFMpegFilterDef(
+            name="amerge",
+            typings_input="[StreamType.audio] * int(inputs)",
+            typings_output=("audio",),
+        ),
         *streams,
         **{
             "inputs": inputs,
@@ -222,7 +250,9 @@ def amerge(
 def amix(
     *streams: AudioStream,
     inputs: Int = Auto("len(streams)"),
-    duration: Int | Literal["longest", "shortest", "first"] | Default = Default("longest"),
+    duration: Int | Literal["longest", "shortest", "first"] | Default = Default(
+        "longest"
+    ),
     dropout_transition: Float = Default(2.0),
     weights: String = Default("1 1"),
     normalize: Boolean = Default(True),
@@ -247,7 +277,11 @@ def amix(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="amix", typings_input="[StreamType.audio] * int(inputs)", typings_output=("audio",)),
+        FFMpegFilterDef(
+            name="amix",
+            typings_input="[StreamType.audio] * int(inputs)",
+            typings_output=("audio",),
+        ),
         *streams,
         **{
             "inputs": inputs,
@@ -278,7 +312,11 @@ def amultiply(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="amultiply", typings_input=("audio", "audio"), typings_output=("audio",)),
+        FFMpegFilterDef(
+            name="amultiply",
+            typings_input=("audio", "audio"),
+            typings_output=("audio",),
+        ),
         _multiply0,
         _multiply1,
         **{} | (extra_options or {}),
@@ -318,7 +356,9 @@ def anlmf(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="anlmf", typings_input=("audio", "audio"), typings_output=("audio",)),
+        FFMpegFilterDef(
+            name="anlmf", typings_input=("audio", "audio"), typings_output=("audio",)
+        ),
         _input,
         _desired,
         **{
@@ -366,7 +406,9 @@ def anlms(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="anlms", typings_input=("audio", "audio"), typings_output=("audio",)),
+        FFMpegFilterDef(
+            name="anlms", typings_input=("audio", "audio"), typings_output=("audio",)
+        ),
         _input,
         _desired,
         **{
@@ -404,7 +446,9 @@ def apsnr(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="apsnr", typings_input=("audio", "audio"), typings_output=("audio",)),
+        FFMpegFilterDef(
+            name="apsnr", typings_input=("audio", "audio"), typings_output=("audio",)
+        ),
         _input0,
         _input1,
         **{
@@ -445,7 +489,9 @@ def arls(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="arls", typings_input=("audio", "audio"), typings_output=("audio",)),
+        FFMpegFilterDef(
+            name="arls", typings_input=("audio", "audio"), typings_output=("audio",)
+        ),
         _input,
         _desired,
         **{
@@ -482,7 +528,9 @@ def asdr(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="asdr", typings_input=("audio", "audio"), typings_output=("audio",)),
+        FFMpegFilterDef(
+            name="asdr", typings_input=("audio", "audio"), typings_output=("audio",)
+        ),
         _input0,
         _input1,
         **{
@@ -515,7 +563,9 @@ def asisdr(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="asisdr", typings_input=("audio", "audio"), typings_output=("audio",)),
+        FFMpegFilterDef(
+            name="asisdr", typings_input=("audio", "audio"), typings_output=("audio",)
+        ),
         _input0,
         _input1,
         **{
@@ -589,7 +639,11 @@ def axcorrelate(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="axcorrelate", typings_input=("audio", "audio"), typings_output=("audio",)),
+        FFMpegFilterDef(
+            name="axcorrelate",
+            typings_input=("audio", "audio"),
+            typings_output=("audio",),
+        ),
         _axcorrelate0,
         _axcorrelate1,
         **{
@@ -886,7 +940,9 @@ def blend(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="blend", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="blend", typings_input=("video", "video"), typings_output=("video",)
+        ),
         _top,
         _bottom,
         **{
@@ -1014,7 +1070,11 @@ def colormap(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="colormap", typings_input=("video", "video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="colormap",
+            typings_input=("video", "video", "video"),
+            typings_output=("video",),
+        ),
         _default,
         _source,
         _target,
@@ -1111,7 +1171,9 @@ def convolve(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="convolve", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="convolve", typings_input=("video", "video"), typings_output=("video",)
+        ),
         _main,
         _impulse,
         **{
@@ -1159,7 +1221,9 @@ def corr(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="corr", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="corr", typings_input=("video", "video"), typings_output=("video",)
+        ),
         _main,
         _reference,
         **{
@@ -1265,7 +1329,11 @@ def deconvolve(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="deconvolve", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="deconvolve",
+            typings_input=("video", "video"),
+            typings_output=("video",),
+        ),
         _main,
         _impulse,
         **{
@@ -1288,7 +1356,9 @@ def displace(
     _xmap: VideoStream,
     _ymap: VideoStream,
     *,
-    edge: Int | Literal["blank", "smear", "wrap", "mirror"] | Default = Default("smear"),
+    edge: Int | Literal["blank", "smear", "wrap", "mirror"] | Default = Default(
+        "smear"
+    ),
     enable: String = Default(None),
     extra_options: dict[str, Any] = None,
 ) -> VideoStream:
@@ -1308,7 +1378,11 @@ def displace(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="displace", typings_input=("video", "video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="displace",
+            typings_input=("video", "video", "video"),
+            typings_output=("video",),
+        ),
         _source,
         _xmap,
         _ymap,
@@ -1328,7 +1402,10 @@ def feedback(
     x: Int = Default(0),
     w: Int = Default(0),
     extra_options: dict[str, Any] = None,
-) -> tuple[VideoStream, VideoStream,]:
+) -> tuple[
+    VideoStream,
+    VideoStream,
+]:
     """
 
     Apply feedback video filter.
@@ -1346,7 +1423,11 @@ def feedback(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="feedback", typings_input=("video", "video"), typings_output=("video", "video")),
+        FFMpegFilterDef(
+            name="feedback",
+            typings_input=("video", "video"),
+            typings_output=("video", "video"),
+        ),
         _default,
         _feedin,
         **{
@@ -1364,7 +1445,9 @@ def feedback(
 def fieldmatch(
     *streams: VideoStream,
     order: Int | Literal["auto", "bff", "tff"] | Default = Default("auto"),
-    mode: Int | Literal["pc", "pc_n", "pc_u", "pc_n_ub", "pcn", "pcn_ub"] | Default = Default("pc_n"),
+    mode: Int
+    | Literal["pc", "pc_n", "pc_u", "pc_n_ub", "pcn", "pcn_ub"]
+    | Default = Default("pc_n"),
     ppsrc: Boolean = Default(False),
     field: Int | Literal["auto", "bottom", "top"] | Default = Default("auto"),
     mchroma: Boolean = Default(True),
@@ -1438,7 +1521,9 @@ def framepack(
     _left: VideoStream,
     _right: VideoStream,
     *,
-    format: Int | Literal["sbs", "tab", "frameseq", "lines", "columns"] | Default = Default("sbs"),
+    format: Int
+    | Literal["sbs", "tab", "frameseq", "lines", "columns"]
+    | Default = Default("sbs"),
     extra_options: dict[str, Any] = None,
 ) -> VideoStream:
     """
@@ -1456,7 +1541,11 @@ def framepack(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="framepack", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="framepack",
+            typings_input=("video", "video"),
+            typings_output=("video",),
+        ),
         _left,
         _right,
         **{
@@ -1493,7 +1582,11 @@ def freezeframes(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="freezeframes", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="freezeframes",
+            typings_input=("video", "video"),
+            typings_output=("video",),
+        ),
         _source,
         _replace,
         **{
@@ -1563,7 +1656,9 @@ def haldclut(
     _clut: VideoStream,
     *,
     clut: Int | Literal["first", "all"] | Default = Default("all"),
-    interp: Int | Literal["nearest", "trilinear", "tetrahedral", "pyramid", "prism"] | Default = Default("tetrahedral"),
+    interp: Int
+    | Literal["nearest", "trilinear", "tetrahedral", "pyramid", "prism"]
+    | Default = Default("tetrahedral"),
     eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
     shortest: Boolean = Default(False),
     repeatlast: Boolean = Default(True),
@@ -1592,7 +1687,9 @@ def haldclut(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="haldclut", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="haldclut", typings_input=("video", "video"), typings_output=("video",)
+        ),
         _main,
         _clut,
         **{
@@ -1680,7 +1777,11 @@ def hstack(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="hstack", typings_input="[StreamType.video] * int(inputs)", typings_output=("video",)),
+        FFMpegFilterDef(
+            name="hstack",
+            typings_input="[StreamType.video] * int(inputs)",
+            typings_output=("video",),
+        ),
         *streams,
         **{
             "inputs": inputs,
@@ -1725,7 +1826,11 @@ def hysteresis(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="hysteresis", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="hysteresis",
+            typings_input=("video", "video"),
+            typings_output=("video",),
+        ),
         _base,
         _alt,
         **{
@@ -1772,7 +1877,9 @@ def identity(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="identity", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="identity", typings_input=("video", "video"), typings_output=("video",)
+        ),
         _main,
         _reference,
         **{
@@ -1790,7 +1897,9 @@ def identity(
 def interleave(
     *streams: VideoStream,
     nb_inputs: Int = Auto("len(streams)"),
-    duration: Int | Literal["longest", "shortest", "first"] | Default = Default("longest"),
+    duration: Int | Literal["longest", "shortest", "first"] | Default = Default(
+        "longest"
+    ),
     extra_options: dict[str, Any] = None,
 ) -> VideoStream:
     """
@@ -1810,7 +1919,9 @@ def interleave(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(
-            name="interleave", typings_input="[StreamType.video] * int(nb_inputs)", typings_output=("video",)
+            name="interleave",
+            typings_input="[StreamType.video] * int(nb_inputs)",
+            typings_output=("video",),
         ),
         *streams,
         **{
@@ -1846,7 +1957,11 @@ def join(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="join", typings_input="[StreamType.audio] * int(inputs)", typings_output=("audio",)),
+        FFMpegFilterDef(
+            name="join",
+            typings_input="[StreamType.audio] * int(inputs)",
+            typings_output=("audio",),
+        ),
         *streams,
         **{
             "inputs": inputs,
@@ -1900,7 +2015,9 @@ def libvmaf(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="libvmaf", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="libvmaf", typings_input=("video", "video"), typings_output=("video",)
+        ),
         _main,
         _reference,
         **{
@@ -2007,7 +2124,9 @@ def lut2(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="lut2", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="lut2", typings_input=("video", "video"), typings_output=("video",)
+        ),
         _srcx,
         _srcy,
         **{
@@ -2056,7 +2175,11 @@ def maskedclamp(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="maskedclamp", typings_input=("video", "video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="maskedclamp",
+            typings_input=("video", "video", "video"),
+            typings_output=("video",),
+        ),
         _base,
         _dark,
         _bright,
@@ -2096,7 +2219,11 @@ def maskedmax(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="maskedmax", typings_input=("video", "video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="maskedmax",
+            typings_input=("video", "video", "video"),
+            typings_output=("video",),
+        ),
         _source,
         _filter1,
         _filter2,
@@ -2134,7 +2261,11 @@ def maskedmerge(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="maskedmerge", typings_input=("video", "video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="maskedmerge",
+            typings_input=("video", "video", "video"),
+            typings_output=("video",),
+        ),
         _base,
         _overlay,
         _mask,
@@ -2172,7 +2303,11 @@ def maskedmin(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="maskedmin", typings_input=("video", "video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="maskedmin",
+            typings_input=("video", "video", "video"),
+            typings_output=("video",),
+        ),
         _source,
         _filter1,
         _filter2,
@@ -2213,7 +2348,11 @@ def maskedthreshold(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="maskedthreshold", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="maskedthreshold",
+            typings_input=("video", "video"),
+            typings_output=("video",),
+        ),
         _source,
         _reference,
         **{
@@ -2312,7 +2451,11 @@ def midequalizer(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="midequalizer", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="midequalizer",
+            typings_input=("video", "video"),
+            typings_output=("video",),
+        ),
         _in0,
         _in1,
         **{
@@ -2330,7 +2473,9 @@ def mix(
     weights: String = Default("1 1"),
     scale: Float = Default(0.0),
     planes: Flags = Default("F"),
-    duration: Int | Literal["longest", "shortest", "first"] | Default = Default("longest"),
+    duration: Int | Literal["longest", "shortest", "first"] | Default = Default(
+        "longest"
+    ),
     enable: String = Default(None),
     extra_options: dict[str, Any] = None,
 ) -> VideoStream:
@@ -2354,7 +2499,11 @@ def mix(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="mix", typings_input="[StreamType.video] * int(inputs)", typings_output=("video",)),
+        FFMpegFilterDef(
+            name="mix",
+            typings_input="[StreamType.video] * int(inputs)",
+            typings_output=("video",),
+        ),
         *streams,
         **{
             "inputs": inputs,
@@ -2407,7 +2556,9 @@ def morpho(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="morpho", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="morpho", typings_input=("video", "video"), typings_output=("video",)
+        ),
         _default,
         _structure,
         **{
@@ -2455,7 +2606,9 @@ def msad(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="msad", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="msad", typings_input=("video", "video"), typings_output=("video",)
+        ),
         _main,
         _reference,
         **{
@@ -2498,7 +2651,9 @@ def multiply(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="multiply", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="multiply", typings_input=("video", "video"), typings_output=("video",)
+        ),
         _source,
         _factor,
         **{
@@ -2518,11 +2673,23 @@ def overlay(
     *,
     x: String = Default("0"),
     y: String = Default("0"),
-    eof_action: Int | Literal["repeat", "endall", "pass", "repeat", "endall", "pass"] | Default = Default("repeat"),
+    eof_action: Int
+    | Literal["repeat", "endall", "pass", "repeat", "endall", "pass"]
+    | Default = Default("repeat"),
     eval: Int | Literal["init", "frame"] | Default = Default("frame"),
     shortest: Boolean = Default(False),
     format: Int
-    | Literal["yuv420", "yuv420p10", "yuv422", "yuv422p10", "yuv444", "yuv444p10", "rgb", "gbrp", "auto"]
+    | Literal[
+        "yuv420",
+        "yuv420p10",
+        "yuv422",
+        "yuv422p10",
+        "yuv444",
+        "yuv444p10",
+        "rgb",
+        "gbrp",
+        "auto",
+    ]
     | Default = Default("yuv420"),
     repeatlast: Boolean = Default(True),
     alpha: Int | Literal["straight", "premultiplied"] | Default = Default("straight"),
@@ -2554,7 +2721,9 @@ def overlay(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="overlay", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="overlay", typings_input=("video", "video"), typings_output=("video",)
+        ),
         _main,
         _overlay,
         **{
@@ -2579,7 +2748,16 @@ def paletteuse(
     _palette: VideoStream,
     *,
     dither: Int
-    | Literal["bayer", "heckbert", "floyd_steinberg", "sierra2", "sierra2_4a", "sierra3", "burkes", "atkinson"]
+    | Literal[
+        "bayer",
+        "heckbert",
+        "floyd_steinberg",
+        "sierra2",
+        "sierra2_4a",
+        "sierra3",
+        "burkes",
+        "atkinson",
+    ]
     | Default = Default("sierra2_4a"),
     bayer_scale: Int = Default(2),
     diff_mode: Int | Literal["rectangle"] | Default = Default(0),
@@ -2608,7 +2786,11 @@ def paletteuse(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="paletteuse", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="paletteuse",
+            typings_input=("video", "video"),
+            typings_output=("video",),
+        ),
         _default,
         _palette,
         **{
@@ -2700,7 +2882,9 @@ def psnr(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="psnr", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="psnr", typings_input=("video", "video"), typings_output=("video",)
+        ),
         _main,
         _reference,
         **{
@@ -2743,7 +2927,11 @@ def remap(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="remap", typings_input=("video", "video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="remap",
+            typings_input=("video", "video", "video"),
+            typings_output=("video",),
+        ),
         _source,
         _xmap,
         _ymap,
@@ -2800,7 +2988,11 @@ def sidechaincompress(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="sidechaincompress", typings_input=("audio", "audio"), typings_output=("audio",)),
+        FFMpegFilterDef(
+            name="sidechaincompress",
+            typings_input=("audio", "audio"),
+            typings_output=("audio",),
+        ),
         _main,
         _sidechain,
         **{
@@ -2868,7 +3060,11 @@ def sidechaingate(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="sidechaingate", typings_input=("audio", "audio"), typings_output=("audio",)),
+        FFMpegFilterDef(
+            name="sidechaingate",
+            typings_input=("audio", "audio"),
+            typings_output=("audio",),
+        ),
         _main,
         _sidechain,
         **{
@@ -2928,7 +3124,9 @@ def signature(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(
-            name="signature", typings_input="[StreamType.video] * int(nb_inputs)", typings_output=("video",)
+            name="signature",
+            typings_input="[StreamType.video] * int(nb_inputs)",
+            typings_output=("video",),
         ),
         *streams,
         **{
@@ -2954,7 +3152,9 @@ def spectrumsynth(
     sample_rate: Int = Default(44100),
     channels: Int = Default(1),
     scale: Int | Literal["lin", "log"] | Default = Default("log"),
-    slide: Int | Literal["replace", "scroll", "fullframe", "rscroll"] | Default = Default("fullframe"),
+    slide: Int
+    | Literal["replace", "scroll", "fullframe", "rscroll"]
+    | Default = Default("fullframe"),
     win_func: Int
     | Literal[
         "rect",
@@ -2982,7 +3182,9 @@ def spectrumsynth(
     ]
     | Default = Default("rect"),
     overlap: Float = Default(1.0),
-    orientation: Int | Literal["vertical", "horizontal"] | Default = Default("vertical"),
+    orientation: Int | Literal["vertical", "horizontal"] | Default = Default(
+        "vertical"
+    ),
     extra_options: dict[str, Any] = None,
 ) -> AudioStream:
     """
@@ -3006,7 +3208,11 @@ def spectrumsynth(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="spectrumsynth", typings_input=("video", "video"), typings_output=("audio",)),
+        FFMpegFilterDef(
+            name="spectrumsynth",
+            typings_input=("video", "video"),
+            typings_output=("audio",),
+        ),
         _magnitude,
         _phase,
         **{
@@ -3055,7 +3261,9 @@ def ssim(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="ssim", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="ssim", typings_input=("video", "video"), typings_output=("video",)
+        ),
         _main,
         _reference,
         **{
@@ -3137,7 +3345,9 @@ def threshold(
     """
     filter_node = filter_node_factory(
         FFMpegFilterDef(
-            name="threshold", typings_input=("video", "video", "video", "video"), typings_output=("video",)
+            name="threshold",
+            typings_input=("video", "video", "video", "video"),
+            typings_output=("video",),
         ),
         _default,
         _threshold,
@@ -3228,7 +3438,9 @@ def varblur(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="varblur", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="varblur", typings_input=("video", "video"), typings_output=("video",)
+        ),
         _default,
         _radius,
         **{
@@ -3276,7 +3488,9 @@ def vif(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="vif", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="vif", typings_input=("video", "video"), typings_output=("video",)
+        ),
         _main,
         _reference,
         **{
@@ -3313,7 +3527,11 @@ def vstack(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="vstack", typings_input="[StreamType.video] * int(inputs)", typings_output=("video",)),
+        FFMpegFilterDef(
+            name="vstack",
+            typings_input="[StreamType.video] * int(inputs)",
+            typings_output=("video",),
+        ),
         *streams,
         **{
             "inputs": inputs,
@@ -3358,7 +3576,11 @@ def xcorrelate(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="xcorrelate", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="xcorrelate",
+            typings_input=("video", "video"),
+            typings_output=("video",),
+        ),
         _primary,
         _secondary,
         **{
@@ -3465,7 +3687,9 @@ def xfade(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="xfade", typings_input=("video", "video"), typings_output=("video",)),
+        FFMpegFilterDef(
+            name="xfade", typings_input=("video", "video"), typings_output=("video",)
+        ),
         _main,
         _xfade,
         **{
@@ -3513,7 +3737,11 @@ def xmedian(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="xmedian", typings_input="[StreamType.video] * int(inputs)", typings_output=("video",)),
+        FFMpegFilterDef(
+            name="xmedian",
+            typings_input="[StreamType.video] * int(inputs)",
+            typings_output=("video",),
+        ),
         *streams,
         **{
             "inputs": inputs,
@@ -3558,7 +3786,11 @@ def xstack(
 
     """
     filter_node = filter_node_factory(
-        FFMpegFilterDef(name="xstack", typings_input="[StreamType.video] * int(inputs)", typings_output=("video",)),
+        FFMpegFilterDef(
+            name="xstack",
+            typings_input="[StreamType.video] * int(inputs)",
+            typings_output=("video",),
+        ),
         *streams,
         **{
             "inputs": inputs,
diff --git a/src/ffmpeg/probe.py b/src/ffmpeg/probe.py
index 46885edb..da89de39 100644
--- a/src/ffmpeg/probe.py
+++ b/src/ffmpeg/probe.py
@@ -11,7 +11,12 @@
 logger = logging.getLogger(__name__)
 
 
-def probe(filename: str | Path, cmd: str = "ffprobe", timeout: int | None = None, **kwargs: Any) -> dict[str, Any]:
+def probe(
+    filename: str | Path,
+    cmd: str = "ffprobe",
+    timeout: int | None = None,
+    **kwargs: Any,
+) -> dict[str, Any]:
     """
     Run ffprobe on the given file and return a JSON representation of the output
 
@@ -38,6 +43,8 @@ def probe(filename: str | Path, cmd: str = "ffprobe", timeout: int | None = None
 
     retcode = p.poll()
     if p.returncode != 0:
-        raise FFMpegExecuteError(retcode=retcode, cmd=command_line(args), stdout=out, stderr=err)
+        raise FFMpegExecuteError(
+            retcode=retcode, cmd=command_line(args), stdout=out, stderr=err
+        )
 
     return json.loads(out.decode("utf-8"))
diff --git a/src/ffmpeg/schema.py b/src/ffmpeg/schema.py
index 14eff148..1316d69c 100644
--- a/src/ffmpeg/schema.py
+++ b/src/ffmpeg/schema.py
@@ -2,7 +2,6 @@
 Defines the basic schema for the ffmpeg command line options.
 """
 
-
 from .common.schema import StreamType
 
 
diff --git a/src/ffmpeg/streams/audio.py b/src/ffmpeg/streams/audio.py
index 3cdec9f6..376b656a 100644
--- a/src/ffmpeg/streams/audio.py
+++ b/src/ffmpeg/streams/audio.py
@@ -9,7 +9,20 @@
 from ..dag.factory import filter_node_factory
 from ..dag.nodes import FilterableStream, FilterNode
 from ..schema import Default
-from ..types import Boolean, Color, Double, Duration, Flags, Float, Image_size, Int, Int64, Rational, String, Video_rate
+from ..types import (
+    Boolean,
+    Color,
+    Double,
+    Duration,
+    Flags,
+    Float,
+    Image_size,
+    Int,
+    Int64,
+    Rational,
+    String,
+    Video_rate,
+)
 
 if TYPE_CHECKING:
     from .video import VideoStream
@@ -53,7 +66,9 @@ def a3dscope(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="a3dscope", typings_input=("audio",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="a3dscope", typings_input=("audio",), typings_output=("video",)
+            ),
             self,
             **{
                 "rate": rate,
@@ -91,7 +106,9 @@ def abench(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="abench", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="abench", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "action": action,
@@ -105,7 +122,9 @@ def abitscope(
         *,
         rate: Video_rate = Default("25"),
         size: Image_size = Default("1024x256"),
-        colors: String = Default("red|green|blue|yellow|orange|lime|pink|magenta|brown"),
+        colors: String = Default(
+            "red|green|blue|yellow|orange|lime|pink|magenta|brown"
+        ),
         mode: Int | Literal["bars", "trace"] | Default = Default("bars"),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -127,7 +146,9 @@ def abitscope(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="abitscope", typings_input=("audio",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="abitscope", typings_input=("audio",), typings_output=("video",)
+            ),
             self,
             **{
                 "rate": rate,
@@ -182,7 +203,9 @@ def acompressor(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="acompressor", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="acompressor", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "level_in": level_in,
@@ -223,7 +246,9 @@ def acontrast(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="acontrast", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="acontrast", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "contrast": contrast,
@@ -248,7 +273,9 @@ def acopy(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="acopy", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="acopy", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{} | (extra_options or {}),
         )
@@ -338,7 +365,11 @@ def acrossfade(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="acrossfade", typings_input=("audio", "audio"), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="acrossfade",
+                typings_input=("audio", "audio"),
+                typings_output=("audio",),
+            ),
             self,
             _crossfade1,
             **{
@@ -357,7 +388,9 @@ def acrossover(
         *,
         split: String = Default("500"),
         order: Int
-        | Literal["2nd", "4th", "6th", "8th", "10th", "12th", "14th", "16th", "18th", "20th"]
+        | Literal[
+            "2nd", "4th", "6th", "8th", "10th", "12th", "14th", "16th", "18th", "20th"
+        ]
         | Default = Default("4th"),
         level: Float = Default(1.0),
         gain: String = Default("1.f"),
@@ -445,7 +478,9 @@ def acrusher(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="acrusher", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="acrusher", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "level_in": level_in,
@@ -490,7 +525,9 @@ def acue(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="acue", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="acue", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "cue": cue,
@@ -534,7 +571,9 @@ def adeclick(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="adeclick", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="adeclick", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "window": window,
@@ -582,7 +621,9 @@ def adeclip(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="adeclip", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="adeclip", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "window": window,
@@ -622,7 +663,9 @@ def adecorrelate(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="adecorrelate", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="adecorrelate", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "stages": stages,
@@ -658,7 +701,9 @@ def adelay(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="adelay", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="adelay", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "delays": delays,
@@ -694,7 +739,9 @@ def adenorm(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="adenorm", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="adenorm", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "level": level,
@@ -726,7 +773,9 @@ def aderivative(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="aderivative", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="aderivative", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "enable": enable,
@@ -750,7 +799,9 @@ def adrawgraph(
         min: Float = Default(-1.0),
         max: Float = Default(1.0),
         mode: Int | Literal["bar", "dot", "line"] | Default = Default("line"),
-        slide: Int | Literal["frame", "replace", "scroll", "rscroll", "picture"] | Default = Default("frame"),
+        slide: Int
+        | Literal["frame", "replace", "scroll", "rscroll", "picture"]
+        | Default = Default("frame"),
         size: Image_size = Default("900x256"),
         rate: Video_rate = Default("25"),
         extra_options: dict[str, Any] = None,
@@ -784,7 +835,9 @@ def adrawgraph(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="adrawgraph", typings_input=("audio",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="adrawgraph", typings_input=("audio",), typings_output=("video",)
+            ),
             self,
             **{
                 "m1": m1,
@@ -836,7 +889,9 @@ def adrc(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="adrc", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="adrc", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "transfer": transfer,
@@ -863,8 +918,12 @@ def adynamicequalizer(
         makeup: Double = Default(0.0),
         range: Double = Default(50.0),
         mode: Int | Literal["listen", "cut", "boost"] | Default = Default("cut"),
-        dftype: Int | Literal["bandpass", "lowpass", "highpass", "peak"] | Default = Default("bandpass"),
-        tftype: Int | Literal["bell", "lowshelf", "highshelf"] | Default = Default("bell"),
+        dftype: Int
+        | Literal["bandpass", "lowpass", "highpass", "peak"]
+        | Default = Default("bandpass"),
+        tftype: Int | Literal["bell", "lowshelf", "highshelf"] | Default = Default(
+            "bell"
+        ),
         direction: Int | Literal["downward", "upward"] | Default = Default("downward"),
         auto: Int | Literal["disabled", "off", "on"] | Default = Default("disabled"),
         precision: Int | Literal["auto", "float", "double"] | Default = Default("auto"),
@@ -902,7 +961,11 @@ def adynamicequalizer(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="adynamicequalizer", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="adynamicequalizer",
+                typings_input=("audio",),
+                typings_output=("audio",),
+            ),
             self,
             **{
                 "threshold": threshold,
@@ -952,7 +1015,11 @@ def adynamicsmooth(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="adynamicsmooth", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="adynamicsmooth",
+                typings_input=("audio",),
+                typings_output=("audio",),
+            ),
             self,
             **{
                 "sensitivity": sensitivity,
@@ -990,7 +1057,9 @@ def aecho(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="aecho", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="aecho", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "in_gain": in_gain,
@@ -1007,7 +1076,9 @@ def aemphasis(
         *,
         level_in: Double = Default(1.0),
         level_out: Double = Default(1.0),
-        mode: Int | Literal["reproduction", "production"] | Default = Default("reproduction"),
+        mode: Int | Literal["reproduction", "production"] | Default = Default(
+            "reproduction"
+        ),
         type: Int
         | Literal["col", "emi", "bsi", "riaa", "cd", "50fm", "75fm", "50kf", "75kf"]
         | Default = Default("cd"),
@@ -1033,7 +1104,9 @@ def aemphasis(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="aemphasis", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="aemphasis", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "level_in": level_in,
@@ -1071,7 +1144,9 @@ def aeval(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="aeval", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="aeval", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "exprs": exprs,
@@ -1119,7 +1194,9 @@ def aexciter(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="aexciter", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="aexciter", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "level_in": level_in,
@@ -1200,7 +1277,9 @@ def afade(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="afade", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="afade", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "type": type,
@@ -1229,12 +1308,18 @@ def afftdn(
         residual_floor: Float = Default(-38.0),
         track_noise: Boolean = Default(False),
         track_residual: Boolean = Default(False),
-        output_mode: Int | Literal["input", "i", "output", "o", "noise", "n"] | Default = Default("output"),
+        output_mode: Int
+        | Literal["input", "i", "output", "o", "noise", "n"]
+        | Default = Default("output"),
         adaptivity: Float = Default(0.5),
         floor_offset: Float = Default(1.0),
-        noise_link: Int | Literal["none", "min", "max", "average"] | Default = Default("min"),
+        noise_link: Int | Literal["none", "min", "max", "average"] | Default = Default(
+            "min"
+        ),
         band_multiplier: Float = Default(1.25),
-        sample_noise: Int | Literal["none", "start", "begin", "stop", "end"] | Default = Default("none"),
+        sample_noise: Int
+        | Literal["none", "start", "begin", "stop", "end"]
+        | Default = Default("none"),
         gain_smooth: Int = Default(0),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
@@ -1268,7 +1353,9 @@ def afftdn(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="afftdn", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="afftdn", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "noise_reduction": noise_reduction,
@@ -1347,7 +1434,9 @@ def afftfilt(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="afftfilt", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="afftfilt", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "real": real,
@@ -1386,7 +1475,9 @@ def aformat(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="aformat", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="aformat", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "sample_fmts": sample_fmts,
@@ -1424,7 +1515,9 @@ def afreqshift(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="afreqshift", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="afreqshift", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "shift": shift,
@@ -1441,7 +1534,9 @@ def afwtdn(
         *,
         sigma: Double = Default(0.0),
         levels: Int = Default(10),
-        wavet: Int | Literal["sym2", "sym4", "rbior68", "deb10", "sym10", "coif5", "bl3"] | Default = Default("sym10"),
+        wavet: Int
+        | Literal["sym2", "sym4", "rbior68", "deb10", "sym10", "coif5", "bl3"]
+        | Default = Default("sym10"),
         percent: Double = Default(85.0),
         profile: Boolean = Default(False),
         adaptive: Boolean = Default(False),
@@ -1473,7 +1568,9 @@ def afwtdn(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="afwtdn", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="afwtdn", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "sigma": sigma,
@@ -1535,7 +1632,9 @@ def agate(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="agate", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="agate", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "level_in": level_in,
@@ -1561,7 +1660,9 @@ def agraphmonitor(
         *,
         size: Image_size = Default("hd720"),
         opacity: Float = Default(0.9),
-        mode: Flags | Literal["full", "compact", "nozero", "noeof", "nodisabled"] | Default = Default("0"),
+        mode: Flags
+        | Literal["full", "compact", "nozero", "noeof", "nodisabled"]
+        | Default = Default("0"),
         flags: Flags
         | Literal[
             "none",
@@ -1607,7 +1708,11 @@ def agraphmonitor(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="agraphmonitor", typings_input=("audio",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="agraphmonitor",
+                typings_input=("audio",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "size": size,
@@ -1626,7 +1731,9 @@ def ahistogram(
         dmode: Int | Literal["single", "separate"] | Default = Default("single"),
         rate: Video_rate = Default("25"),
         size: Image_size = Default("hd720"),
-        scale: Int | Literal["log", "sqrt", "cbrt", "lin", "rlog"] | Default = Default("log"),
+        scale: Int | Literal["log", "sqrt", "cbrt", "lin", "rlog"] | Default = Default(
+            "log"
+        ),
         ascale: Int | Literal["log", "lin"] | Default = Default("log"),
         acount: Int = Default(1),
         rheight: Float = Default(0.1),
@@ -1657,7 +1764,9 @@ def ahistogram(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="ahistogram", typings_input=("audio",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="ahistogram", typings_input=("audio",), typings_output=("video",)
+            ),
             self,
             **{
                 "dmode": dmode,
@@ -1682,7 +1791,9 @@ def aiir(
         gains: String = Default("1|1"),
         dry: Double = Default(1.0),
         wet: Double = Default(1.0),
-        format: Int | Literal["ll", "sf", "tf", "zp", "pr", "pd", "sp"] | Default = Default("zp"),
+        format: Int
+        | Literal["ll", "sf", "tf", "zp", "pr", "pd", "sp"]
+        | Default = Default("zp"),
         process: Int | Literal["d", "s", "p"] | Default = Default("s"),
         precision: Int | Literal["dbl", "flt", "i32", "i16"] | Default = Default("dbl"),
         e: Int | Literal["dbl", "flt", "i32", "i16"] | Default = Default("dbl"),
@@ -1773,7 +1884,9 @@ def aintegral(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="aintegral", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="aintegral", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "enable": enable,
@@ -1803,7 +1916,9 @@ def alatency(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="alatency", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="alatency", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "enable": enable,
@@ -1851,7 +1966,9 @@ def alimiter(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="alimiter", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="alimiter", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "level_in": level_in,
@@ -1879,8 +1996,12 @@ def allpass(
         channels: String = Default("all"),
         normalize: Boolean = Default(False),
         order: Int = Default(2),
-        transform: Int | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"] | Default = Default("di"),
-        precision: Int | Literal["auto", "s16", "s32", "f32", "f64"] | Default = Default("auto"),
+        transform: Int
+        | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"]
+        | Default = Default("di"),
+        precision: Int
+        | Literal["auto", "s16", "s32", "f32", "f64"]
+        | Default = Default("auto"),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> AudioStream:
@@ -1908,7 +2029,9 @@ def allpass(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="allpass", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="allpass", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "frequency": frequency,
@@ -1953,7 +2076,9 @@ def aloop(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="aloop", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="aloop", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "loop": loop,
@@ -1968,11 +2093,15 @@ def aloop(
     def ametadata(
         self,
         *,
-        mode: Int | Literal["select", "add", "modify", "delete", "print"] | Default = Default("select"),
+        mode: Int
+        | Literal["select", "add", "modify", "delete", "print"]
+        | Default = Default("select"),
         key: String = Default(None),
         value: String = Default(None),
         function: Int
-        | Literal["same_str", "starts_with", "less", "equal", "greater", "expr", "ends_with"]
+        | Literal[
+            "same_str", "starts_with", "less", "equal", "greater", "expr", "ends_with"
+        ]
         | Default = Default("same_str"),
         expr: String = Default(None),
         file: String = Default(None),
@@ -2002,7 +2131,9 @@ def ametadata(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="ametadata", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="ametadata", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -2035,7 +2166,11 @@ def amultiply(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="amultiply", typings_input=("audio", "audio"), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="amultiply",
+                typings_input=("audio", "audio"),
+                typings_output=("audio",),
+            ),
             self,
             _multiply1,
             **{} | (extra_options or {}),
@@ -2050,7 +2185,9 @@ def anequalizer(
         size: Image_size = Default("hd720"),
         mgain: Double = Default(60.0),
         fscale: Int | Literal["lin", "log"] | Default = Default("log"),
-        colors: String = Default("red|green|blue|yellow|orange|lime|pink|magenta|brown"),
+        colors: String = Default(
+            "red|green|blue|yellow|orange|lime|pink|magenta|brown"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> FilterNode:
@@ -2127,7 +2264,9 @@ def anlmdn(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="anlmdn", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="anlmdn", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "strength": strength,
@@ -2173,7 +2312,11 @@ def anlmf(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="anlmf", typings_input=("audio", "audio"), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="anlmf",
+                typings_input=("audio", "audio"),
+                typings_output=("audio",),
+            ),
             self,
             _desired,
             **{
@@ -2220,7 +2363,11 @@ def anlms(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="anlms", typings_input=("audio", "audio"), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="anlms",
+                typings_input=("audio", "audio"),
+                typings_output=("audio",),
+            ),
             self,
             _desired,
             **{
@@ -2251,7 +2398,9 @@ def anull(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="anull", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="anull", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{} | (extra_options or {}),
         )
@@ -2288,7 +2437,9 @@ def apad(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="apad", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="apad", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "packet_size": packet_size,
@@ -2305,7 +2456,9 @@ def apad(
     def aperms(
         self,
         *,
-        mode: Int | Literal["none", "ro", "rw", "toggle", "random"] | Default = Default("none"),
+        mode: Int | Literal["none", "ro", "rw", "toggle", "random"] | Default = Default(
+            "none"
+        ),
         seed: Int64 = Default(-1),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
@@ -2327,7 +2480,9 @@ def aperms(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="aperms", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="aperms", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -2412,7 +2567,9 @@ def aphaser(
         delay: Double = Default(3.0),
         decay: Double = Default(0.4),
         speed: Double = Default(0.5),
-        type: Int | Literal["triangular", "t", "sinusoidal", "s"] | Default = Default("triangular"),
+        type: Int | Literal["triangular", "t", "sinusoidal", "s"] | Default = Default(
+            "triangular"
+        ),
         extra_options: dict[str, Any] = None,
     ) -> AudioStream:
         """
@@ -2435,7 +2592,9 @@ def aphaser(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="aphaser", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="aphaser", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "in_gain": in_gain,
@@ -2476,7 +2635,9 @@ def aphaseshift(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="aphaseshift", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="aphaseshift", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "shift": shift,
@@ -2510,7 +2671,11 @@ def apsnr(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="apsnr", typings_input=("audio", "audio"), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="apsnr",
+                typings_input=("audio", "audio"),
+                typings_output=("audio",),
+            ),
             self,
             _input1,
             **{
@@ -2555,7 +2720,9 @@ def apsyclip(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="apsyclip", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="apsyclip", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "level_in": level_in,
@@ -2576,7 +2743,9 @@ def apulsator(
         *,
         level_in: Double = Default(1.0),
         level_out: Double = Default(1.0),
-        mode: Int | Literal["sine", "triangle", "square", "sawup", "sawdown"] | Default = Default("sine"),
+        mode: Int
+        | Literal["sine", "triangle", "square", "sawup", "sawdown"]
+        | Default = Default("sine"),
         amount: Double = Default(1.0),
         offset_l: Double = Default(0.0),
         offset_r: Double = Default(0.5),
@@ -2612,7 +2781,9 @@ def apulsator(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="apulsator", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="apulsator", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "level_in": level_in,
@@ -2654,7 +2825,9 @@ def arealtime(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="arealtime", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="arealtime", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "limit": limit,
@@ -2685,7 +2858,9 @@ def aresample(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="aresample", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="aresample", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "sample_rate": sample_rate,
@@ -2710,7 +2885,9 @@ def areverse(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="areverse", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="areverse", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{} | (extra_options or {}),
         )
@@ -2746,7 +2923,9 @@ def arls(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="arls", typings_input=("audio", "audio"), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="arls", typings_input=("audio", "audio"), typings_output=("audio",)
+            ),
             self,
             _desired,
             **{
@@ -2785,7 +2964,9 @@ def arnndn(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="arnndn", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="arnndn", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "model": model,
@@ -2818,7 +2999,9 @@ def asdr(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="asdr", typings_input=("audio", "audio"), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="asdr", typings_input=("audio", "audio"), typings_output=("audio",)
+            ),
             self,
             _input1,
             **{
@@ -2892,7 +3075,9 @@ def aselect(
         """
         filter_node = filter_node_factory(
             FFMpegFilterDef(
-                name="aselect", typings_input=("audio",), typings_output="[StreamType.audio] * int(outputs)"
+                name="aselect",
+                typings_input=("audio",),
+                typings_output="[StreamType.audio] * int(outputs)",
             ),
             self,
             **{
@@ -2927,7 +3112,9 @@ def asendcmd(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="asendcmd", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="asendcmd", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "commands": commands,
@@ -2962,7 +3149,9 @@ def asetnsamples(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="asetnsamples", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="asetnsamples", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "nb_out_samples": nb_out_samples,
@@ -2994,7 +3183,9 @@ def asetpts(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="asetpts", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="asetpts", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "expr": expr,
@@ -3024,7 +3215,9 @@ def asetrate(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="asetrate", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="asetrate", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "sample_rate": sample_rate,
@@ -3054,7 +3247,9 @@ def asettb(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="asettb", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="asettb", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "expr": expr,
@@ -3079,7 +3274,9 @@ def ashowinfo(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="ashowinfo", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="ashowinfo", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{} | (extra_options or {}),
         )
@@ -3134,7 +3331,9 @@ def asidedata(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="asidedata", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="asidedata", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -3167,7 +3366,11 @@ def asisdr(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="asisdr", typings_input=("audio", "audio"), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="asisdr",
+                typings_input=("audio", "audio"),
+                typings_output=("audio",),
+            ),
             self,
             _input1,
             **{
@@ -3181,7 +3384,9 @@ def asoftclip(
         self,
         *,
         type: Int
-        | Literal["hard", "tanh", "atan", "cubic", "exp", "alg", "quintic", "sin", "erf"]
+        | Literal[
+            "hard", "tanh", "atan", "cubic", "exp", "alg", "quintic", "sin", "erf"
+        ]
         | Default = Default("tanh"),
         threshold: Double = Default(1.0),
         output: Double = Default(1.0),
@@ -3210,7 +3415,9 @@ def asoftclip(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="asoftclip", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="asoftclip", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "type": type,
@@ -3296,7 +3503,11 @@ def aspectralstats(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="aspectralstats", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="aspectralstats",
+                typings_input=("audio",),
+                typings_output=("audio",),
+            ),
             self,
             **{
                 "win_size": win_size,
@@ -3331,7 +3542,9 @@ def asplit(
         """
         filter_node = filter_node_factory(
             FFMpegFilterDef(
-                name="asplit", typings_input=("audio",), typings_output="[StreamType.audio] * int(outputs)"
+                name="asplit",
+                typings_input=("audio",),
+                typings_output="[StreamType.audio] * int(outputs)",
             ),
             self,
             **{
@@ -3437,7 +3650,9 @@ def astats(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="astats", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="astats", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "length": length,
@@ -3489,7 +3704,9 @@ def asubboost(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="asubboost", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="asubboost", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "dry": dry,
@@ -3534,7 +3751,9 @@ def asubcut(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="asubcut", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="asubcut", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "cutoff": cutoff,
@@ -3573,7 +3792,9 @@ def asupercut(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="asupercut", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="asupercut", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "cutoff": cutoff,
@@ -3614,7 +3835,9 @@ def asuperpass(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="asuperpass", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="asuperpass", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "centerf": centerf,
@@ -3656,7 +3879,9 @@ def asuperstop(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="asuperstop", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="asuperstop", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "centerf": centerf,
@@ -3690,7 +3915,9 @@ def atempo(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="atempo", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="atempo", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "tempo": tempo,
@@ -3730,7 +3957,9 @@ def atilt(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="atilt", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="atilt", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "freq": freq,
@@ -3777,7 +4006,9 @@ def atrim(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="atrim", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="atrim", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "start": start,
@@ -3795,7 +4026,9 @@ def atrim(
     def avectorscope(
         self,
         *,
-        mode: Int | Literal["lissajous", "lissajous_xy", "polar"] | Default = Default("lissajous"),
+        mode: Int | Literal["lissajous", "lissajous_xy", "polar"] | Default = Default(
+            "lissajous"
+        ),
         rate: Video_rate = Default("25"),
         size: Image_size = Default("400x400"),
         rc: Int = Default(40),
@@ -3843,7 +4076,9 @@ def avectorscope(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="avectorscope", typings_input=("audio",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="avectorscope", typings_input=("audio",), typings_output=("video",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -3891,7 +4126,11 @@ def axcorrelate(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="axcorrelate", typings_input=("audio", "audio"), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="axcorrelate",
+                typings_input=("audio", "audio"),
+                typings_output=("audio",),
+            ),
             self,
             _axcorrelate1,
             **{
@@ -3923,7 +4162,9 @@ def azmq(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="azmq", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="azmq", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "bind_address": bind_address,
@@ -3942,8 +4183,12 @@ def bandpass(
         mix: Double = Default(1.0),
         channels: String = Default("all"),
         normalize: Boolean = Default(False),
-        transform: Int | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"] | Default = Default("di"),
-        precision: Int | Literal["auto", "s16", "s32", "f32", "f64"] | Default = Default("auto"),
+        transform: Int
+        | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"]
+        | Default = Default("di"),
+        precision: Int
+        | Literal["auto", "s16", "s32", "f32", "f64"]
+        | Default = Default("auto"),
         blocksize: Int = Default(0),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
@@ -3973,7 +4218,9 @@ def bandpass(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="bandpass", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="bandpass", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "frequency": frequency,
@@ -4001,8 +4248,12 @@ def bandreject(
         mix: Double = Default(1.0),
         channels: String = Default("all"),
         normalize: Boolean = Default(False),
-        transform: Int | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"] | Default = Default("di"),
-        precision: Int | Literal["auto", "s16", "s32", "f32", "f64"] | Default = Default("auto"),
+        transform: Int
+        | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"]
+        | Default = Default("di"),
+        precision: Int
+        | Literal["auto", "s16", "s32", "f32", "f64"]
+        | Default = Default("auto"),
         blocksize: Int = Default(0),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
@@ -4031,7 +4282,9 @@ def bandreject(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="bandreject", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="bandreject", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "frequency": frequency,
@@ -4060,8 +4313,12 @@ def bass(
         mix: Double = Default(1.0),
         channels: String = Default("all"),
         normalize: Boolean = Default(False),
-        transform: Int | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"] | Default = Default("di"),
-        precision: Int | Literal["auto", "s16", "s32", "f32", "f64"] | Default = Default("auto"),
+        transform: Int
+        | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"]
+        | Default = Default("di"),
+        precision: Int
+        | Literal["auto", "s16", "s32", "f32", "f64"]
+        | Default = Default("auto"),
         blocksize: Int = Default(0),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
@@ -4092,7 +4349,9 @@ def bass(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="bass", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="bass", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "frequency": frequency,
@@ -4120,8 +4379,12 @@ def biquad(
         mix: Double = Default(1.0),
         channels: String = Default("all"),
         normalize: Boolean = Default(False),
-        transform: Int | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"] | Default = Default("di"),
-        precision: Int | Literal["auto", "s16", "s32", "f32", "f64"] | Default = Default("auto"),
+        transform: Int
+        | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"]
+        | Default = Default("di"),
+        precision: Int
+        | Literal["auto", "s16", "s32", "f32", "f64"]
+        | Default = Default("auto"),
         blocksize: Int = Default(0),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
@@ -4149,7 +4412,9 @@ def biquad(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="biquad", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="biquad", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "a0": a0,
@@ -4189,7 +4454,9 @@ def channelmap(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="channelmap", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="channelmap", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "map": map,
@@ -4269,7 +4536,9 @@ def chorus(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="chorus", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="chorus", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "in_gain": in_gain,
@@ -4316,7 +4585,9 @@ def compand(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="compand", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="compand", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "attacks": attacks,
@@ -4364,7 +4635,11 @@ def compensationdelay(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="compensationdelay", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="compensationdelay",
+                typings_input=("audio",),
+                typings_output=("audio",),
+            ),
             self,
             **{
                 "mm": mm,
@@ -4412,7 +4687,9 @@ def crossfeed(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="crossfeed", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="crossfeed", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "strength": strength,
@@ -4452,7 +4729,9 @@ def crystalizer(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="crystalizer", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="crystalizer", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "i": i,
@@ -4488,7 +4767,9 @@ def dcshift(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="dcshift", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="dcshift", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "shift": shift,
@@ -4528,7 +4809,9 @@ def deesser(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="deesser", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="deesser", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "i": i,
@@ -4568,7 +4851,11 @@ def dialoguenhance(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="dialoguenhance", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="dialoguenhance",
+                typings_input=("audio",),
+                typings_output=("audio",),
+            ),
             self,
             **{
                 "original": original,
@@ -4601,7 +4888,9 @@ def drmeter(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="drmeter", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="drmeter", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "length": length,
@@ -4657,7 +4946,9 @@ def dynaudnorm(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="dynaudnorm", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="dynaudnorm", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "framelen": framelen,
@@ -4695,7 +4986,9 @@ def earwax(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="earwax", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="earwax", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{} | (extra_options or {}),
         )
@@ -4713,8 +5006,12 @@ def ebur128(
         dualmono: Boolean = Default(False),
         panlaw: Double = Default(-3.0103),
         target: Int = Default(-23),
-        gauge: Int | Literal["momentary", "m", "shortterm", "s"] | Default = Default("momentary"),
-        scale: Int | Literal["absolute", "LUFS", "relative", "LU"] | Default = Default("absolute"),
+        gauge: Int | Literal["momentary", "m", "shortterm", "s"] | Default = Default(
+            "momentary"
+        ),
+        scale: Int | Literal["absolute", "LUFS", "relative", "LU"] | Default = Default(
+            "absolute"
+        ),
         integrated: Double = Default(0.0),
         range: Double = Default(0.0),
         lra_low: Double = Default(0.0),
@@ -4795,8 +5092,12 @@ def equalizer(
         mix: Double = Default(1.0),
         channels: String = Default("all"),
         normalize: Boolean = Default(False),
-        transform: Int | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"] | Default = Default("di"),
-        precision: Int | Literal["auto", "s16", "s32", "f32", "f64"] | Default = Default("auto"),
+        transform: Int
+        | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"]
+        | Default = Default("di"),
+        precision: Int
+        | Literal["auto", "s16", "s32", "f32", "f64"]
+        | Default = Default("auto"),
         blocksize: Int = Default(0),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
@@ -4826,7 +5127,9 @@ def equalizer(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="equalizer", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="equalizer", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "frequency": frequency,
@@ -4870,7 +5173,9 @@ def extrastereo(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="extrastereo", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="extrastereo", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "m": m,
@@ -4905,9 +5210,13 @@ def firequalizer(
         fixed: Boolean = Default(False),
         multi: Boolean = Default(False),
         zero_phase: Boolean = Default(False),
-        scale: Int | Literal["linlin", "linlog", "loglin", "loglog"] | Default = Default("linlog"),
+        scale: Int
+        | Literal["linlin", "linlog", "loglin", "loglog"]
+        | Default = Default("linlog"),
         dumpfile: String = Default(None),
-        dumpscale: Int | Literal["linlin", "linlog", "loglin", "loglog"] | Default = Default("linlog"),
+        dumpscale: Int
+        | Literal["linlin", "linlog", "loglin", "loglog"]
+        | Default = Default("linlog"),
         fft2: Boolean = Default(False),
         min_phase: Boolean = Default(False),
         extra_options: dict[str, Any] = None,
@@ -4939,7 +5248,9 @@ def firequalizer(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="firequalizer", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="firequalizer", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "gain": gain,
@@ -4968,7 +5279,9 @@ def flanger(
         regen: Double = Default(0.0),
         width: Double = Default(71.0),
         speed: Double = Default(0.5),
-        shape: Int | Literal["triangular", "t", "sinusoidal", "s"] | Default = Default("sinusoidal"),
+        shape: Int | Literal["triangular", "t", "sinusoidal", "s"] | Default = Default(
+            "sinusoidal"
+        ),
         phase: Double = Default(25.0),
         interp: Int | Literal["linear", "quadratic"] | Default = Default("linear"),
         extra_options: dict[str, Any] = None,
@@ -4995,7 +5308,9 @@ def flanger(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="flanger", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="flanger", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "delay": delay,
@@ -5017,7 +5332,9 @@ def haas(
         level_in: Double = Default(1.0),
         level_out: Double = Default(1.0),
         side_gain: Double = Default(1.0),
-        middle_source: Int | Literal["left", "right", "mid", "side"] | Default = Default("mid"),
+        middle_source: Int
+        | Literal["left", "right", "mid", "side"]
+        | Default = Default("mid"),
         middle_phase: Boolean = Default(False),
         left_delay: Double = Default(2.05),
         left_balance: Double = Default(-1.0),
@@ -5056,7 +5373,9 @@ def haas(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="haas", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="haas", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "level_in": level_in,
@@ -5084,7 +5403,9 @@ def hdcd(
         process_stereo: Boolean = Default(True),
         cdt_ms: Int = Default(2000),
         force_pe: Boolean = Default(False),
-        analyze_mode: Int | Literal["off", "lle", "pe", "cdt", "tgm"] | Default = Default("off"),
+        analyze_mode: Int
+        | Literal["off", "lle", "pe", "cdt", "tgm"]
+        | Default = Default("off"),
         bits_per_sample: Int | Literal["16", "20", "24"] | Default = Default(16),
         extra_options: dict[str, Any] = None,
     ) -> AudioStream:
@@ -5108,7 +5429,9 @@ def hdcd(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="hdcd", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="hdcd", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "disable_autoconvert": disable_autoconvert,
@@ -5132,8 +5455,12 @@ def highpass(
         mix: Double = Default(1.0),
         channels: String = Default("all"),
         normalize: Boolean = Default(False),
-        transform: Int | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"] | Default = Default("di"),
-        precision: Int | Literal["auto", "s16", "s32", "f32", "f64"] | Default = Default("auto"),
+        transform: Int
+        | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"]
+        | Default = Default("di"),
+        precision: Int
+        | Literal["auto", "s16", "s32", "f32", "f64"]
+        | Default = Default("auto"),
         blocksize: Int = Default(0),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
@@ -5163,7 +5490,9 @@ def highpass(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="highpass", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="highpass", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "frequency": frequency,
@@ -5193,8 +5522,12 @@ def highshelf(
         mix: Double = Default(1.0),
         channels: String = Default("all"),
         normalize: Boolean = Default(False),
-        transform: Int | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"] | Default = Default("di"),
-        precision: Int | Literal["auto", "s16", "s32", "f32", "f64"] | Default = Default("auto"),
+        transform: Int
+        | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"]
+        | Default = Default("di"),
+        precision: Int
+        | Literal["auto", "s16", "s32", "f32", "f64"]
+        | Default = Default("auto"),
         blocksize: Int = Default(0),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
@@ -5225,7 +5558,9 @@ def highshelf(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="highshelf", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="highshelf", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "frequency": frequency,
@@ -5258,7 +5593,9 @@ def loudnorm(
         offset: Double = Default(0.0),
         linear: Boolean = Default(True),
         dual_mono: Boolean = Default(False),
-        print_format: Int | Literal["none", "json", "summary"] | Default = Default("none"),
+        print_format: Int | Literal["none", "json", "summary"] | Default = Default(
+            "none"
+        ),
         extra_options: dict[str, Any] = None,
     ) -> AudioStream:
         """
@@ -5286,7 +5623,9 @@ def loudnorm(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="loudnorm", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="loudnorm", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "I": I,
@@ -5315,8 +5654,12 @@ def lowpass(
         mix: Double = Default(1.0),
         channels: String = Default("all"),
         normalize: Boolean = Default(False),
-        transform: Int | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"] | Default = Default("di"),
-        precision: Int | Literal["auto", "s16", "s32", "f32", "f64"] | Default = Default("auto"),
+        transform: Int
+        | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"]
+        | Default = Default("di"),
+        precision: Int
+        | Literal["auto", "s16", "s32", "f32", "f64"]
+        | Default = Default("auto"),
         blocksize: Int = Default(0),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
@@ -5346,7 +5689,9 @@ def lowpass(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="lowpass", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="lowpass", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "frequency": frequency,
@@ -5376,8 +5721,12 @@ def lowshelf(
         mix: Double = Default(1.0),
         channels: String = Default("all"),
         normalize: Boolean = Default(False),
-        transform: Int | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"] | Default = Default("di"),
-        precision: Int | Literal["auto", "s16", "s32", "f32", "f64"] | Default = Default("auto"),
+        transform: Int
+        | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"]
+        | Default = Default("di"),
+        precision: Int
+        | Literal["auto", "s16", "s32", "f32", "f64"]
+        | Default = Default("auto"),
         blocksize: Int = Default(0),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
@@ -5408,7 +5757,9 @@ def lowshelf(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="lowshelf", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="lowshelf", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "frequency": frequency,
@@ -5451,7 +5802,9 @@ def mcompand(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="mcompand", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="mcompand", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "args": args,
@@ -5481,7 +5834,9 @@ def pan(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="pan", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="pan", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "args": args,
@@ -5513,7 +5868,9 @@ def replaygain(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="replaygain", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="replaygain", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "track_gain": track_gain,
@@ -5528,13 +5885,21 @@ def rubberband(
         *,
         tempo: Double = Default(1.0),
         pitch: Double = Default(1.0),
-        transients: Int | Literal["crisp", "mixed", "smooth"] | Default = Default("crisp"),
-        detector: Int | Literal["compound", "percussive", "soft"] | Default = Default("compound"),
+        transients: Int | Literal["crisp", "mixed", "smooth"] | Default = Default(
+            "crisp"
+        ),
+        detector: Int | Literal["compound", "percussive", "soft"] | Default = Default(
+            "compound"
+        ),
         phase: Int | Literal["laminar", "independent"] | Default = Default("laminar"),
-        window: Int | Literal["standard", "short", "long"] | Default = Default("standard"),
+        window: Int | Literal["standard", "short", "long"] | Default = Default(
+            "standard"
+        ),
         smoothing: Int | Literal["off", "on"] | Default = Default("off"),
         formant: Int | Literal["shifted", "preserved"] | Default = Default("shifted"),
-        pitchq: Int | Literal["quality", "speed", "consistency"] | Default = Default("speed"),
+        pitchq: Int | Literal["quality", "speed", "consistency"] | Default = Default(
+            "speed"
+        ),
         channels: Int | Literal["apart", "together"] | Default = Default("apart"),
         extra_options: dict[str, Any] = None,
     ) -> AudioStream:
@@ -5562,7 +5927,9 @@ def rubberband(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="rubberband", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="rubberband", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "tempo": tempo,
@@ -5608,7 +5975,15 @@ def showcqt(
         axisfile: String = Default(None),
         axis: Boolean = Default(True),
         csp: Int
-        | Literal["unspecified", "bt709", "fcc", "bt470bg", "smpte170m", "smpte240m", "bt2020ncl"]
+        | Literal[
+            "unspecified",
+            "bt709",
+            "fcc",
+            "bt470bg",
+            "smpte170m",
+            "smpte240m",
+            "bt2020ncl",
+        ]
         | Default = Default("unspecified"),
         cscheme: String = Default("1|0.5|0|0|0.5|1"),
         extra_options: dict[str, Any] = None,
@@ -5653,7 +6028,9 @@ def showcqt(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="showcqt", typings_input=("audio",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="showcqt", typings_input=("audio",), typings_output=("video",)
+            ),
             self,
             **{
                 "size": size,
@@ -5695,7 +6072,9 @@ def showcwt(
         scale: Int
         | Literal["linear", "log", "bark", "mel", "erbs", "sqrt", "cbrt", "qdrt"]
         | Default = Default("linear"),
-        iscale: Int | Literal["linear", "log", "sqrt", "cbrt", "qdrt"] | Default = Default("log"),
+        iscale: Int
+        | Literal["linear", "log", "sqrt", "cbrt", "qdrt"]
+        | Default = Default("log"),
         min: Float = Default(20.0),
         max: Float = Default(20000.0),
         imin: Float = Default(0.0),
@@ -5703,8 +6082,12 @@ def showcwt(
         logb: Float = Default(0.0001),
         deviation: Float = Default(1.0),
         pps: Int = Default(64),
-        mode: Int | Literal["magnitude", "phase", "magphase", "channel", "stereo"] | Default = Default("magnitude"),
-        slide: Int | Literal["replace", "scroll", "frame"] | Default = Default("replace"),
+        mode: Int
+        | Literal["magnitude", "phase", "magphase", "channel", "stereo"]
+        | Default = Default("magnitude"),
+        slide: Int | Literal["replace", "scroll", "frame"] | Default = Default(
+            "replace"
+        ),
         direction: Int | Literal["lr", "rl", "ud", "du"] | Default = Default("lr"),
         bar: Float = Default(0.0),
         rotation: Float = Default(0.0),
@@ -5740,7 +6123,9 @@ def showcwt(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="showcwt", typings_input=("audio",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="showcwt", typings_input=("audio",), typings_output=("video",)
+            ),
             self,
             **{
                 "size": size,
@@ -5801,10 +6186,14 @@ def showfreqs(
         | Default = Default("hann"),
         overlap: Float = Default(1.0),
         averaging: Int = Default(1),
-        colors: String = Default("red|green|blue|yellow|orange|lime|pink|magenta|brown"),
+        colors: String = Default(
+            "red|green|blue|yellow|orange|lime|pink|magenta|brown"
+        ),
         cmode: Int | Literal["combined", "separate"] | Default = Default("combined"),
         minamp: Float = Default(1e-06),
-        data: Int | Literal["magnitude", "phase", "delay"] | Default = Default("magnitude"),
+        data: Int | Literal["magnitude", "phase", "delay"] | Default = Default(
+            "magnitude"
+        ),
         channels: String = Default("all"),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -5836,7 +6225,9 @@ def showfreqs(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="showfreqs", typings_input=("audio",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="showfreqs", typings_input=("audio",), typings_output=("video",)
+            ),
             self,
             **{
                 "size": size,
@@ -5910,7 +6301,9 @@ def showspatial(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="showspatial", typings_input=("audio",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="showspatial", typings_input=("audio",), typings_output=("video",)
+            ),
             self,
             **{
                 "size": size,
@@ -5926,7 +6319,9 @@ def showspectrum(
         self,
         *,
         size: Image_size = Default("640x512"),
-        slide: Int | Literal["replace", "scroll", "fullframe", "rscroll", "lreplace"] | Default = Default("replace"),
+        slide: Int
+        | Literal["replace", "scroll", "fullframe", "rscroll", "lreplace"]
+        | Default = Default("replace"),
         mode: Int | Literal["combined", "separate"] | Default = Default("combined"),
         color: Int
         | Literal[
@@ -5947,7 +6342,9 @@ def showspectrum(
             "terrain",
         ]
         | Default = Default("channel"),
-        scale: Int | Literal["lin", "sqrt", "cbrt", "log", "4thrt", "5thrt"] | Default = Default("sqrt"),
+        scale: Int
+        | Literal["lin", "sqrt", "cbrt", "log", "4thrt", "5thrt"]
+        | Default = Default("sqrt"),
         fscale: Int | Literal["lin", "log"] | Default = Default("lin"),
         saturation: Float = Default(1.0),
         win_func: Int
@@ -5976,10 +6373,14 @@ def showspectrum(
             "kaiser",
         ]
         | Default = Default("hann"),
-        orientation: Int | Literal["vertical", "horizontal"] | Default = Default("vertical"),
+        orientation: Int | Literal["vertical", "horizontal"] | Default = Default(
+            "vertical"
+        ),
         overlap: Float = Default(0.0),
         gain: Float = Default(1.0),
-        data: Int | Literal["magnitude", "phase", "uphase"] | Default = Default("magnitude"),
+        data: Int | Literal["magnitude", "phase", "uphase"] | Default = Default(
+            "magnitude"
+        ),
         rotation: Float = Default(0.0),
         start: Int = Default(0),
         stop: Int = Default(0),
@@ -6024,7 +6425,9 @@ def showspectrum(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="showspectrum", typings_input=("audio",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="showspectrum", typings_input=("audio",), typings_output=("video",)
+            ),
             self,
             **{
                 "size": size,
@@ -6076,7 +6479,9 @@ def showspectrumpic(
             "terrain",
         ]
         | Default = Default("intensity"),
-        scale: Int | Literal["lin", "sqrt", "cbrt", "log", "4thrt", "5thrt"] | Default = Default("log"),
+        scale: Int
+        | Literal["lin", "sqrt", "cbrt", "log", "4thrt", "5thrt"]
+        | Default = Default("log"),
         fscale: Int | Literal["lin", "log"] | Default = Default("lin"),
         saturation: Float = Default(1.0),
         win_func: Int
@@ -6105,7 +6510,9 @@ def showspectrumpic(
             "kaiser",
         ]
         | Default = Default("hann"),
-        orientation: Int | Literal["vertical", "horizontal"] | Default = Default("vertical"),
+        orientation: Int | Literal["vertical", "horizontal"] | Default = Default(
+            "vertical"
+        ),
         gain: Float = Default(1.0),
         legend: Boolean = Default(True),
         rotation: Float = Default(0.0),
@@ -6146,7 +6553,11 @@ def showspectrumpic(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="showspectrumpic", typings_input=("audio",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="showspectrumpic",
+                typings_input=("audio",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "size": size,
@@ -6219,7 +6630,9 @@ def showvolume(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="showvolume", typings_input=("audio",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="showvolume", typings_input=("audio",), typings_output=("video",)
+            ),
             self,
             **{
                 "rate": rate,
@@ -6246,11 +6659,15 @@ def showwaves(
         self,
         *,
         size: Image_size = Default("600x240"),
-        mode: Int | Literal["point", "line", "p2p", "cline"] | Default = Default("point"),
+        mode: Int | Literal["point", "line", "p2p", "cline"] | Default = Default(
+            "point"
+        ),
         n: Rational = Default("0/1"),
         rate: Video_rate = Default("25"),
         split_channels: Boolean = Default(False),
-        colors: String = Default("red|green|blue|yellow|orange|lime|pink|magenta|brown"),
+        colors: String = Default(
+            "red|green|blue|yellow|orange|lime|pink|magenta|brown"
+        ),
         scale: Int | Literal["lin", "log", "sqrt", "cbrt"] | Default = Default("lin"),
         draw: Int | Literal["scale", "full"] | Default = Default("scale"),
         extra_options: dict[str, Any] = None,
@@ -6277,7 +6694,9 @@ def showwaves(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="showwaves", typings_input=("audio",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="showwaves", typings_input=("audio",), typings_output=("video",)
+            ),
             self,
             **{
                 "size": size,
@@ -6298,7 +6717,9 @@ def showwavespic(
         *,
         size: Image_size = Default("600x240"),
         split_channels: Boolean = Default(False),
-        colors: String = Default("red|green|blue|yellow|orange|lime|pink|magenta|brown"),
+        colors: String = Default(
+            "red|green|blue|yellow|orange|lime|pink|magenta|brown"
+        ),
         scale: Int | Literal["lin", "log", "sqrt", "cbrt"] | Default = Default("lin"),
         draw: Int | Literal["scale", "full"] | Default = Default("scale"),
         filter: Int | Literal["average", "peak"] | Default = Default("average"),
@@ -6324,7 +6745,9 @@ def showwavespic(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="showwavespic", typings_input=("audio",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="showwavespic", typings_input=("audio",), typings_output=("video",)
+            ),
             self,
             **{
                 "size": size,
@@ -6382,7 +6805,11 @@ def sidechaincompress(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="sidechaincompress", typings_input=("audio", "audio"), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="sidechaincompress",
+                typings_input=("audio", "audio"),
+                typings_output=("audio",),
+            ),
             self,
             _sidechain,
             **{
@@ -6449,7 +6876,11 @@ def sidechaingate(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="sidechaingate", typings_input=("audio", "audio"), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="sidechaingate",
+                typings_input=("audio", "audio"),
+                typings_output=("audio",),
+            ),
             self,
             _sidechain,
             **{
@@ -6496,7 +6927,11 @@ def silencedetect(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="silencedetect", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="silencedetect",
+                typings_input=("audio",),
+                typings_output=("audio",),
+            ),
             self,
             **{
                 "n": n,
@@ -6520,7 +6955,9 @@ def silenceremove(
         stop_threshold: Double = Default(0.0),
         stop_silence: Duration = Default(0.0),
         stop_mode: Int | Literal["any", "all"] | Default = Default("all"),
-        detection: Int | Literal["avg", "rms", "peak", "median", "ptp", "dev"] | Default = Default("rms"),
+        detection: Int
+        | Literal["avg", "rms", "peak", "median", "ptp", "dev"]
+        | Default = Default("rms"),
         window: Duration = Default(0.02),
         timestamp: Int | Literal["write", "copy"] | Default = Default("write"),
         enable: String = Default(None),
@@ -6554,7 +6991,11 @@ def silenceremove(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="silenceremove", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="silenceremove",
+                typings_input=("audio",),
+                typings_output=("audio",),
+            ),
             self,
             **{
                 "start_periods": start_periods,
@@ -6617,7 +7058,9 @@ def speechnorm(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="speechnorm", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="speechnorm", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "peak": peak,
@@ -6659,8 +7102,12 @@ def stereotools(
         delay: Double = Default(0.0),
         sclevel: Double = Default(1.0),
         phase: Double = Default(0.0),
-        bmode_in: Int | Literal["balance", "amplitude", "power"] | Default = Default("balance"),
-        bmode_out: Int | Literal["balance", "amplitude", "power"] | Default = Default("balance"),
+        bmode_in: Int | Literal["balance", "amplitude", "power"] | Default = Default(
+            "balance"
+        ),
+        bmode_out: Int | Literal["balance", "amplitude", "power"] | Default = Default(
+            "balance"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> AudioStream:
@@ -6699,7 +7146,9 @@ def stereotools(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="stereotools", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="stereotools", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "level_in": level_in,
@@ -6757,7 +7206,9 @@ def stereowiden(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="stereowiden", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="stereowiden", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "delay": delay,
@@ -6825,7 +7276,11 @@ def superequalizer(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="superequalizer", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="superequalizer",
+                typings_input=("audio",),
+                typings_output=("audio",),
+            ),
             self,
             **{
                 "1b": _1b,
@@ -6995,7 +7450,9 @@ def surround(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="surround", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="surround", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "chl_out": chl_out,
@@ -7064,8 +7521,12 @@ def tiltshelf(
         mix: Double = Default(1.0),
         channels: String = Default("all"),
         normalize: Boolean = Default(False),
-        transform: Int | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"] | Default = Default("di"),
-        precision: Int | Literal["auto", "s16", "s32", "f32", "f64"] | Default = Default("auto"),
+        transform: Int
+        | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"]
+        | Default = Default("di"),
+        precision: Int
+        | Literal["auto", "s16", "s32", "f32", "f64"]
+        | Default = Default("auto"),
         blocksize: Int = Default(0),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
@@ -7096,7 +7557,9 @@ def tiltshelf(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="tiltshelf", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="tiltshelf", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "frequency": frequency,
@@ -7127,8 +7590,12 @@ def treble(
         mix: Double = Default(1.0),
         channels: String = Default("all"),
         normalize: Boolean = Default(False),
-        transform: Int | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"] | Default = Default("di"),
-        precision: Int | Literal["auto", "s16", "s32", "f32", "f64"] | Default = Default("auto"),
+        transform: Int
+        | Literal["di", "dii", "tdi", "tdii", "latt", "svf", "zdf"]
+        | Default = Default("di"),
+        precision: Int
+        | Literal["auto", "s16", "s32", "f32", "f64"]
+        | Default = Default("auto"),
         blocksize: Int = Default(0),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
@@ -7159,7 +7626,9 @@ def treble(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="treble", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="treble", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "frequency": frequency,
@@ -7204,7 +7673,9 @@ def tremolo(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="tremolo", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="tremolo", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "f": f,
@@ -7240,7 +7711,9 @@ def vibrato(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="vibrato", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="vibrato", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "f": f,
@@ -7276,7 +7749,9 @@ def virtualbass(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="virtualbass", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="virtualbass", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "cutoff": cutoff,
@@ -7291,9 +7766,13 @@ def volume(
         self,
         *,
         volume: String = Default("1.0"),
-        precision: Int | Literal["fixed", "float", "double"] | Default = Default("float"),
+        precision: Int | Literal["fixed", "float", "double"] | Default = Default(
+            "float"
+        ),
         eval: Int | Literal["once", "frame"] | Default = Default("once"),
-        replaygain: Int | Literal["drop", "ignore", "track", "album"] | Default = Default("drop"),
+        replaygain: Int
+        | Literal["drop", "ignore", "track", "album"]
+        | Default = Default("drop"),
         replaygain_preamp: Double = Default(0.0),
         replaygain_noclip: Boolean = Default(True),
         enable: String = Default(None),
@@ -7320,7 +7799,9 @@ def volume(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="volume", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="volume", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{
                 "volume": volume,
@@ -7351,7 +7832,9 @@ def volumedetect(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="volumedetect", typings_input=("audio",), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="volumedetect", typings_input=("audio",), typings_output=("audio",)
+            ),
             self,
             **{} | (extra_options or {}),
         )
diff --git a/src/ffmpeg/streams/video.py b/src/ffmpeg/streams/video.py
index 56330811..afd5bb9c 100644
--- a/src/ffmpeg/streams/video.py
+++ b/src/ffmpeg/streams/video.py
@@ -9,7 +9,20 @@
 from ..dag.factory import filter_node_factory
 from ..dag.nodes import FilterableStream, FilterNode
 from ..schema import Default
-from ..types import Boolean, Color, Double, Duration, Flags, Float, Image_size, Int, Int64, Rational, String, Video_rate
+from ..types import (
+    Boolean,
+    Color,
+    Double,
+    Duration,
+    Flags,
+    Float,
+    Image_size,
+    Int,
+    Int64,
+    Rational,
+    String,
+    Video_rate,
+)
 
 if TYPE_CHECKING:
     from .audio import AudioStream
@@ -47,7 +60,9 @@ def addroi(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="addroi", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="addroi", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "x": x,
@@ -77,7 +92,9 @@ def alphaextract(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="alphaextract", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="alphaextract", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{} | (extra_options or {}),
         )
@@ -87,10 +104,14 @@ def alphamerge(
         self,
         _alpha: VideoStream,
         *,
-        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
         shortest: Boolean = Default(False),
         repeatlast: Boolean = Default(True),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -113,7 +134,11 @@ def alphamerge(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="alphamerge", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="alphamerge",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _alpha,
             **{
@@ -162,7 +187,9 @@ def amplify(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="amplify", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="amplify", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "radius": radius,
@@ -207,7 +234,9 @@ def ass(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="ass", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="ass", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "filename": filename,
@@ -265,7 +294,9 @@ def atadenoise(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="atadenoise", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="atadenoise", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "0a": _0a,
@@ -313,7 +344,9 @@ def avgblur(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="avgblur", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="avgblur", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "sizeX": sizeX,
@@ -352,7 +385,11 @@ def backgroundkey(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="backgroundkey", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="backgroundkey",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "threshold": threshold,
@@ -387,7 +424,9 @@ def bbox(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="bbox", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="bbox", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "min_val": min_val,
@@ -418,7 +457,9 @@ def bench(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="bench", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="bench", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "action": action,
@@ -454,7 +495,9 @@ def bilateral(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="bilateral", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="bilateral", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "sigmaS": sigmaS,
@@ -491,7 +534,11 @@ def bitplanenoise(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="bitplanenoise", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="bitplanenoise",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "bitplane": bitplane,
@@ -527,7 +574,9 @@ def blackdetect(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="blackdetect", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="blackdetect", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "d": d,
@@ -561,7 +610,9 @@ def blackframe(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="blackframe", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="blackframe", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "amount": amount,
@@ -815,10 +866,14 @@ def blend(
         c2_opacity: Double = Default(1.0),
         c3_opacity: Double = Default(1.0),
         all_opacity: Double = Default(1.0),
-        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
         shortest: Boolean = Default(False),
         repeatlast: Boolean = Default(True),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -856,7 +911,11 @@ def blend(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="blend", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="blend",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _bottom,
             **{
@@ -910,7 +969,9 @@ def blockdetect(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="blockdetect", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="blockdetect", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "period_min": period_min,
@@ -952,7 +1013,9 @@ def blurdetect(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="blurdetect", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="blurdetect", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "high": high,
@@ -999,7 +1062,9 @@ def boxblur(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="boxblur", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="boxblur", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "luma_radius": luma_radius,
@@ -1017,7 +1082,9 @@ def boxblur(
     def bwdif(
         self,
         *,
-        mode: Int | Literal["send_frame", "send_field"] | Default = Default("send_field"),
+        mode: Int | Literal["send_frame", "send_field"] | Default = Default(
+            "send_field"
+        ),
         parity: Int | Literal["tff", "bff", "auto"] | Default = Default("auto"),
         deint: Int | Literal["all", "interlaced"] | Default = Default("all"),
         enable: String = Default(None),
@@ -1041,7 +1108,9 @@ def bwdif(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="bwdif", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="bwdif", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -1078,7 +1147,9 @@ def cas(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="cas", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="cas", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "strength": strength,
@@ -1105,7 +1176,9 @@ def ccrepack(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="ccrepack", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="ccrepack", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{} | (extra_options or {}),
         )
@@ -1140,7 +1213,9 @@ def chromahold(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="chromahold", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="chromahold", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "color": color,
@@ -1182,7 +1257,9 @@ def chromakey(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="chromakey", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="chromakey", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "color": color,
@@ -1206,7 +1283,9 @@ def chromanr(
         threy: Float = Default(200.0),
         threu: Float = Default(200.0),
         threv: Float = Default(200.0),
-        distance: Int | Literal["manhattan", "euclidean"] | Default = Default("manhattan"),
+        distance: Int | Literal["manhattan", "euclidean"] | Default = Default(
+            "manhattan"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -1234,7 +1313,9 @@ def chromanr(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="chromanr", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="chromanr", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "thres": thres,
@@ -1283,7 +1364,9 @@ def chromashift(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="chromashift", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="chromashift", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "cbh": cbh,
@@ -1370,7 +1453,9 @@ def ciescope(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="ciescope", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="ciescope", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "system": system,
@@ -1419,7 +1504,9 @@ def codecview(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="codecview", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="codecview", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "mv": mv,
@@ -1474,7 +1561,9 @@ def colorbalance(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="colorbalance", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="colorbalance", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "rs": rs,
@@ -1512,7 +1601,9 @@ def colorchannelmixer(
         ag: Double = Default(0.0),
         ab: Double = Default(0.0),
         aa: Double = Default(1.0),
-        pc: Int | Literal["none", "lum", "max", "avg", "sum", "nrm", "pwr"] | Default = Default("none"),
+        pc: Int
+        | Literal["none", "lum", "max", "avg", "sum", "nrm", "pwr"]
+        | Default = Default("none"),
         pa: Double = Default(0.0),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
@@ -1550,7 +1641,11 @@ def colorchannelmixer(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="colorchannelmixer", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="colorchannelmixer",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "rr": rr,
@@ -1612,7 +1707,11 @@ def colorcontrast(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="colorcontrast", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="colorcontrast",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "rc": rc,
@@ -1636,7 +1735,9 @@ def colorcorrect(
         rh: Float = Default(0.0),
         bh: Float = Default(0.0),
         saturation: Float = Default(1.0),
-        analyze: Int | Literal["manual", "average", "minmax", "median"] | Default = Default("manual"),
+        analyze: Int
+        | Literal["manual", "average", "minmax", "median"]
+        | Default = Default("manual"),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -1661,7 +1762,9 @@ def colorcorrect(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="colorcorrect", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="colorcorrect", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "rl": rl,
@@ -1703,7 +1806,9 @@ def colorhold(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="colorhold", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="colorhold", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "color": color,
@@ -1744,7 +1849,9 @@ def colorize(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="colorize", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="colorize", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "hue": hue,
@@ -1784,7 +1891,9 @@ def colorkey(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="colorkey", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="colorkey", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "color": color,
@@ -1815,7 +1924,9 @@ def colorlevels(
         gomax: Double = Default(1.0),
         bomax: Double = Default(1.0),
         aomax: Double = Default(1.0),
-        preserve: Int | Literal["none", "lum", "max", "avg", "sum", "nrm", "pwr"] | Default = Default("none"),
+        preserve: Int
+        | Literal["none", "lum", "max", "avg", "sum", "nrm", "pwr"]
+        | Default = Default("none"),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -1851,7 +1962,9 @@ def colorlevels(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="colorlevels", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="colorlevels", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "rimin": rimin,
@@ -1885,7 +1998,9 @@ def colormap(
         patch_size: Image_size = Default("64x64"),
         nb_patches: Int = Default(0),
         type: Int | Literal["relative", "absolute"] | Default = Default("absolute"),
-        kernel: Int | Literal["euclidean", "weuclidean"] | Default = Default("euclidean"),
+        kernel: Int | Literal["euclidean", "weuclidean"] | Default = Default(
+            "euclidean"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -1908,7 +2023,11 @@ def colormap(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="colormap", typings_input=("video", "video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="colormap",
+                typings_input=("video", "video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _source,
             _target,
@@ -1927,10 +2046,28 @@ def colormatrix(
         self,
         *,
         src: Int
-        | Literal["bt709", "fcc", "bt601", "bt470", "bt470bg", "smpte170m", "smpte240m", "bt2020"]
+        | Literal[
+            "bt709",
+            "fcc",
+            "bt601",
+            "bt470",
+            "bt470bg",
+            "smpte170m",
+            "smpte240m",
+            "bt2020",
+        ]
         | Default = Default(-1),
         dst: Int
-        | Literal["bt709", "fcc", "bt601", "bt470", "bt470bg", "smpte170m", "smpte240m", "bt2020"]
+        | Literal[
+            "bt709",
+            "fcc",
+            "bt601",
+            "bt470",
+            "bt470bg",
+            "smpte170m",
+            "smpte240m",
+            "bt2020",
+        ]
         | Default = Default(-1),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
@@ -1952,7 +2089,9 @@ def colormatrix(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="colormatrix", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="colormatrix", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "src": src,
@@ -1967,10 +2106,29 @@ def colorspace(
         self,
         *,
         all: Int
-        | Literal["bt470m", "bt470bg", "525", "625", "bt709", "smpte170m", "smpte240m", "bt2020"]
+        | Literal[
+            "bt470m",
+            "bt470bg",
+            "525",
+            "625",
+            "bt709",
+            "smpte170m",
+            "smpte240m",
+            "bt2020",
+        ]
         | Default = Default(0),
         space: Int
-        | Literal["bt709", "fcc", "bt470bg", "smpte170m", "smpte240m", "ycgco", "gbr", "bt2020nc", "bt2020ncl"]
+        | Literal[
+            "bt709",
+            "fcc",
+            "bt470bg",
+            "smpte170m",
+            "smpte240m",
+            "ycgco",
+            "gbr",
+            "bt2020nc",
+            "bt2020ncl",
+        ]
         | Default = Default(2),
         range: Int | Literal["tv", "mpeg", "pc", "jpeg"] | Default = Default(0),
         primaries: Int
@@ -2022,12 +2180,33 @@ def colorspace(
         | Default = Default(-1),
         fast: Boolean = Default(False),
         dither: Int | Literal["none", "fsb"] | Default = Default("none"),
-        wpadapt: Int | Literal["bradford", "vonkries", "identity"] | Default = Default("bradford"),
+        wpadapt: Int | Literal["bradford", "vonkries", "identity"] | Default = Default(
+            "bradford"
+        ),
         iall: Int
-        | Literal["bt470m", "bt470bg", "525", "625", "bt709", "smpte170m", "smpte240m", "bt2020"]
+        | Literal[
+            "bt470m",
+            "bt470bg",
+            "525",
+            "625",
+            "bt709",
+            "smpte170m",
+            "smpte240m",
+            "bt2020",
+        ]
         | Default = Default(0),
         ispace: Int
-        | Literal["bt709", "fcc", "bt470bg", "smpte170m", "smpte240m", "ycgco", "gbr", "bt2020nc", "bt2020ncl"]
+        | Literal[
+            "bt709",
+            "fcc",
+            "bt470bg",
+            "smpte170m",
+            "smpte240m",
+            "ycgco",
+            "gbr",
+            "bt2020nc",
+            "bt2020ncl",
+        ]
         | Default = Default(2),
         irange: Int | Literal["tv", "mpeg", "pc", "jpeg"] | Default = Default(0),
         iprimaries: Int
@@ -2096,7 +2275,9 @@ def colorspace(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="colorspace", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="colorspace", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "all": all,
@@ -2146,7 +2327,11 @@ def colortemperature(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="colortemperature", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="colortemperature",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "temperature": temperature,
@@ -2211,7 +2396,9 @@ def convolution(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="convolution", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="convolution", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "0m": _0m,
@@ -2243,10 +2430,14 @@ def convolve(
         planes: Int = Default(7),
         impulse: Int | Literal["first", "all"] | Default = Default("all"),
         noise: Float = Default(1e-07),
-        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
         shortest: Boolean = Default(False),
         repeatlast: Boolean = Default(True),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -2272,7 +2463,11 @@ def convolve(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="convolve", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="convolve",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _impulse,
             **{
@@ -2305,7 +2500,9 @@ def copy(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="copy", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="copy", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{} | (extra_options or {}),
         )
@@ -2338,7 +2535,9 @@ def coreimage(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="coreimage", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="coreimage", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "list_filters": list_filters,
@@ -2354,10 +2553,14 @@ def corr(
         self,
         _reference: VideoStream,
         *,
-        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
         shortest: Boolean = Default(False),
         repeatlast: Boolean = Default(True),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -2380,7 +2583,9 @@ def corr(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="corr", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="corr", typings_input=("video", "video"), typings_output=("video",)
+            ),
             self,
             _reference,
             **{
@@ -2417,7 +2622,9 @@ def cover_rect(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="cover_rect", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="cover_rect", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "cover": cover,
@@ -2458,7 +2665,9 @@ def crop(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="crop", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="crop", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "out_w": out_w,
@@ -2513,7 +2722,9 @@ def cropdetect(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="cropdetect", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="cropdetect", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "limit": limit,
@@ -2557,7 +2768,9 @@ def cue(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="cue", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="cue", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "cue": cue,
@@ -2621,7 +2834,9 @@ def curves(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="curves", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="curves", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "preset": preset,
@@ -2674,7 +2889,9 @@ def datascope(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="datascope", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="datascope", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "size": size,
@@ -2717,7 +2934,9 @@ def dblur(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="dblur", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="dblur", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "angle": angle,
@@ -2758,7 +2977,9 @@ def dctdnoiz(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="dctdnoiz", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="dctdnoiz", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "sigma": sigma,
@@ -2808,7 +3029,9 @@ def deband(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="deband", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="deband", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "1thr": _1thr,
@@ -2860,7 +3083,9 @@ def deblock(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="deblock", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="deblock", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "filter": filter,
@@ -2883,10 +3108,14 @@ def deconvolve(
         planes: Int = Default(7),
         impulse: Int | Literal["first", "all"] | Default = Default("all"),
         noise: Float = Default(1e-07),
-        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
         shortest: Boolean = Default(False),
         repeatlast: Boolean = Default(True),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -2912,7 +3141,11 @@ def deconvolve(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="deconvolve", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="deconvolve",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _impulse,
             **{
@@ -2932,7 +3165,9 @@ def deconvolve(
     def dedot(
         self,
         *,
-        m: Flags | Literal["dotcrawl", "rainbows"] | Default = Default("dotcrawl+rainbows"),
+        m: Flags | Literal["dotcrawl", "rainbows"] | Default = Default(
+            "dotcrawl+rainbows"
+        ),
         lt: Float = Default(0.079),
         tl: Float = Default(0.079),
         tc: Float = Default(0.058),
@@ -2960,7 +3195,9 @@ def dedot(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="dedot", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="dedot", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "m": m,
@@ -3003,7 +3240,9 @@ def deflate(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="deflate", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="deflate", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "threshold0": threshold0,
@@ -3020,7 +3259,9 @@ def deflicker(
         self,
         *,
         size: Int = Default(5),
-        mode: Int | Literal["am", "gm", "hm", "qm", "cm", "pm", "median"] | Default = Default("am"),
+        mode: Int
+        | Literal["am", "gm", "hm", "qm", "cm", "pm", "median"]
+        | Default = Default("am"),
         bypass: Boolean = Default(False),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -3041,7 +3282,9 @@ def deflicker(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="deflicker", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="deflicker", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "size": size,
@@ -3073,7 +3316,9 @@ def dejudder(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="dejudder", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="dejudder", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "cycle": cycle,
@@ -3113,7 +3358,9 @@ def delogo(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="delogo", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="delogo", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "x": x,
@@ -3158,7 +3405,9 @@ def derain(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="derain", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="derain", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "filter_type": filter_type,
@@ -3181,7 +3430,9 @@ def deshake(
         h: Int = Default(-1),
         rx: Int = Default(16),
         ry: Int = Default(16),
-        edge: Int | Literal["blank", "original", "clamp", "mirror"] | Default = Default("mirror"),
+        edge: Int | Literal["blank", "original", "clamp", "mirror"] | Default = Default(
+            "mirror"
+        ),
         blocksize: Int = Default(8),
         contrast: Int = Default(125),
         search: Int | Literal["exhaustive", "less"] | Default = Default("exhaustive"),
@@ -3215,7 +3466,9 @@ def deshake(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="deshake", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="deshake", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "x": x,
@@ -3272,7 +3525,9 @@ def despill(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="despill", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="despill", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "type": type,
@@ -3292,7 +3547,9 @@ def despill(
     def detelecine(
         self,
         *,
-        first_field: Int | Literal["top", "t", "bottom", "b"] | Default = Default("top"),
+        first_field: Int | Literal["top", "t", "bottom", "b"] | Default = Default(
+            "top"
+        ),
         pattern: String = Default("23"),
         start_frame: Int = Default(0),
         extra_options: dict[str, Any] = None,
@@ -3314,7 +3571,9 @@ def detelecine(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="detelecine", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="detelecine", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "first_field": first_field,
@@ -3356,7 +3615,9 @@ def dilation(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="dilation", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="dilation", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "coordinates": coordinates,
@@ -3375,7 +3636,9 @@ def displace(
         _xmap: VideoStream,
         _ymap: VideoStream,
         *,
-        edge: Int | Literal["blank", "smear", "wrap", "mirror"] | Default = Default("smear"),
+        edge: Int | Literal["blank", "smear", "wrap", "mirror"] | Default = Default(
+            "smear"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -3395,7 +3658,11 @@ def displace(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="displace", typings_input=("video", "video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="displace",
+                typings_input=("video", "video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _xmap,
             _ymap,
@@ -3446,7 +3713,9 @@ def dnn_classify(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="dnn_classify", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="dnn_classify", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "dnn_backend": dnn_backend,
@@ -3501,7 +3770,9 @@ def dnn_detect(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="dnn_detect", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="dnn_detect", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "dnn_backend": dnn_backend,
@@ -3551,7 +3822,11 @@ def dnn_processing(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="dnn_processing", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="dnn_processing",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "dnn_backend": dnn_backend,
@@ -3569,7 +3844,9 @@ def dnn_processing(
     def doubleweave(
         self,
         *,
-        first_field: Int | Literal["top", "t", "bottom", "b"] | Default = Default("top"),
+        first_field: Int | Literal["top", "t", "bottom", "b"] | Default = Default(
+            "top"
+        ),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
         """
@@ -3587,7 +3864,9 @@ def doubleweave(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="doubleweave", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="doubleweave", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "first_field": first_field,
@@ -3633,7 +3912,9 @@ def drawbox(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="drawbox", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="drawbox", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "x": x,
@@ -3665,7 +3946,9 @@ def drawgraph(
         min: Float = Default(-1.0),
         max: Float = Default(1.0),
         mode: Int | Literal["bar", "dot", "line"] | Default = Default("line"),
-        slide: Int | Literal["frame", "replace", "scroll", "rscroll", "picture"] | Default = Default("frame"),
+        slide: Int
+        | Literal["frame", "replace", "scroll", "rscroll", "picture"]
+        | Default = Default("frame"),
         size: Image_size = Default("900x256"),
         rate: Video_rate = Default("25"),
         extra_options: dict[str, Any] = None,
@@ -3699,7 +3982,9 @@ def drawgraph(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="drawgraph", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="drawgraph", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "m1": m1,
@@ -3757,7 +4042,9 @@ def drawgrid(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="drawgrid", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="drawgrid", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "x": x,
@@ -3789,7 +4076,20 @@ def drawtext(
         line_spacing: Int = Default(0),
         fontsize: String = Default(None),
         text_align: Flags
-        | Literal["left", "L", "right", "R", "center", "C", "top", "T", "bottom", "B", "middle", "M"]
+        | Literal[
+            "left",
+            "L",
+            "right",
+            "R",
+            "center",
+            "C",
+            "top",
+            "T",
+            "bottom",
+            "B",
+            "middle",
+            "M",
+        ]
         | Default = Default("0"),
         x: String = Default("0"),
         y: String = Default("0"),
@@ -3801,7 +4101,9 @@ def drawtext(
         tabsize: Int = Default(4),
         basetime: Int64 = Default("I64_MIN"),
         font: String = Default("Sans"),
-        expansion: Int | Literal["none", "normal", "strftime"] | Default = Default("normal"),
+        expansion: Int | Literal["none", "normal", "strftime"] | Default = Default(
+            "normal"
+        ),
         y_align: Int | Literal["text", "baseline", "font"] | Default = Default("text"),
         timecode: String = Default(None),
         tc24hmax: Boolean = Default(False),
@@ -3882,7 +4184,9 @@ def drawtext(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="drawtext", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="drawtext", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "fontfile": fontfile,
@@ -3931,7 +4235,9 @@ def edgedetect(
         high: Double = Default(0.196078),
         low: Double = Default(0.0784314),
         mode: Int | Literal["wires", "colormix", "canny"] | Default = Default("wires"),
-        planes: Flags | Literal["y", "u", "v", "r", "g", "b"] | Default = Default("y+u+v+r+g+b"),
+        planes: Flags | Literal["y", "u", "v", "r", "g", "b"] | Default = Default(
+            "y+u+v+r+g+b"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -3954,7 +4260,9 @@ def edgedetect(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="edgedetect", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="edgedetect", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "high": high,
@@ -3996,7 +4304,9 @@ def elbg(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="elbg", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="elbg", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "codebook_length": codebook_length,
@@ -4032,7 +4342,9 @@ def entropy(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="entropy", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="entropy", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -4063,7 +4375,9 @@ def epx(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="epx", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="epx", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "n": n,
@@ -4111,7 +4425,9 @@ def eq(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="eq", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="eq", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "contrast": contrast,
@@ -4160,7 +4476,9 @@ def erosion(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="erosion", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="erosion", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "coordinates": coordinates,
@@ -4213,7 +4531,9 @@ def estdif(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="estdif", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="estdif", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -4256,7 +4576,9 @@ def exposure(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="exposure", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="exposure", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "exposure": exposure,
@@ -4270,7 +4592,9 @@ def exposure(
     def extractplanes(
         self,
         *,
-        planes: Flags | Literal["y", "u", "v", "r", "g", "b", "a"] | Default = Default("r"),
+        planes: Flags | Literal["y", "u", "v", "r", "g", "b", "a"] | Default = Default(
+            "r"
+        ),
         extra_options: dict[str, Any] = None,
     ) -> FilterNode:
         """
@@ -4338,7 +4662,9 @@ def fade(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="fade", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="fade", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "type": type,
@@ -4361,7 +4687,10 @@ def feedback(
         x: Int = Default(0),
         w: Int = Default(0),
         extra_options: dict[str, Any] = None,
-    ) -> tuple[VideoStream, VideoStream,]:
+    ) -> tuple[
+        VideoStream,
+        VideoStream,
+    ]:
         """
 
         Apply feedback video filter.
@@ -4379,7 +4708,11 @@ def feedback(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="feedback", typings_input=("video", "video"), typings_output=("video", "video")),
+            FFMpegFilterDef(
+                name="feedback",
+                typings_input=("video", "video"),
+                typings_output=("video", "video"),
+            ),
             self,
             _feedin,
             **{
@@ -4457,7 +4790,9 @@ def fftdnoiz(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="fftdnoiz", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="fftdnoiz", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "sigma": sigma,
@@ -4510,7 +4845,9 @@ def fftfilt(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="fftfilt", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="fftfilt", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "dc_Y": dc_Y,
@@ -4547,7 +4884,9 @@ def field(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="field", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="field", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "type": type,
@@ -4560,7 +4899,9 @@ def fieldhint(
         self,
         *,
         hint: String = Default(None),
-        mode: Int | Literal["absolute", "relative", "pattern"] | Default = Default("absolute"),
+        mode: Int | Literal["absolute", "relative", "pattern"] | Default = Default(
+            "absolute"
+        ),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
         """
@@ -4579,7 +4920,9 @@ def fieldhint(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="fieldhint", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="fieldhint", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "hint": hint,
@@ -4612,7 +4955,9 @@ def fieldorder(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="fieldorder", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="fieldorder", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "order": order,
@@ -4657,7 +5002,9 @@ def fillborders(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="fillborders", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="fillborders", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "left": left,
@@ -4701,7 +5048,9 @@ def find_rect(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="find_rect", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="find_rect", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "object": object,
@@ -4755,7 +5104,9 @@ def floodfill(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="floodfill", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="floodfill", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "x": x,
@@ -4795,7 +5146,9 @@ def format(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="format", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="format", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "pix_fmts": pix_fmts,
@@ -4809,7 +5162,9 @@ def fps(
         *,
         fps: String = Default("25"),
         start_time: Double = Default("DBL_MAX"),
-        round: Int | Literal["zero", "inf", "down", "up", "near"] | Default = Default("near"),
+        round: Int | Literal["zero", "inf", "down", "up", "near"] | Default = Default(
+            "near"
+        ),
         eof_action: Int | Literal["round", "pass"] | Default = Default("round"),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -4831,7 +5186,9 @@ def fps(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="fps", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="fps", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "fps": fps,
@@ -4847,7 +5204,9 @@ def framepack(
         self,
         _right: VideoStream,
         *,
-        format: Int | Literal["sbs", "tab", "frameseq", "lines", "columns"] | Default = Default("sbs"),
+        format: Int
+        | Literal["sbs", "tab", "frameseq", "lines", "columns"]
+        | Default = Default("sbs"),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
         """
@@ -4865,7 +5224,11 @@ def framepack(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="framepack", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="framepack",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _right,
             **{
@@ -4882,7 +5245,9 @@ def framerate(
         interp_start: Int = Default(15),
         interp_end: Int = Default(240),
         scene: Double = Default(8.2),
-        flags: Flags | Literal["scene_change_detect", "scd"] | Default = Default("scene_change_detect+scd"),
+        flags: Flags | Literal["scene_change_detect", "scd"] | Default = Default(
+            "scene_change_detect+scd"
+        ),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
         """
@@ -4904,7 +5269,9 @@ def framerate(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="framerate", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="framerate", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "fps": fps,
@@ -4940,7 +5307,9 @@ def framestep(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="framestep", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="framestep", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "step": step,
@@ -4973,7 +5342,9 @@ def freezedetect(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="freezedetect", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="freezedetect", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "n": n,
@@ -5009,7 +5380,11 @@ def freezeframes(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="freezeframes", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="freezeframes",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _replace,
             **{
@@ -5046,7 +5421,9 @@ def frei0r(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="frei0r", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="frei0r", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "filter_name": filter_name,
@@ -5086,7 +5463,9 @@ def fspp(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="fspp", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="fspp", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "quality": quality,
@@ -5128,7 +5507,9 @@ def gblur(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="gblur", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="gblur", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "sigma": sigma,
@@ -5151,7 +5532,9 @@ def geq(
         red_expr: String = Default(None),
         green_expr: String = Default(None),
         blue_expr: String = Default(None),
-        interpolation: Int | Literal["nearest", "n", "bilinear", "b"] | Default = Default("bilinear"),
+        interpolation: Int
+        | Literal["nearest", "n", "bilinear", "b"]
+        | Default = Default("bilinear"),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -5178,7 +5561,9 @@ def geq(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="geq", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="geq", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "lum_expr": lum_expr,
@@ -5220,7 +5605,9 @@ def gradfun(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="gradfun", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="gradfun", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "strength": strength,
@@ -5236,7 +5623,9 @@ def graphmonitor(
         *,
         size: Image_size = Default("hd720"),
         opacity: Float = Default(0.9),
-        mode: Flags | Literal["full", "compact", "nozero", "noeof", "nodisabled"] | Default = Default("0"),
+        mode: Flags
+        | Literal["full", "compact", "nozero", "noeof", "nodisabled"]
+        | Default = Default("0"),
         flags: Flags
         | Literal[
             "none",
@@ -5282,7 +5671,9 @@ def graphmonitor(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="graphmonitor", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="graphmonitor", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "size": size,
@@ -5316,7 +5707,9 @@ def grayworld(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="grayworld", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="grayworld", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "enable": enable,
@@ -5352,7 +5745,9 @@ def greyedge(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="greyedge", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="greyedge", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "difford": difford,
@@ -5372,10 +5767,14 @@ def haldclut(
         interp: Int
         | Literal["nearest", "trilinear", "tetrahedral", "pyramid", "prism"]
         | Default = Default("tetrahedral"),
-        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
         shortest: Boolean = Default(False),
         repeatlast: Boolean = Default(True),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -5400,7 +5799,11 @@ def haldclut(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="haldclut", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="haldclut",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _clut,
             **{
@@ -5437,7 +5840,9 @@ def hflip(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="hflip", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="hflip", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "enable": enable,
@@ -5451,7 +5856,9 @@ def histeq(
         *,
         strength: Float = Default(0.2),
         intensity: Float = Default(0.21),
-        antibanding: Int | Literal["none", "weak", "strong"] | Default = Default("none"),
+        antibanding: Int | Literal["none", "weak", "strong"] | Default = Default(
+            "none"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -5473,7 +5880,9 @@ def histeq(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="histeq", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="histeq", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "strength": strength,
@@ -5490,8 +5899,12 @@ def histogram(
         *,
         level_height: Int = Default(200),
         scale_height: Int = Default(12),
-        display_mode: Int | Literal["overlay", "parade", "stack"] | Default = Default("stack"),
-        levels_mode: Int | Literal["linear", "logarithmic"] | Default = Default("linear"),
+        display_mode: Int | Literal["overlay", "parade", "stack"] | Default = Default(
+            "stack"
+        ),
+        levels_mode: Int | Literal["linear", "logarithmic"] | Default = Default(
+            "linear"
+        ),
         components: Int = Default(7),
         fgopacity: Float = Default(0.7),
         bgopacity: Float = Default(0.5),
@@ -5533,7 +5946,9 @@ def histogram(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="histogram", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="histogram", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "level_height": level_height,
@@ -5578,7 +5993,9 @@ def hqdn3d(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="hqdn3d", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="hqdn3d", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "luma_spatial": luma_spatial,
@@ -5612,7 +6029,9 @@ def hqx(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="hqx", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="hqx", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "n": n,
@@ -5652,7 +6071,9 @@ def hsvhold(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="hsvhold", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="hsvhold", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "hue": hue,
@@ -5697,7 +6118,9 @@ def hsvkey(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="hsvkey", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="hsvkey", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "hue": hue,
@@ -5740,7 +6163,9 @@ def hue(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="hue", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="hue", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "h": h,
@@ -5759,7 +6184,9 @@ def huesaturation(
         hue: Float = Default(0.0),
         saturation: Float = Default(0.0),
         intensity: Float = Default(0.0),
-        colors: Flags | Literal["r", "y", "g", "c", "b", "m", "a"] | Default = Default("r+y+g+c+b+m+a"),
+        colors: Flags | Literal["r", "y", "g", "c", "b", "m", "a"] | Default = Default(
+            "r+y+g+c+b+m+a"
+        ),
         strength: Float = Default(1.0),
         rw: Float = Default(0.333),
         gw: Float = Default(0.334),
@@ -5792,7 +6219,11 @@ def huesaturation(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="huesaturation", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="huesaturation",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "hue": hue,
@@ -5826,7 +6257,9 @@ def hwdownload(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="hwdownload", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="hwdownload", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{} | (extra_options or {}),
         )
@@ -5835,7 +6268,9 @@ def hwdownload(
     def hwmap(
         self,
         *,
-        mode: Flags | Literal["read", "write", "overwrite", "direct"] | Default = Default("read+write"),
+        mode: Flags
+        | Literal["read", "write", "overwrite", "direct"]
+        | Default = Default("read+write"),
         derive_device: String = Default(None),
         reverse: Int = Default(0),
         extra_options: dict[str, Any] = None,
@@ -5857,7 +6292,9 @@ def hwmap(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="hwmap", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="hwmap", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -5889,7 +6326,9 @@ def hwupload(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="hwupload", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="hwupload", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "derive_device": derive_device,
@@ -5904,10 +6343,14 @@ def hysteresis(
         *,
         planes: Int = Default(15),
         threshold: Int = Default(0),
-        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
         shortest: Boolean = Default(False),
         repeatlast: Boolean = Default(True),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -5932,7 +6375,11 @@ def hysteresis(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="hysteresis", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="hysteresis",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _alt,
             **{
@@ -5952,10 +6399,14 @@ def identity(
         self,
         _reference: VideoStream,
         *,
-        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
         shortest: Boolean = Default(False),
         repeatlast: Boolean = Default(True),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -5978,7 +6429,11 @@ def identity(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="identity", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="identity",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _reference,
             **{
@@ -6021,7 +6476,9 @@ def idet(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="idet", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="idet", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "intl_thres": intl_thres,
@@ -6037,9 +6494,15 @@ def idet(
     def il(
         self,
         *,
-        luma_mode: Int | Literal["none", "interleave", "i", "deinterleave", "d"] | Default = Default("none"),
-        chroma_mode: Int | Literal["none", "interleave", "i", "deinterleave", "d"] | Default = Default("none"),
-        alpha_mode: Int | Literal["none", "interleave", "i", "deinterleave", "d"] | Default = Default("none"),
+        luma_mode: Int
+        | Literal["none", "interleave", "i", "deinterleave", "d"]
+        | Default = Default("none"),
+        chroma_mode: Int
+        | Literal["none", "interleave", "i", "deinterleave", "d"]
+        | Default = Default("none"),
+        alpha_mode: Int
+        | Literal["none", "interleave", "i", "deinterleave", "d"]
+        | Default = Default("none"),
         luma_swap: Boolean = Default(False),
         chroma_swap: Boolean = Default(False),
         alpha_swap: Boolean = Default(False),
@@ -6067,7 +6530,9 @@ def il(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="il", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="il", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "luma_mode": luma_mode,
@@ -6111,7 +6576,9 @@ def inflate(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="inflate", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="inflate", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "threshold0": threshold0,
@@ -6128,7 +6595,9 @@ def interlace(
         self,
         *,
         scan: Int | Literal["tff", "bff"] | Default = Default("tff"),
-        lowpass: Int | Literal["off", "linear", "complex"] | Default = Default("linear"),
+        lowpass: Int | Literal["off", "linear", "complex"] | Default = Default(
+            "linear"
+        ),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
         """
@@ -6147,7 +6616,9 @@ def interlace(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="interlace", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="interlace", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "scan": scan,
@@ -6186,7 +6657,9 @@ def kerndeint(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="kerndeint", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="kerndeint", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "thresh": thresh,
@@ -6226,7 +6699,9 @@ def kirsch(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="kirsch", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="kirsch", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "planes": planes,
@@ -6263,7 +6738,9 @@ def lagfun(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="lagfun", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="lagfun", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "decay": decay,
@@ -6295,7 +6772,9 @@ def latency(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="latency", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="latency", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "enable": enable,
@@ -6337,7 +6816,11 @@ def lenscorrection(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="lenscorrection", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="lenscorrection",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "cx": cx,
@@ -6363,10 +6846,14 @@ def libvmaf(
         n_subsample: Int = Default(1),
         model: String = Default("version=vmaf_v0.6.1"),
         feature: String = Default(None),
-        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
         shortest: Boolean = Default(False),
         repeatlast: Boolean = Default(True),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
         """
@@ -6394,7 +6881,11 @@ def libvmaf(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="libvmaf", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="libvmaf",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _reference,
             **{
@@ -6441,7 +6932,9 @@ def limiter(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="limiter", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="limiter", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "min": min,
@@ -6480,7 +6973,9 @@ def loop(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="loop", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="loop", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "loop": loop,
@@ -6519,7 +7014,9 @@ def lumakey(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="lumakey", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="lumakey", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "threshold": threshold,
@@ -6574,7 +7071,9 @@ def lut(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="lut", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="lut", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "c0": c0,
@@ -6598,7 +7097,9 @@ def lut1d(
         self,
         *,
         file: String = Default(None),
-        interp: Int | Literal["nearest", "linear", "cosine", "cubic", "spline"] | Default = Default("linear"),
+        interp: Int
+        | Literal["nearest", "linear", "cosine", "cubic", "spline"]
+        | Default = Default("linear"),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -6619,7 +7120,9 @@ def lut1d(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="lut1d", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="lut1d", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "file": file,
@@ -6639,10 +7142,14 @@ def lut2(
         c2: String = Default("x"),
         c3: String = Default("x"),
         d: Int = Default(0),
-        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
         shortest: Boolean = Default(False),
         repeatlast: Boolean = Default(True),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -6670,7 +7177,9 @@ def lut2(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="lut2", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="lut2", typings_input=("video", "video"), typings_output=("video",)
+            ),
             self,
             _srcy,
             **{
@@ -6718,7 +7227,9 @@ def lut3d(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="lut3d", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="lut3d", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "file": file,
@@ -6773,7 +7284,9 @@ def lutrgb(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="lutrgb", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="lutrgb", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "c0": c0,
@@ -6836,7 +7349,9 @@ def lutyuv(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="lutyuv", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="lutyuv", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "c0": c0,
@@ -6885,7 +7400,11 @@ def maskedclamp(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="maskedclamp", typings_input=("video", "video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="maskedclamp",
+                typings_input=("video", "video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _dark,
             _bright,
@@ -6924,7 +7443,11 @@ def maskedmax(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="maskedmax", typings_input=("video", "video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="maskedmax",
+                typings_input=("video", "video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _filter1,
             _filter2,
@@ -6961,7 +7484,11 @@ def maskedmerge(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="maskedmerge", typings_input=("video", "video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="maskedmerge",
+                typings_input=("video", "video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _overlay,
             _mask,
@@ -6998,7 +7525,11 @@ def maskedmin(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="maskedmin", typings_input=("video", "video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="maskedmin",
+                typings_input=("video", "video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _filter1,
             _filter2,
@@ -7038,7 +7569,11 @@ def maskedthreshold(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="maskedthreshold", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="maskedthreshold",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _reference,
             **{
@@ -7082,7 +7617,9 @@ def maskfun(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="maskfun", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="maskfun", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "low": low,
@@ -7099,7 +7636,9 @@ def maskfun(
     def mcdeint(
         self,
         *,
-        mode: Int | Literal["fast", "medium", "slow", "extra_slow"] | Default = Default("fast"),
+        mode: Int | Literal["fast", "medium", "slow", "extra_slow"] | Default = Default(
+            "fast"
+        ),
         parity: Int | Literal["tff", "bff"] | Default = Default("bff"),
         qp: Int = Default(1),
         extra_options: dict[str, Any] = None,
@@ -7121,7 +7660,9 @@ def mcdeint(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="mcdeint", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="mcdeint", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -7161,7 +7702,9 @@ def median(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="median", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="median", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "radius": radius,
@@ -7201,7 +7744,9 @@ def mestimate(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="mestimate", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="mestimate", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "method": method,
@@ -7215,11 +7760,15 @@ def mestimate(
     def metadata(
         self,
         *,
-        mode: Int | Literal["select", "add", "modify", "delete", "print"] | Default = Default("select"),
+        mode: Int
+        | Literal["select", "add", "modify", "delete", "print"]
+        | Default = Default("select"),
         key: String = Default(None),
         value: String = Default(None),
         function: Int
-        | Literal["same_str", "starts_with", "less", "equal", "greater", "expr", "ends_with"]
+        | Literal[
+            "same_str", "starts_with", "less", "equal", "greater", "expr", "ends_with"
+        ]
         | Default = Default("same_str"),
         expr: String = Default(None),
         file: String = Default(None),
@@ -7249,7 +7798,9 @@ def metadata(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="metadata", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="metadata", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -7289,7 +7840,11 @@ def midequalizer(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="midequalizer", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="midequalizer",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _in1,
             **{
@@ -7341,7 +7896,9 @@ def minterpolate(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="minterpolate", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="minterpolate", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "fps": fps,
@@ -7388,7 +7945,9 @@ def monochrome(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="monochrome", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="monochrome", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "cb": cb,
@@ -7410,10 +7969,14 @@ def morpho(
         | Default = Default("erode"),
         planes: Int = Default(7),
         structure: Int | Literal["first", "all"] | Default = Default("all"),
-        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
         shortest: Boolean = Default(False),
         repeatlast: Boolean = Default(True),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -7439,7 +8002,11 @@ def morpho(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="morpho", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="morpho",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _structure,
             **{
@@ -7485,7 +8052,9 @@ def mpdecimate(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="mpdecimate", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="mpdecimate", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "max": max,
@@ -7502,10 +8071,14 @@ def msad(
         self,
         _reference: VideoStream,
         *,
-        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
         shortest: Boolean = Default(False),
         repeatlast: Boolean = Default(True),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -7528,7 +8101,9 @@ def msad(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="msad", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="msad", typings_input=("video", "video"), typings_output=("video",)
+            ),
             self,
             _reference,
             **{
@@ -7570,7 +8145,11 @@ def multiply(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="multiply", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="multiply",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _factor,
             **{
@@ -7586,7 +8165,9 @@ def multiply(
     def negate(
         self,
         *,
-        components: Flags | Literal["y", "u", "v", "r", "g", "b", "a"] | Default = Default("y+u+v+r+g+b"),
+        components: Flags
+        | Literal["y", "u", "v", "r", "g", "b", "a"]
+        | Default = Default("y+u+v+r+g+b"),
         negate_alpha: Boolean = Default(False),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
@@ -7608,7 +8189,9 @@ def negate(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="negate", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="negate", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "components": components,
@@ -7650,7 +8233,9 @@ def nlmeans(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="nlmeans", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="nlmeans", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "s": s,
@@ -7671,11 +8256,17 @@ def nnedi(
         deint: Int | Literal["all", "interlaced"] | Default = Default("all"),
         field: Int | Literal["af", "a", "t", "b", "tf", "bf"] | Default = Default("a"),
         planes: Int = Default(7),
-        nsize: Int | Literal["s8x6", "s16x6", "s32x6", "s48x6", "s8x4", "s16x4", "s32x4"] | Default = Default("s32x4"),
-        nns: Int | Literal["n16", "n32", "n64", "n128", "n256"] | Default = Default("n32"),
+        nsize: Int
+        | Literal["s8x6", "s16x6", "s32x6", "s48x6", "s8x4", "s16x4", "s32x4"]
+        | Default = Default("s32x4"),
+        nns: Int | Literal["n16", "n32", "n64", "n128", "n256"] | Default = Default(
+            "n32"
+        ),
         qual: Int | Literal["fast", "slow"] | Default = Default("fast"),
         etype: Int | Literal["a", "abs", "s", "mse"] | Default = Default("a"),
-        pscrn: Int | Literal["none", "original", "new", "new2", "new3"] | Default = Default("new"),
+        pscrn: Int
+        | Literal["none", "original", "new", "new2", "new3"]
+        | Default = Default("new"),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -7703,7 +8294,9 @@ def nnedi(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="nnedi", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="nnedi", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "weights": weights,
@@ -7742,7 +8335,9 @@ def noformat(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="noformat", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="noformat", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "pix_fmts": pix_fmts,
@@ -7802,7 +8397,9 @@ def noise(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="noise", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="noise", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "all_seed": all_seed,
@@ -7857,7 +8454,9 @@ def normalize(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="normalize", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="normalize", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "blackpt": blackpt,
@@ -7887,7 +8486,9 @@ def null(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="null", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="null", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{} | (extra_options or {}),
         )
@@ -7898,7 +8499,9 @@ def ocr(
         *,
         datapath: String = Default(None),
         language: String = Default("eng"),
-        whitelist: String = Default("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.:;,-+_!?\"'[]{}("),
+        whitelist: String = Default(
+            "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.:;,-+_!?\"'[]{}("
+        ),
         blacklist: String = Default(""),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -7920,7 +8523,9 @@ def ocr(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="ocr", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="ocr", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "datapath": datapath,
@@ -7979,7 +8584,9 @@ def oscilloscope(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="oscilloscope", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="oscilloscope", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "x": x,
@@ -8007,15 +8614,31 @@ def overlay(
         *,
         x: String = Default("0"),
         y: String = Default("0"),
-        eof_action: Int | Literal["repeat", "endall", "pass", "repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int
+        | Literal["repeat", "endall", "pass", "repeat", "endall", "pass"]
+        | Default = Default("repeat"),
         eval: Int | Literal["init", "frame"] | Default = Default("frame"),
         shortest: Boolean = Default(False),
         format: Int
-        | Literal["yuv420", "yuv420p10", "yuv422", "yuv422p10", "yuv444", "yuv444p10", "rgb", "gbrp", "auto"]
+        | Literal[
+            "yuv420",
+            "yuv420p10",
+            "yuv422",
+            "yuv422p10",
+            "yuv444",
+            "yuv444p10",
+            "rgb",
+            "gbrp",
+            "auto",
+        ]
         | Default = Default("yuv420"),
         repeatlast: Boolean = Default(True),
-        alpha: Int | Literal["straight", "premultiplied"] | Default = Default("straight"),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        alpha: Int | Literal["straight", "premultiplied"] | Default = Default(
+            "straight"
+        ),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -8043,7 +8666,11 @@ def overlay(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="overlay", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="overlay",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _overlay,
             **{
@@ -8089,7 +8716,9 @@ def owdenoise(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="owdenoise", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="owdenoise", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "depth": depth,
@@ -8134,7 +8763,9 @@ def pad(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="pad", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="pad", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "width": width,
@@ -8176,7 +8807,9 @@ def palettegen(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="palettegen", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="palettegen", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "max_colors": max_colors,
@@ -8193,7 +8826,16 @@ def paletteuse(
         _palette: VideoStream,
         *,
         dither: Int
-        | Literal["bayer", "heckbert", "floyd_steinberg", "sierra2", "sierra2_4a", "sierra3", "burkes", "atkinson"]
+        | Literal[
+            "bayer",
+            "heckbert",
+            "floyd_steinberg",
+            "sierra2",
+            "sierra2_4a",
+            "sierra3",
+            "burkes",
+            "atkinson",
+        ]
         | Default = Default("sierra2_4a"),
         bayer_scale: Int = Default(2),
         diff_mode: Int | Literal["rectangle"] | Default = Default(0),
@@ -8222,7 +8864,11 @@ def paletteuse(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="paletteuse", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="paletteuse",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _palette,
             **{
@@ -8240,7 +8886,9 @@ def paletteuse(
     def perms(
         self,
         *,
-        mode: Int | Literal["none", "ro", "rw", "toggle", "random"] | Default = Default("none"),
+        mode: Int | Literal["none", "ro", "rw", "toggle", "random"] | Default = Default(
+            "none"
+        ),
         seed: Int64 = Default(-1),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
@@ -8262,7 +8910,9 @@ def perms(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="perms", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="perms", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -8316,7 +8966,9 @@ def perspective(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="perspective", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="perspective", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "x0": x0,
@@ -8339,7 +8991,9 @@ def perspective(
     def phase(
         self,
         *,
-        mode: Int | Literal["p", "t", "b", "T", "B", "u", "U", "a", "A"] | Default = Default("A"),
+        mode: Int
+        | Literal["p", "t", "b", "T", "B", "u", "U", "a", "A"]
+        | Default = Default("A"),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -8359,7 +9013,9 @@ def phase(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="phase", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="phase", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -8396,7 +9052,11 @@ def photosensitivity(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="photosensitivity", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="photosensitivity",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "frames": frames,
@@ -8424,7 +9084,9 @@ def pixdesctest(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="pixdesctest", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="pixdesctest", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{} | (extra_options or {}),
         )
@@ -8459,7 +9121,9 @@ def pixelize(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="pixelize", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="pixelize", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "width": width,
@@ -8507,7 +9171,9 @@ def pixscope(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="pixscope", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="pixscope", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "x": x,
@@ -8546,7 +9212,9 @@ def pp(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="pp", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="pp", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "subfilters": subfilters,
@@ -8581,7 +9249,9 @@ def pp7(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="pp7", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="pp7", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "qp": qp,
@@ -8619,7 +9289,9 @@ def prewitt(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="prewitt", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="prewitt", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "planes": planes,
@@ -8691,7 +9363,9 @@ def pseudocolor(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="pseudocolor", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="pseudocolor", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "c0": c0,
@@ -8714,10 +9388,14 @@ def psnr(
         stats_file: String = Default(None),
         stats_version: Int = Default(1),
         output_max: Boolean = Default(False),
-        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
         shortest: Boolean = Default(False),
         repeatlast: Boolean = Default(True),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -8743,7 +9421,9 @@ def psnr(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="psnr", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="psnr", typings_input=("video", "video"), typings_output=("video",)
+            ),
             self,
             _reference,
             **{
@@ -8791,7 +9471,9 @@ def pullup(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="pullup", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="pullup", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "jl": jl,
@@ -8828,7 +9510,9 @@ def qp(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="qp", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="qp", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "qp": qp,
@@ -8861,7 +9545,9 @@ def random(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="random", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="random", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "frames": frames,
@@ -8902,7 +9588,9 @@ def readeia608(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="readeia608", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="readeia608", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "scan_min": scan_min,
@@ -8941,7 +9629,9 @@ def readvitc(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="readvitc", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="readvitc", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "scan_max": scan_max,
@@ -8975,7 +9665,9 @@ def realtime(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="realtime", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="realtime", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "limit": limit,
@@ -9010,7 +9702,11 @@ def remap(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="remap", typings_input=("video", "video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="remap",
+                typings_input=("video", "video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _xmap,
             _ymap,
@@ -9051,7 +9747,9 @@ def removegrain(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="removegrain", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="removegrain", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "m0": m0,
@@ -9087,7 +9785,9 @@ def removelogo(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="removelogo", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="removelogo", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "filename": filename,
@@ -9113,7 +9813,9 @@ def repeatfields(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="repeatfields", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="repeatfields", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{} | (extra_options or {}),
         )
@@ -9135,7 +9837,9 @@ def reverse(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="reverse", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="reverse", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{} | (extra_options or {}),
         )
@@ -9180,7 +9884,9 @@ def rgbashift(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="rgbashift", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="rgbashift", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "rh": rh,
@@ -9225,7 +9931,9 @@ def roberts(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="roberts", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="roberts", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "planes": planes,
@@ -9268,7 +9976,9 @@ def rotate(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="rotate", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="rotate", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "angle": angle,
@@ -9315,7 +10025,9 @@ def sab(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="sab", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="sab", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "luma_radius": luma_radius,
@@ -9338,10 +10050,14 @@ def scale(
         flags: String = Default(""),
         interl: Boolean = Default(False),
         in_color_matrix: String
-        | Literal["auto", "bt601", "bt470", "smpte170m", "bt709", "fcc", "smpte240m", "bt2020"]
+        | Literal[
+            "auto", "bt601", "bt470", "smpte170m", "bt709", "fcc", "smpte240m", "bt2020"
+        ]
         | Default = Default("auto"),
         out_color_matrix: String
-        | Literal["auto", "bt601", "bt470", "smpte170m", "bt709", "fcc", "smpte240m", "bt2020"]
+        | Literal[
+            "auto", "bt601", "bt470", "smpte170m", "bt709", "fcc", "smpte240m", "bt2020"
+        ]
         | Default = Default(None),
         in_range: Int
         | Literal["auto", "unknown", "full", "limited", "jpeg", "mpeg", "tv", "pc"]
@@ -9353,7 +10069,9 @@ def scale(
         in_h_chr_pos: Int = Default(-513),
         out_v_chr_pos: Int = Default(-513),
         out_h_chr_pos: Int = Default(-513),
-        force_original_aspect_ratio: Int | Literal["disable", "decrease", "increase"] | Default = Default("disable"),
+        force_original_aspect_ratio: Int
+        | Literal["disable", "decrease", "increase"]
+        | Default = Default("disable"),
         force_divisible_by: Int = Default(1),
         param0: Double = Default("DBL_MAX"),
         param1: Double = Default("DBL_MAX"),
@@ -9391,7 +10109,9 @@ def scale(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="scale", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="scale", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "w": w,
@@ -9445,7 +10165,9 @@ def scale_vt(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="scale_vt", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="scale_vt", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "w": w,
@@ -9481,7 +10203,9 @@ def scdet(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="scdet", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="scdet", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "threshold": threshold,
@@ -9518,7 +10242,9 @@ def scharr(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="scharr", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="scharr", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "planes": planes,
@@ -9559,7 +10285,9 @@ def scroll(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="scroll", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="scroll", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "horizontal": horizontal,
@@ -9636,7 +10364,9 @@ def select(
         """
         filter_node = filter_node_factory(
             FFMpegFilterDef(
-                name="select", typings_input=("video",), typings_output="[StreamType.video] * int(outputs)"
+                name="select",
+                typings_input=("video",),
+                typings_output="[StreamType.video] * int(outputs)",
             ),
             self,
             **{
@@ -9651,7 +10381,9 @@ def select(
     def selectivecolor(
         self,
         *,
-        correction_method: Int | Literal["absolute", "relative"] | Default = Default("absolute"),
+        correction_method: Int | Literal["absolute", "relative"] | Default = Default(
+            "absolute"
+        ),
         reds: String = Default(None),
         yellows: String = Default(None),
         greens: String = Default(None),
@@ -9691,7 +10423,11 @@ def selectivecolor(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="selectivecolor", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="selectivecolor",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "correction_method": correction_method,
@@ -9734,7 +10470,9 @@ def sendcmd(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="sendcmd", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="sendcmd", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "commands": commands,
@@ -9760,7 +10498,11 @@ def separatefields(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="separatefields", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="separatefields",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{} | (extra_options or {}),
         )
@@ -9789,7 +10531,9 @@ def setdar(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="setdar", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="setdar", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "dar": dar,
@@ -9820,7 +10564,9 @@ def setfield(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="setfield", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="setfield", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -9832,9 +10578,21 @@ def setfield(
     def setparams(
         self,
         *,
-        field_mode: Int | Literal["auto", "bff", "tff", "prog"] | Default = Default("auto"),
+        field_mode: Int | Literal["auto", "bff", "tff", "prog"] | Default = Default(
+            "auto"
+        ),
         range: Int
-        | Literal["auto", "unspecified", "unknown", "limited", "tv", "mpeg", "full", "pc", "jpeg"]
+        | Literal[
+            "auto",
+            "unspecified",
+            "unknown",
+            "limited",
+            "tv",
+            "mpeg",
+            "full",
+            "pc",
+            "jpeg",
+        ]
         | Default = Default("auto"),
         color_primaries: Int
         | Literal[
@@ -9916,7 +10674,9 @@ def setparams(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="setparams", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="setparams", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "field_mode": field_mode,
@@ -9950,7 +10710,9 @@ def setpts(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="setpts", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="setpts", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "expr": expr,
@@ -9963,7 +10725,17 @@ def setrange(
         self,
         *,
         range: Int
-        | Literal["auto", "unspecified", "unknown", "limited", "tv", "mpeg", "full", "pc", "jpeg"]
+        | Literal[
+            "auto",
+            "unspecified",
+            "unknown",
+            "limited",
+            "tv",
+            "mpeg",
+            "full",
+            "pc",
+            "jpeg",
+        ]
         | Default = Default("auto"),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -9982,7 +10754,9 @@ def setrange(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="setrange", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="setrange", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "range": range,
@@ -10014,7 +10788,9 @@ def setsar(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="setsar", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="setsar", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "sar": sar,
@@ -10045,7 +10821,9 @@ def settb(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="settb", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="settb", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "expr": expr,
@@ -10083,7 +10861,9 @@ def shear(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="shear", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="shear", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "shx": shx,
@@ -10117,7 +10897,9 @@ def showinfo(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="showinfo", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="showinfo", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "checksum": checksum,
@@ -10147,7 +10929,9 @@ def showpalette(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="showpalette", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="showpalette", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "s": s,
@@ -10179,7 +10963,11 @@ def shuffleframes(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="shuffleframes", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="shuffleframes",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "mapping": mapping,
@@ -10193,7 +10981,9 @@ def shufflepixels(
         self,
         *,
         direction: Int | Literal["forward", "inverse"] | Default = Default("forward"),
-        mode: Int | Literal["horizontal", "vertical", "block"] | Default = Default("horizontal"),
+        mode: Int | Literal["horizontal", "vertical", "block"] | Default = Default(
+            "horizontal"
+        ),
         width: Int = Default(10),
         height: Int = Default(10),
         seed: Int64 = Default(-1),
@@ -10220,7 +11010,11 @@ def shufflepixels(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="shufflepixels", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="shufflepixels",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "direction": direction,
@@ -10263,7 +11057,11 @@ def shuffleplanes(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="shuffleplanes", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="shuffleplanes",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "map0": map0,
@@ -10325,7 +11123,9 @@ def sidedata(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="sidedata", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="sidedata", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -10361,7 +11161,9 @@ def signalstats(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="signalstats", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="signalstats", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "stat": stat,
@@ -10393,7 +11195,9 @@ def siti(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="siti", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="siti", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "print_summary": print_summary,
@@ -10435,7 +11239,9 @@ def smartblur(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="smartblur", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="smartblur", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "luma_radius": luma_radius,
@@ -10477,7 +11283,9 @@ def sobel(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="sobel", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="sobel", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "planes": planes,
@@ -10496,7 +11304,9 @@ def spectrumsynth(
         sample_rate: Int = Default(44100),
         channels: Int = Default(1),
         scale: Int | Literal["lin", "log"] | Default = Default("log"),
-        slide: Int | Literal["replace", "scroll", "fullframe", "rscroll"] | Default = Default("fullframe"),
+        slide: Int
+        | Literal["replace", "scroll", "fullframe", "rscroll"]
+        | Default = Default("fullframe"),
         win_func: Int
         | Literal[
             "rect",
@@ -10524,7 +11334,9 @@ def spectrumsynth(
         ]
         | Default = Default("rect"),
         overlap: Float = Default(1.0),
-        orientation: Int | Literal["vertical", "horizontal"] | Default = Default("vertical"),
+        orientation: Int | Literal["vertical", "horizontal"] | Default = Default(
+            "vertical"
+        ),
         extra_options: dict[str, Any] = None,
     ) -> AudioStream:
         """
@@ -10548,7 +11360,11 @@ def spectrumsynth(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="spectrumsynth", typings_input=("video", "video"), typings_output=("audio",)),
+            FFMpegFilterDef(
+                name="spectrumsynth",
+                typings_input=("video", "video"),
+                typings_output=("audio",),
+            ),
             self,
             _phase,
             **{
@@ -10586,7 +11402,11 @@ def split(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="split", typings_input=("video",), typings_output="[StreamType.video] * int(outputs)"),
+            FFMpegFilterDef(
+                name="split",
+                typings_input=("video",),
+                typings_output="[StreamType.video] * int(outputs)",
+            ),
             self,
             **{
                 "outputs": outputs,
@@ -10625,7 +11445,9 @@ def spp(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="spp", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="spp", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "quality": quality,
@@ -10667,7 +11489,9 @@ def sr(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="sr", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="sr", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "dnn_backend": dnn_backend,
@@ -10685,10 +11509,14 @@ def ssim(
         _reference: VideoStream,
         *,
         stats_file: String = Default(None),
-        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
         shortest: Boolean = Default(False),
         repeatlast: Boolean = Default(True),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -10712,7 +11540,9 @@ def ssim(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="ssim", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="ssim", typings_input=("video", "video"), typings_output=("video",)
+            ),
             self,
             _reference,
             **{
@@ -10811,7 +11641,9 @@ def stereo3d(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="stereo3d", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="stereo3d", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "in": _in,
@@ -10856,7 +11688,9 @@ def subtitles(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="subtitles", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="subtitles", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "filename": filename,
@@ -10888,7 +11722,9 @@ def super2xsai(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="super2xsai", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="super2xsai", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{} | (extra_options or {}),
         )
@@ -10927,7 +11763,9 @@ def swaprect(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="swaprect", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="swaprect", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "w": w,
@@ -10963,7 +11801,9 @@ def swapuv(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="swapuv", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="swapuv", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "enable": enable,
@@ -11248,7 +12088,9 @@ def tblend(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="tblend", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="tblend", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "c0_mode": c0_mode,
@@ -11275,7 +12117,9 @@ def tblend(
     def telecine(
         self,
         *,
-        first_field: Int | Literal["top", "t", "bottom", "b"] | Default = Default("top"),
+        first_field: Int | Literal["top", "t", "bottom", "b"] | Default = Default(
+            "top"
+        ),
         pattern: String = Default("23"),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -11295,7 +12139,9 @@ def telecine(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="telecine", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="telecine", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "first_field": first_field,
@@ -11309,13 +12155,19 @@ def thistogram(
         self,
         *,
         width: Int = Default(0),
-        display_mode: Int | Literal["overlay", "parade", "stack"] | Default = Default("stack"),
-        levels_mode: Int | Literal["linear", "logarithmic"] | Default = Default("linear"),
+        display_mode: Int | Literal["overlay", "parade", "stack"] | Default = Default(
+            "stack"
+        ),
+        levels_mode: Int | Literal["linear", "logarithmic"] | Default = Default(
+            "linear"
+        ),
         components: Int = Default(7),
         bgopacity: Float = Default(0.9),
         envelope: Boolean = Default(False),
         ecolor: Color = Default("gold"),
-        slide: Int | Literal["frame", "replace", "scroll", "rscroll", "picture"] | Default = Default("replace"),
+        slide: Int
+        | Literal["frame", "replace", "scroll", "rscroll", "picture"]
+        | Default = Default("replace"),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
         """
@@ -11340,7 +12192,9 @@ def thistogram(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="thistogram", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="thistogram", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "width": width,
@@ -11383,7 +12237,9 @@ def threshold(
         """
         filter_node = filter_node_factory(
             FFMpegFilterDef(
-                name="threshold", typings_input=("video", "video", "video", "video"), typings_output=("video",)
+                name="threshold",
+                typings_input=("video", "video", "video", "video"),
+                typings_output=("video",),
             ),
             self,
             _threshold,
@@ -11422,7 +12278,9 @@ def thumbnail(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="thumbnail", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="thumbnail", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "n": n,
@@ -11466,7 +12324,9 @@ def tile(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="tile", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="tile", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "layout": layout,
@@ -11486,7 +12346,14 @@ def tinterlace(
         *,
         mode: Int
         | Literal[
-            "merge", "drop_even", "drop_odd", "pad", "interleave_top", "interleave_bottom", "interlacex2", "mergex2"
+            "merge",
+            "drop_even",
+            "drop_odd",
+            "pad",
+            "interleave_top",
+            "interleave_bottom",
+            "interlacex2",
+            "mergex2",
         ]
         | Default = Default("merge"),
         extra_options: dict[str, Any] = None,
@@ -11506,7 +12373,9 @@ def tinterlace(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="tinterlace", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="tinterlace", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -11544,7 +12413,9 @@ def tlut2(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="tlut2", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="tlut2", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "c0": c0,
@@ -11584,7 +12455,9 @@ def tmedian(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="tmedian", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="tmedian", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "radius": radius,
@@ -11623,7 +12496,11 @@ def tmidequalizer(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="tmidequalizer", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="tmidequalizer",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "radius": radius,
@@ -11664,7 +12541,9 @@ def tmix(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="tmix", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="tmix", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "frames": frames,
@@ -11706,7 +12585,9 @@ def tonemap(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="tonemap", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="tonemap", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "tonemap": tonemap,
@@ -11751,7 +12632,9 @@ def tpad(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="tpad", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="tpad", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "start": start,
@@ -11769,8 +12652,12 @@ def tpad(
     def transpose(
         self,
         *,
-        dir: Int | Literal["cclock_flip", "clock", "cclock", "clock_flip"] | Default = Default("cclock_flip"),
-        passthrough: Int | Literal["none", "portrait", "landscape"] | Default = Default("none"),
+        dir: Int
+        | Literal["cclock_flip", "clock", "cclock", "clock_flip"]
+        | Default = Default("cclock_flip"),
+        passthrough: Int | Literal["none", "portrait", "landscape"] | Default = Default(
+            "none"
+        ),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
         """
@@ -11789,7 +12676,9 @@ def transpose(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="transpose", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="transpose", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "dir": dir,
@@ -11803,9 +12692,13 @@ def transpose_vt(
         self,
         *,
         dir: Int
-        | Literal["cclock_flip", "clock", "cclock", "clock_flip", "reversal", "hflip", "vflip"]
+        | Literal[
+            "cclock_flip", "clock", "cclock", "clock_flip", "reversal", "hflip", "vflip"
+        ]
         | Default = Default("cclock_flip"),
-        passthrough: Int | Literal["none", "portrait", "landscape"] | Default = Default("none"),
+        passthrough: Int | Literal["none", "portrait", "landscape"] | Default = Default(
+            "none"
+        ),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
         """
@@ -11824,7 +12717,9 @@ def transpose_vt(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="transpose_vt", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="transpose_vt", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "dir": dir,
@@ -11867,7 +12762,9 @@ def trim(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="trim", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="trim", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "start": start,
@@ -11921,7 +12818,9 @@ def unsharp(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="unsharp", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="unsharp", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "luma_msize_x": luma_msize_x,
@@ -11960,7 +12859,9 @@ def untile(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="untile", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="untile", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "layout": layout,
@@ -11998,7 +12899,9 @@ def uspp(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="uspp", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="uspp", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "quality": quality,
@@ -12184,7 +13087,9 @@ def v360(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="v360", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="v360", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "input": input,
@@ -12261,7 +13166,11 @@ def vaguedenoiser(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="vaguedenoiser", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="vaguedenoiser",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "threshold": threshold,
@@ -12283,10 +13192,14 @@ def varblur(
         min_r: Int = Default(0),
         max_r: Int = Default(8),
         planes: Int = Default(15),
-        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
         shortest: Boolean = Default(False),
         repeatlast: Boolean = Default(True),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -12312,7 +13225,11 @@ def varblur(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="varblur", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="varblur",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _radius,
             **{
@@ -12338,8 +13255,12 @@ def vectorscope(
         x: Int = Default(1),
         y: Int = Default(2),
         intensity: Float = Default(0.004),
-        envelope: Int | Literal["none", "instant", "peak", "instant"] | Default = Default("none"),
-        graticule: Int | Literal["none", "green", "color", "invert"] | Default = Default("none"),
+        envelope: Int
+        | Literal["none", "instant", "peak", "instant"]
+        | Default = Default("none"),
+        graticule: Int
+        | Literal["none", "green", "color", "invert"]
+        | Default = Default("none"),
         opacity: Float = Default(0.75),
         flags: Flags | Literal["white", "black", "name"] | Default = Default("name"),
         bgopacity: Float = Default(0.3),
@@ -12378,7 +13299,9 @@ def vectorscope(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="vectorscope", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="vectorscope", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -12421,7 +13344,9 @@ def vflip(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="vflip", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="vflip", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "enable": enable,
@@ -12446,7 +13371,9 @@ def vfrdet(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="vfrdet", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="vfrdet", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{} | (extra_options or {}),
         )
@@ -12489,7 +13416,9 @@ def vibrance(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="vibrance", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="vibrance", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "intensity": intensity,
@@ -12541,7 +13470,11 @@ def vidstabdetect(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="vidstabdetect", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="vidstabdetect",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "result": result,
@@ -12571,7 +13504,9 @@ def vidstabtransform(
         zoom: Double = Default(0.0),
         optzoom: Int = Default(1),
         zoomspeed: Double = Default(0.25),
-        interpol: Int | Literal["no", "linear", "bilinear", "bicubic"] | Default = Default("bilinear"),
+        interpol: Int
+        | Literal["no", "linear", "bilinear", "bicubic"]
+        | Default = Default("bilinear"),
         tripod: Boolean = Default(False),
         debug: Boolean = Default(False),
         extra_options: dict[str, Any] = None,
@@ -12604,7 +13539,11 @@ def vidstabtransform(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="vidstabtransform", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="vidstabtransform",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
             self,
             **{
                 "input": input,
@@ -12630,10 +13569,14 @@ def vif(
         self,
         _reference: VideoStream,
         *,
-        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
         shortest: Boolean = Default(False),
         repeatlast: Boolean = Default(True),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -12656,7 +13599,9 @@ def vif(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="vif", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="vif", typings_input=("video", "video"), typings_output=("video",)
+            ),
             self,
             _reference,
             **{
@@ -12705,7 +13650,9 @@ def vignette(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="vignette", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="vignette", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "angle": angle,
@@ -12742,7 +13689,9 @@ def vmafmotion(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="vmafmotion", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="vmafmotion", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "stats_file": stats_file,
@@ -12780,7 +13729,9 @@ def w3fdif(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="w3fdif", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="w3fdif", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "filter": filter,
@@ -12799,16 +13750,26 @@ def waveform(
         mode: Int | Literal["row", "column"] | Default = Default("column"),
         intensity: Float = Default(0.04),
         mirror: Boolean = Default(True),
-        display: Int | Literal["overlay", "stack", "parade"] | Default = Default("stack"),
+        display: Int | Literal["overlay", "stack", "parade"] | Default = Default(
+            "stack"
+        ),
         components: Int = Default(1),
-        envelope: Int | Literal["none", "instant", "peak", "instant"] | Default = Default("none"),
+        envelope: Int
+        | Literal["none", "instant", "peak", "instant"]
+        | Default = Default("none"),
         filter: Int
-        | Literal["lowpass", "flat", "aflat", "chroma", "color", "acolor", "xflat", "yflat"]
+        | Literal[
+            "lowpass", "flat", "aflat", "chroma", "color", "acolor", "xflat", "yflat"
+        ]
         | Default = Default("lowpass"),
-        graticule: Int | Literal["none", "green", "orange", "invert"] | Default = Default("none"),
+        graticule: Int
+        | Literal["none", "green", "orange", "invert"]
+        | Default = Default("none"),
         opacity: Float = Default(0.75),
         flags: Flags | Literal["numbers", "dots"] | Default = Default("numbers"),
-        scale: Int | Literal["digital", "millivolts", "ire"] | Default = Default("digital"),
+        scale: Int | Literal["digital", "millivolts", "ire"] | Default = Default(
+            "digital"
+        ),
         bgopacity: Float = Default(0.75),
         tint0: Float = Default(0.0),
         tint1: Float = Default(0.0),
@@ -12846,7 +13807,9 @@ def waveform(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="waveform", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="waveform", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -12873,7 +13836,9 @@ def waveform(
     def weave(
         self,
         *,
-        first_field: Int | Literal["top", "t", "bottom", "b"] | Default = Default("top"),
+        first_field: Int | Literal["top", "t", "bottom", "b"] | Default = Default(
+            "top"
+        ),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
         """
@@ -12891,7 +13856,9 @@ def weave(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="weave", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="weave", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "first_field": first_field,
@@ -12921,7 +13888,9 @@ def xbr(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="xbr", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="xbr", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "n": n,
@@ -12936,10 +13905,14 @@ def xcorrelate(
         *,
         planes: Int = Default(7),
         secondary: Int | Literal["first", "all"] | Default = Default("all"),
-        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
         shortest: Boolean = Default(False),
         repeatlast: Boolean = Default(True),
-        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default("default"),
+        ts_sync_mode: Int | Literal["default", "nearest"] | Default = Default(
+            "default"
+        ),
         enable: String = Default(None),
         extra_options: dict[str, Any] = None,
     ) -> VideoStream:
@@ -12964,7 +13937,11 @@ def xcorrelate(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="xcorrelate", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="xcorrelate",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _secondary,
             **{
@@ -13070,7 +14047,11 @@ def xfade(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="xfade", typings_input=("video", "video"), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="xfade",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
             self,
             _xfade,
             **{
@@ -13087,7 +14068,9 @@ def yadif(
         self,
         *,
         mode: Int
-        | Literal["send_frame", "send_field", "send_frame_nospatial", "send_field_nospatial"]
+        | Literal[
+            "send_frame", "send_field", "send_frame_nospatial", "send_field_nospatial"
+        ]
         | Default = Default("send_frame"),
         parity: Int | Literal["tff", "bff", "auto"] | Default = Default("auto"),
         deint: Int | Literal["all", "interlaced"] | Default = Default("all"),
@@ -13112,7 +14095,9 @@ def yadif(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="yadif", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="yadif", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "mode": mode,
@@ -13151,7 +14136,9 @@ def yaepblur(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="yaepblur", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="yaepblur", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "radius": radius,
@@ -13184,7 +14171,9 @@ def zmq(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="zmq", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="zmq", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "bind_address": bind_address,
@@ -13224,7 +14213,9 @@ def zoompan(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="zoompan", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="zoompan", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "zoom": zoom,
@@ -13244,11 +14235,15 @@ def zscale(
         w: String = Default(None),
         h: String = Default(None),
         size: String = Default(None),
-        dither: Int | Literal["none", "ordered", "random", "error_diffusion"] | Default = Default("none"),
+        dither: Int
+        | Literal["none", "ordered", "random", "error_diffusion"]
+        | Default = Default("none"),
         filter: Int
         | Literal["point", "bilinear", "bicubic", "spline16", "spline36", "lanczos"]
         | Default = Default("bilinear"),
-        out_range: Int | Literal["input", "limited", "full", "unknown", "tv", "pc"] | Default = Default("input"),
+        out_range: Int
+        | Literal["input", "limited", "full", "unknown", "tv", "pc"]
+        | Default = Default("input"),
         primaries: Int
         | Literal[
             "input",
@@ -13322,7 +14317,9 @@ def zscale(
             "ictcp",
         ]
         | Default = Default("input"),
-        in_range: Int | Literal["input", "limited", "full", "unknown", "tv", "pc"] | Default = Default("input"),
+        in_range: Int
+        | Literal["input", "limited", "full", "unknown", "tv", "pc"]
+        | Default = Default("input"),
         primariesin: Int
         | Literal[
             "input",
@@ -13441,7 +14438,9 @@ def zscale(
 
         """
         filter_node = filter_node_factory(
-            FFMpegFilterDef(name="zscale", typings_input=("video",), typings_output=("video",)),
+            FFMpegFilterDef(
+                name="zscale", typings_input=("video",), typings_output=("video",)
+            ),
             self,
             **{
                 "w": w,
diff --git a/src/ffmpeg/tests/test_base.py b/src/ffmpeg/tests/test_base.py
index fad7426e..3d8fd6c1 100644
--- a/src/ffmpeg/tests/test_base.py
+++ b/src/ffmpeg/tests/test_base.py
@@ -59,23 +59,34 @@ def test_compile(snapshot: SnapshotAssertion) -> None:
 def test_generate_thumbnail_for_video(snapshot: SnapshotAssertion) -> None:
     # ["ffmpeg", "-ss", "10", "-i", "input.mp4", "-filter_complex", "[0]scale=800:-1[s0]", "-map", "[s0]", "-vframes", "1", "output.mp4"]
     assert snapshot(extension_class=JSONSnapshotExtension) == (
-        input("input.mp4", ss=10).scale(w="800", h="-1").output(filename="output.mp4", vframes=1).compile()
+        input("input.mp4", ss=10)
+        .scale(w="800", h="-1")
+        .output(filename="output.mp4", vframes=1)
+        .compile()
     )
 
 
 def test_assemble_video_from_sequence_of_frames(snapshot: SnapshotAssertion) -> None:
     # ["ffmpeg", "-framerate", "25", "-pattern_type", "glob", "-i", "/path/to/jpegs/*.jpg", "movie.mp4""]
     assert snapshot(extension_class=JSONSnapshotExtension) == (
-        input("/path/to/jpegs/*.jpg", extra_options={"framerate": 25, "pattern_type": "glob"})
+        input(
+            "/path/to/jpegs/*.jpg",
+            extra_options={"framerate": 25, "pattern_type": "glob"},
+        )
         .output(filename="movie.mp4")
         .compile()
     )
 
 
-def test_assemble_video_from_sequence_of_frames_with_additional_filtering(snapshot: SnapshotAssertion) -> None:
+def test_assemble_video_from_sequence_of_frames_with_additional_filtering(
+    snapshot: SnapshotAssertion,
+) -> None:
     # ["ffmpeg", "-framerate", "25", "-pattern_type", "glob", "-i", "/path/to/jpegs/*.jpg", "-filter_complex", "[0]deflicker=mode=pm:size=10[s0];[s0]scale=force_original_aspect_ratio=increase:size=hd1080[s1]", "-map", "[s1]", "-crf", "20", "-movflags", "faststart", "-pix_fmt", "yuv420p", "-preset", "slower", "movie.mp4"]
     assert snapshot(extension_class=JSONSnapshotExtension) == (
-        input("/path/to/jpegs/*.jpg", extra_options={"framerate": 25, "pattern_type": "glob"})
+        input(
+            "/path/to/jpegs/*.jpg",
+            extra_options={"framerate": 25, "pattern_type": "glob"},
+        )
         .deflicker(mode="pm", size=10)
         # FIXME: scale's w,h options should be optional
         .scale(force_original_aspect_ratio="increase", extra_options={"size": "hd1080"})
@@ -99,7 +110,10 @@ def test_audio_video_pipeline(snapshot: SnapshotAssertion) -> None:
     joined = concat(v1, a1, v2, a2, v=1, a=1)
     v3 = joined.video(0)
     a3 = joined.audio(0).volume(volume="0.8")
-    assert snapshot(extension_class=JSONSnapshotExtension) == output(v3, a3, filename="out.mp4").compile()
+    assert (
+        snapshot(extension_class=JSONSnapshotExtension)
+        == output(v3, a3, filename="out.mp4").compile()
+    )
 
 
 def test_mono_to_stereo_with_offsets_and_video(snapshot: SnapshotAssertion) -> None:
@@ -109,7 +123,9 @@ def test_mono_to_stereo_with_offsets_and_video(snapshot: SnapshotAssertion) -> N
     input_video = input("input-video.mp4")
     assert snapshot(extension_class=JSONSnapshotExtension) == (
         join(audio_left, audio_right, inputs=2, channel_layout="stereo")
-        .output(input_video.video, filename="output-video.mp4", shortest=True, vcodec="copy")
+        .output(
+            input_video.video, filename="output-video.mp4", shortest=True, vcodec="copy"
+        )
         .overwrite_output()
         .compile()
     )
@@ -162,7 +178,9 @@ def test_compile_merge_outputs_with_filter_complex(snapshot: SnapshotAssertion)
     output1 = output(splitted.video(0), filename="output1.mp4")
     output2 = output(splitted.video(1), filename="output2.mp4")
 
-    assert snapshot(extension_class=JSONSnapshotExtension) == (merge_outputs(output1, output2).compile())
+    assert snapshot(extension_class=JSONSnapshotExtension) == (
+        merge_outputs(output1, output2).compile()
+    )
 
 
 def test_concat_dumuxer(snapshot: SnapshotAssertion) -> None:
@@ -175,7 +193,9 @@ def test_concat_dumuxer(snapshot: SnapshotAssertion) -> None:
         },
     )
 
-    assert snapshot(extension_class=JSONSnapshotExtension) == (stream.output(filename="output.mp4").compile())
+    assert snapshot(extension_class=JSONSnapshotExtension) == (
+        stream.output(filename="output.mp4").compile()
+    )
 
 
 def test_customize_vfilter(snapshot: SnapshotAssertion) -> None:
@@ -191,4 +211,7 @@ def test_customize_vfilter(snapshot: SnapshotAssertion) -> None:
         input_typings=(StreamType.video, StreamType.video),
     )
 
-    assert snapshot(extension_class=JSONSnapshotExtension) == gltransition.output(filename="output.mp4").compile()
+    assert (
+        snapshot(extension_class=JSONSnapshotExtension)
+        == gltransition.output(filename="output.mp4").compile()
+    )
diff --git a/src/ffmpeg/utils/run.py b/src/ffmpeg/utils/run.py
index 63f66e05..68f734d9 100644
--- a/src/ffmpeg/utils/run.py
+++ b/src/ffmpeg/utils/run.py
@@ -19,7 +19,7 @@ def command_line(args: list[str]) -> str:
 
 # Filter_Node_Option_Type
 def ignore_default(
-    kwargs: dict[str, str | int | float | bool | Default]
+    kwargs: dict[str, str | int | float | bool | Default],
 ) -> tuple[tuple[str, str | int | float | bool | LazyValue], ...]:
     """
     Convert the values of the dictionary to strings.
diff --git a/src/ffmpeg/utils/tests/test_escaping.py b/src/ffmpeg/utils/tests/test_escaping.py
index afafe7e5..71e635cd 100644
--- a/src/ffmpeg/utils/tests/test_escaping.py
+++ b/src/ffmpeg/utils/tests/test_escaping.py
@@ -8,7 +8,11 @@
 
 
 @pytest.mark.parametrize(
-    "text", ["this is a 'string': may contain one, or more, special characters", "this is a string[0]"]
+    "text",
+    [
+        "this is a 'string': may contain one, or more, special characters",
+        "this is a string[0]",
+    ],
 )
 def test_escaping(snapshot: SnapshotAssertion, text: str) -> None:
     assert snapshot == escape(text, "\\'[],;")
@@ -24,5 +28,9 @@ def test_escaping(snapshot: SnapshotAssertion, text: str) -> None:
         {"true": True, "false": False},
     ],
 )
-def test_convert_kwargs_to_cmd_line_args(snapshot: SnapshotAssertion, options: dict[str, Any]) -> None:
-    assert snapshot(extension_class=JSONSnapshotExtension) == convert_kwargs_to_cmd_line_args(options)
+def test_convert_kwargs_to_cmd_line_args(
+    snapshot: SnapshotAssertion, options: dict[str, Any]
+) -> None:
+    assert snapshot(
+        extension_class=JSONSnapshotExtension
+    ) == convert_kwargs_to_cmd_line_args(options)
diff --git a/src/ffmpeg/utils/view.py b/src/ffmpeg/utils/view.py
index aab75227..5db15610 100644
--- a/src/ffmpeg/utils/view.py
+++ b/src/ffmpeg/utils/view.py
@@ -35,7 +35,8 @@ def view(node: Node, format: Literal["png", "svg", "dot"]) -> str:
         import graphviz  # type: ignore
     except ImportError:
         raise ImportError(
-            "failed to import graphviz; please make sure graphviz is installed (e.g. " "`pip install graphviz`)"
+            "failed to import graphviz; please make sure graphviz is installed (e.g. "
+            "`pip install graphviz`)"
         )
 
     graph = graphviz.Digraph(format=format)
@@ -59,6 +60,10 @@ def view(node: Node, format: Literal["png", "svg", "dot"]) -> str:
 
     for node in context.all_nodes:
         for idx, stream in enumerate(node.inputs):
-            graph.edge(stream.node.hex, node.hex, label=f"{'*' if stream.index is None else stream.index} => {idx}")
+            graph.edge(
+                stream.node.hex,
+                node.hex,
+                label=f"{'*' if stream.index is None else stream.index} => {idx}",
+            )
 
     return graph.render(engine="dot")
diff --git a/src/scripts/parse_help/parse_filter.py b/src/scripts/parse_help/parse_filter.py
index 21d93f3e..7f745cc0 100644
--- a/src/scripts/parse_help/parse_filter.py
+++ b/src/scripts/parse_help/parse_filter.py
@@ -25,7 +25,9 @@ def extract_filter_help_text(filter_name: str) -> str:
     """
 
     result = subprocess.run(
-        ["ffmpeg", "-h", f"filter={filter_name}", "-hide_banner"], stdout=subprocess.PIPE, text=True
+        ["ffmpeg", "-h", f"filter={filter_name}", "-hide_banner"],
+        stdout=subprocess.PIPE,
+        text=True,
     )
     return result.stdout
 
@@ -107,9 +109,11 @@ def _parse_default(default: str | None, type: str) -> int | float | bool | str |
         default = default.strip('"')
 
     try:
-        match (type):
+        match type:
             case "boolean":
-                assert default in ("true", "false"), f"Invalid default value for boolean: {default}"
+                assert default in ("true", "false"), (
+                    f"Invalid default value for boolean: {default}"
+                )
                 return default == "true"
             case "duration":
                 assert default is not None
@@ -208,18 +212,26 @@ def _parse_choices(lines: list[str]) -> list[FFMpegFilterOptionChoice]:
     """
     output: list[FFMpegFilterOptionChoice] = []
     for line in lines:
-        match: list[tuple[str, str, str, str]] = re.findall(r"([\w]+)\s+([\s\-\w]+)\s+([\w\.]{11})(\s+.*)?", line)
+        match: list[tuple[str, str, str, str]] = re.findall(
+            r"([\w]+)\s+([\s\-\w]+)\s+([\w\.]{11})(\s+.*)?", line
+        )
         assert match
         name, value, flags, help = match[0]
         if not value.strip():
             value = name
 
-        output.append(FFMpegFilterOptionChoice(name=name, help=help.strip(), value=value.strip(), flags=flags.strip()))
+        output.append(
+            FFMpegFilterOptionChoice(
+                name=name, help=help.strip(), value=value.strip(), flags=flags.strip()
+            )
+        )
 
     return output
 
 
-def _parse_options(lines: list[str], tree: dict[str, list[str]]) -> list[FFMpegFilterOption]:
+def _parse_options(
+    lines: list[str], tree: dict[str, list[str]]
+) -> list[FFMpegFilterOption]:
     """
     Parse the options for a filter.
 
@@ -322,7 +334,10 @@ def extract_avfilter_info_from_help(filter_name: str) -> FFMpegFilter:
     else:
         output_types = None
 
-    is_suppoert_timeline = tree[""][-1] == "This filter has support for timeline through the 'enable' option."
+    is_suppoert_timeline = (
+        tree[""][-1]
+        == "This filter has support for timeline through the 'enable' option."
+    )
     is_support_framesync = "framesync AVOptions:" in tree
 
     options = []
@@ -332,7 +347,11 @@ def extract_avfilter_info_from_help(filter_name: str) -> FFMpegFilter:
 
     if is_suppoert_timeline:
         options.append(
-            FFMpegFilterOption(name="enable", description="timeline editing", type=FFMpegFilterOptionType.string)
+            FFMpegFilterOption(
+                name="enable",
+                description="timeline editing",
+                type=FFMpegFilterOptionType.string,
+            )
         )
 
     return FFMpegFilter(