[Bug]: `write_recording()` fails with `NWBZarrIO` backend
### What happened?

When trying to write a `recording` object using the `NWBZarrIO` backend from `hdmf-zarr`, I get the following error related to the `len` of the `SpikeInterfaceRecordingDataChunkIterator`.

The same `nwbfile` does not produce any error when writing to HDF5.

@oruebel @rly I think this might be due to the way `neuroconv` handles the data iteration, but tagging you here in case it's a Zarr backend issue.


### Steps to Reproduce

```python
from pynwb import NWBFile
from hdmf_zarr.nwb import NWBZarrIO
from datetime import datetime
from neuroconv.tools.spikeinterface import write_recording

import spikeinterface.full as si


# create toy objects
rec, sort = si.toy_example()

# instantiate nwbfile
nwb_metadata = dict(session_description="toy_example", identifier="tpy", session_start_time=datetime.now())
nwbfile = NWBFile(**nwb_metadata)

# write recording
write_recording(rec, nwbfile=nwbfile)

# write to Zarr
with NWBZarrIO('test_recording_zarr.nwb', "w") as io:
    io.write(nwbfile)
```


### Traceback

```python
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/hdmf_zarr/backend.py:904, in ZarrIO.__list_fill__(self, parent, name, data, options)
    903 try:
--> 904     dset[:] = data  # If data is an h5py.Dataset then this will copy the data
    905 # For compound data types containing strings Zarr sometimes does not like wirting multiple values
    906 # try to write them one-at-a-time instead then

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/zarr/core.py:1373, in Array.__setitem__(self, selection, value)
   1372 else:
-> 1373     self.set_basic_selection(pure_selection, value, fields=fields)

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/zarr/core.py:1468, in Array.set_basic_selection(self, selection, value, fields)
   1467 else:
-> 1468     return self._set_basic_selection_nd(selection, value, fields=fields)

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/zarr/core.py:1772, in Array._set_basic_selection_nd(self, selection, value, fields)
   1770 indexer = BasicIndexer(selection, self)
-> 1772 self._set_selection(indexer, value, fields=fields)

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/zarr/core.py:1800, in Array._set_selection(self, indexer, value, fields)
   1799         value = np.asanyarray(value, like=self._meta_array)
-> 1800     check_array_shape('value', value, sel_shape)
   1802 # iterate over chunks in range

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/zarr/util.py:547, in check_array_shape(param, array, shape)
    546 if array.shape != shape:
--> 547     raise ValueError('parameter {!r}: expected array with shape {!r}, got {!r}'
    548                      .format(param, shape, array.shape))

ValueError: parameter 'value': expected array with shape (300000, 4), got ()

During handling of the above exception, another exception occurred:

TypeError                                 Traceback (most recent call last)
Cell In [22], line 2
      1 with NWBZarrIO('nwb-test-files/test_recording_zarr.nwb', "w") as io:
----> 2     io.write(nwbfile)

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/hdmf/utils.py:645, in docval.<locals>.dec.<locals>.func_call(*args, **kwargs)
    643 def func_call(*args, **kwargs):
    644     pargs = _check_args(args, kwargs)
--> 645     return func(args[0], **pargs)

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/hdmf_zarr/backend.py:151, in ZarrIO.write(self, **kwargs)
    149 """Overwrite the write method to add support for caching the specification"""
    150 cache_spec = popargs('cache_spec', kwargs)
--> 151 super(ZarrIO, self).write(**kwargs)
    152 if cache_spec:
    153     self.__cache_spec()

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/hdmf/utils.py:645, in docval.<locals>.dec.<locals>.func_call(*args, **kwargs)
    643 def func_call(*args, **kwargs):
    644     pargs = _check_args(args, kwargs)
--> 645     return func(args[0], **pargs)

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/hdmf/backends/io.py:51, in HDMFIO.write(self, **kwargs)
     49 container = popargs('container', kwargs)
     50 f_builder = self.__manager.build(container, source=self.__source, root=True)
---> 51 self.write_builder(f_builder, **kwargs)

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/hdmf/utils.py:645, in docval.<locals>.dec.<locals>.func_call(*args, **kwargs)
    643 def func_call(*args, **kwargs):
    644     pargs = _check_args(args, kwargs)
--> 645     return func(args[0], **pargs)

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/hdmf_zarr/backend.py:248, in ZarrIO.write_builder(self, **kwargs)
    246 f_builder, link_data, exhaust_dci = getargs('builder', 'link_data', 'exhaust_dci', kwargs)
    247 for name, gbldr in f_builder.groups.items():
--> 248     self.write_group(parent=self.__file,
    249                      builder=gbldr,
    250                      link_data=link_data,
    251                      exhaust_dci=exhaust_dci)
    252 for name, dbldr in f_builder.datasets.items():
    253     self.write_dataset(parent=self.__file,
    254                        builder=dbldr,
    255                        link_data=link_data,
    256                        exhaust_dci=exhaust_dci)

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/hdmf/utils.py:645, in docval.<locals>.dec.<locals>.func_call(*args, **kwargs)
    643 def func_call(*args, **kwargs):
    644     pargs = _check_args(args, kwargs)
--> 645     return func(args[0], **pargs)

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/hdmf_zarr/backend.py:283, in ZarrIO.write_group(self, **kwargs)
    281 if subgroups:
    282     for subgroup_name, sub_builder in subgroups.items():
--> 283         self.write_group(parent=group,
    284                          builder=sub_builder,
    285                          link_data=link_data,
    286                          exhaust_dci=exhaust_dci)
    288 datasets = builder.datasets
    289 if datasets:

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/hdmf/utils.py:645, in docval.<locals>.dec.<locals>.func_call(*args, **kwargs)
    643 def func_call(*args, **kwargs):
    644     pargs = _check_args(args, kwargs)
--> 645     return func(args[0], **pargs)

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/hdmf_zarr/backend.py:291, in ZarrIO.write_group(self, **kwargs)
    289 if datasets:
    290     for dset_name, sub_builder in datasets.items():
--> 291         self.write_dataset(parent=group,
    292                            builder=sub_builder,
    293                            link_data=link_data,
    294                            exhaust_dci=exhaust_dci)
    296 # write all links (haven implemented)
    297 links = builder.links

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/hdmf/utils.py:645, in docval.<locals>.dec.<locals>.func_call(*args, **kwargs)
    643 def func_call(*args, **kwargs):
    644     pargs = _check_args(args, kwargs)
--> 645     return func(args[0], **pargs)

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/hdmf_zarr/backend.py:736, in ZarrIO.write_dataset(self, **kwargs)
    734     self.__dci_queue.append(dataset=dset, data=data)
    735 elif hasattr(data, '__len__'):
--> 736     dset = self.__list_fill__(parent, name, data, options)
    737 else:
    738     dset = self.__scalar_fill__(parent, name, data, options)

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/hdmf_zarr/backend.py:908, in ZarrIO.__list_fill__(self, parent, name, data, options)
    905     # For compound data types containing strings Zarr sometimes does not like wirting multiple values
    906     # try to write them one-at-a-time instead then
    907     except ValueError:
--> 908         for i in range(len(data)):
    909             dset[i] = data[i]
    910 return dset

File ~/anaconda3/envs/nwb/lib/python3.9/site-packages/hdmf/data_utils.py:1028, in DataIO.__len__(self)
   1026 if not self.valid:
   1027     raise InvalidDataIOError("Cannot get length of data. Data is not valid.")
-> 1028 return len(self.data)

TypeError: object of type 'SpikeInterfaceRecordingDataChunkIterator' has no len()
```


### Operating System

Linux

### Python Executable

Python

### Python Version

3.9

### Package Versions

_No response_

### Code of Conduct

- [X] I agree to follow this project's [Code of Conduct](https://github.com/catalystneuro/neuroconv/blob/main/.github/CODE_OF_CONDUCT.rst)
- [X] Have you ensured this bug was not already [reported](https://github.com/catalystneuro/neuroconv/issues)?
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4ca0c23e..22e855d9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,13 +1,21 @@
 # Upcoming
 
+### Official deprecation
+* Removed the `buffer_size` argument from `neuroconv.tools.roiextractors.write_imaging`. [PR #???](https://github.com/catalystneuro/neuroconv/pull/???)
+
 ### Fixes
 * Temporarily hotfixed the `tensorflow` dependency after the release of `deeplabcut==2.3.0`. [PR #268](https://github.com/catalystneuro/neuroconv/pull/268)
 
-
-
 ### Pending deprecation
 
 * Added `DeprecationWarning`s for `spikeextractors` objects in `neuroconv.tools.spikeinterface`. [PR #266](https://github.com/catalystneuro/neuroconv/pull/266)
+*  Added `DeprecationWarning`s for `iterator_type`+`iterator_opts` and `compression`+`compression_opts` references across all of NeuroConv. The new standard is to use `iterator_options` with keys `method` and `method_options` as well as `compression_options` with keys `method` and `method_options`.  [PR #???](https://github.com/catalystneuro/neuroconv/pull/???)
+
+
+### Features
+* Added `compression_options` control for Imaging tools and interfaces. [PR #???](https://github.com/catalystneuro/neuroconv/pull/???)
+
+
 
 # v0.2.3
 
diff --git a/src/neuroconv/basedatainterface.py b/src/neuroconv/basedatainterface.py
index 9761ff55..1a983a0c 100644
--- a/src/neuroconv/basedatainterface.py
+++ b/src/neuroconv/basedatainterface.py
@@ -2,6 +2,7 @@
 from abc import abstractmethod, ABC
 import uuid
 from typing import Optional
+from warnings import warn
 
 from pynwb import NWBFile
 
diff --git a/src/neuroconv/datainterfaces/ecephys/baselfpextractorinterface.py b/src/neuroconv/datainterfaces/ecephys/baselfpextractorinterface.py
index 2c3f9ce7..8a0f95c1 100644
--- a/src/neuroconv/datainterfaces/ecephys/baselfpextractorinterface.py
+++ b/src/neuroconv/datainterfaces/ecephys/baselfpextractorinterface.py
@@ -3,6 +3,7 @@ from typing import Optional, Union
 from pathlib import Path
 from pynwb import NWBFile
 from pynwb.ecephys import ElectricalSeries
+from warnings import warn
 
 from .baserecordingextractorinterface import BaseRecordingExtractorInterface
 from ...utils import get_schema_from_hdmf_class, OptionalFilePathType
@@ -36,13 +37,53 @@ class BaseLFPExtractorInterface(BaseRecordingExtractorInterface):
         stub_test: bool = False,
         starting_time: Optional[float] = None,
         use_times: bool = False,  # To-do to remove, deprecation
-        compression: Optional[str] = None,
-        compression_opts: Optional[int] = None,
-        iterator_type: str = "v2",
-        iterator_opts: Optional[dict] = None,
+        compression_options: Optional[dict] = None,
+        iterator_options: Optional[dict] = None,
+        compression: Optional[str] = None,  # TODO: remove
+        compression_opts: Optional[int] = None,  # TODO: remove
+        iterator_type: Optional[str] = None,  # TODO: remove
+        iterator_opts: Optional[dict] = None,  # TODO: remove
     ):
+        if any([x is not None for x in [compression, compression_opts]]):  # pragma: no cover
+            assert compression_options is None, (
+                "You may not specify both 'compression' and 'compression_opts' with 'compression_options'! "
+                "Please use only 'compression_options'."
+            )
+            warn(
+                message=(
+                    "The options 'compression' and 'compression_opts' will soon be deprecated! "
+                    "Please use 'compression_options' instead."
+                ),
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+            compression_options = dict(
+                method=compression if isinstance(compression, str) else "gzip",
+                method_options=compression_opts,
+            )
+        if any([x is not None for x in [iterator_type, iterator_opts]]):  # pragma: no cover
+            assert iterator_options is None, (
+                "You may not specify both 'iterator_type' and 'iterator_opts' with 'iterator_options'! "
+                "Please use only 'iterator_options'."
+            )
+            warn(
+                message=(
+                    "The options 'iterator_type' and 'iterator_opts' will soon be deprecated! "
+                    "Please use 'iterator_options' instead."
+                ),
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+            iterator_options = dict(
+                method=iterator_type or "v2",
+                method_options=iterator_opts or dict(),
+            )
+
         from ...tools.spikeinterface import write_recording
 
+        compression_options = compression_options or dict(method="gzip")
+        iterator_options = iterator_options or dict(method="v2")
+
         if stub_test or self.subset_channels is not None:
             recording = self.subset_recording(stub_test=stub_test)
         else:
@@ -58,8 +99,6 @@ class BaseLFPExtractorInterface(BaseRecordingExtractorInterface):
             use_times=use_times,
             write_as="lfp",
             es_key="ElectricalSeriesLFP",
-            compression=compression,
-            compression_opts=compression_opts,
-            iterator_type=iterator_type,
-            iterator_opts=iterator_opts,
+            compression_options=compression_options,
+            iterator_options=iterator_options,
         )
diff --git a/src/neuroconv/datainterfaces/ecephys/baserecordingextractorinterface.py b/src/neuroconv/datainterfaces/ecephys/baserecordingextractorinterface.py
index bb7a3745..6853a5d0 100644
--- a/src/neuroconv/datainterfaces/ecephys/baserecordingextractorinterface.py
+++ b/src/neuroconv/datainterfaces/ecephys/baserecordingextractorinterface.py
@@ -1,5 +1,6 @@
 """Authors: Cody Baker and Ben Dichter."""
 from typing import Optional
+from warnings import warn
 
 from pynwb import NWBFile
 from pynwb.device import Device
@@ -118,10 +119,12 @@ class BaseRecordingExtractorInterface(BaseExtractorInterface):
         write_as: Optional[str] = None,
         write_electrical_series: bool = True,
         es_key: str = None,
-        compression: Optional[str] = None,
-        compression_opts: Optional[int] = None,
-        iterator_type: str = "v2",
-        iterator_opts: Optional[dict] = None,
+        compression_options: Optional[dict] = None,
+        iterator_options: Optional[dict] = None,
+        compression: Optional[str] = None,  # TODO: remove
+        compression_opts: Optional[int] = None,  # TODO: remove
+        iterator_type: Optional[str] = None,  # TODO: remove
+        iterator_opts: Optional[dict] = None,  # TODO: remove
     ):
         """
         Primary function for converting raw (unprocessed) RecordingExtractor data to the NWB standard.
@@ -152,6 +155,39 @@ class BaseRecordingExtractorInterface(BaseExtractorInterface):
             and electrodes are written to NWB.
         es_key : str, optional
             Key in metadata dictionary containing metadata info for the specific electrical series
+        compression_options: dictionary, optional
+            Type of compression to use. Should follow the structure
+
+            dict(
+                method="name_of_compression_method",
+                method_options=dict(...),
+            )
+
+            Valid 'method' values are any accepted by the `:py:class:~pynwb.H5DataIO`, such as "gzip" and "lzf".
+
+            Not all methods have additional 'method_options' - in those cases, do not need to specify that field.
+
+            The default method is "gzip" with 'extra_options=dict(level=4)'.
+            Set 'method' to `None` to disable all compression.
+        iterator_options: dictionary, optional
+            The type of DataChunkIterator to use. Should follow the structure
+
+            dict(
+                method="v1_or_v2",
+                method_options=dict(...),
+            )
+
+            'v1' is the original DataChunkIterator of the hdmf data_utils.
+            'v2' is the locally developed RecordingExtractorDataChunkIterator, which offers full control over chunking.
+            The default method is "v2".
+
+            Some 'method_options' for the "v2" iterator are
+                buffer_gb : float, optional
+                    Automatically calculates suitable buffer shape. Recommended to be as much free RAM as available.
+                    The default is 1 GB.
+                chunk_mb : float, optional
+                    Automatically calculates suitable chunk shape. Should be at or below 1 MB.
+                    The default is 1 MB.
         compression : {'gzip', 'lzf', None}
             Type of compression to use.
             Set to None to disable all compression.
@@ -170,8 +206,46 @@ class BaseRecordingExtractorInterface(BaseExtractorInterface):
                     Should be below 1 MB. Automatically calculates suitable chunk shape.
             If manual specification of buffer_shape and chunk_shape are desired, these may be specified as well.
         """
+        if any([x is not None for x in [compression, compression_opts]]):  # pragma: no cover
+            assert compression_options is None, (
+                "You may not specify both 'compression' and 'compression_opts' with 'compression_options'! "
+                "Please use only 'compression_options'."
+            )
+            warn(
+                message=(
+                    "The options 'compression' and 'compression_opts' will soon be deprecated! "
+                    "Please use 'compression_options' instead."
+                ),
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+            compression_options = dict(
+                method=compression if isinstance(compression, str) else "gzip",
+                method_options=compression_opts,
+            )
+        if any([x is not None for x in [iterator_type, iterator_opts]]):  # pragma: no cover
+            assert iterator_options is None, (
+                "You may not specify both 'iterator_type' and 'iterator_opts' with 'iterator_options'! "
+                "Please use only 'iterator_options'."
+            )
+            warn(
+                message=(
+                    "The options 'iterator_type' and 'iterator_opts' will soon be deprecated! "
+                    "Please use 'iterator_options' instead."
+                ),
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+            iterator_options = dict(
+                method=iterator_type or "v2",
+                method_options=iterator_opts or dict(),
+            )
+
         from ...tools.spikeinterface import write_recording
 
+        compression_options = compression_options or dict(method="gzip")
+        iterator_options = iterator_options or dict(method="v2")
+
         if stub_test or self.subset_channels is not None:
             recording = self.subset_recording(stub_test=stub_test)
         else:
@@ -189,8 +263,6 @@ class BaseRecordingExtractorInterface(BaseExtractorInterface):
             write_as=write_as,
             write_electrical_series=write_electrical_series,
             es_key=es_key or self.es_key,
-            compression=compression,
-            compression_opts=compression_opts,
-            iterator_type=iterator_type,
-            iterator_opts=iterator_opts,
+            compression_options=compression_options,
+            iterator_options=iterator_options,
         )
diff --git a/src/neuroconv/datainterfaces/ophys/baseimagingextractorinterface.py b/src/neuroconv/datainterfaces/ophys/baseimagingextractorinterface.py
index 9e344f62..4c710b57 100644
--- a/src/neuroconv/datainterfaces/ophys/baseimagingextractorinterface.py
+++ b/src/neuroconv/datainterfaces/ophys/baseimagingextractorinterface.py
@@ -80,6 +80,8 @@ class BaseImagingExtractorInterface(BaseExtractorInterface):
         overwrite: bool = False,
         stub_test: bool = False,
         stub_frames: int = 100,
+        compression_options: Optional[dict] = None,
+        iterator_options: Optional[dict] = None,
     ):
         from ...tools.roiextractors import write_imaging
 
@@ -96,4 +98,6 @@ class BaseImagingExtractorInterface(BaseExtractorInterface):
             metadata=metadata,
             overwrite=overwrite,
             verbose=self.verbose,
+            compression_options=compression_options,
+            iterator_options=iterator_options,
         )
diff --git a/src/neuroconv/datainterfaces/ophys/basesegmentationextractorinterface.py b/src/neuroconv/datainterfaces/ophys/basesegmentationextractorinterface.py
index 535d26ca..303c9d0c 100644
--- a/src/neuroconv/datainterfaces/ophys/basesegmentationextractorinterface.py
+++ b/src/neuroconv/datainterfaces/ophys/basesegmentationextractorinterface.py
@@ -69,8 +69,8 @@ class BaseSegmentationExtractorInterface(BaseExtractorInterface):
         include_roi_centroids: bool = True,
         include_roi_acceptance: bool = True,
         mask_type: Optional[str] = "image",  # Optional[Literal["image", "pixel", "voxel"]]
-        iterator_options: Optional[dict] = None,
         compression_options: Optional[dict] = None,
+        iterator_options: Optional[dict] = None,
     ):
         """
 
@@ -130,6 +130,6 @@ class BaseSegmentationExtractorInterface(BaseExtractorInterface):
             include_roi_centroids=include_roi_centroids,
             include_roi_acceptance=include_roi_acceptance,
             mask_type=mask_type,
-            iterator_options=iterator_options,
             compression_options=compression_options,
+            iterator_options=iterator_options,
         )
diff --git a/src/neuroconv/tools/roiextractors/roiextractors.py b/src/neuroconv/tools/roiextractors/roiextractors.py
index a5f2343e..4c9f50dd 100644
--- a/src/neuroconv/tools/roiextractors/roiextractors.py
+++ b/src/neuroconv/tools/roiextractors/roiextractors.py
@@ -267,25 +267,37 @@ def add_two_photon_series(
     nwbfile: NWBFile,
     metadata: dict,
     two_photon_series_index: int = 0,
-    iterator_type: Optional[str] = "v2",
+    compression_options: Optional[dict] = None,
     iterator_options: Optional[dict] = None,
+    iterator_type: Optional[str] = None,  # TODO: to be removed
     use_times=False,  # TODO: to be removed
-    buffer_size: Optional[int] = None,  # TODO: to be removed
 ) -> NWBFile:
     """
     Auxiliary static method for nwbextractor.
 
     Adds two photon series from imaging object as TwoPhotonSeries to nwbfile object.
     """
-    if use_times:
-        warn("Keyword argument 'use_times' is deprecated and will be removed on or after August 1st, 2022.")
-    if buffer_size:
+    if iterator_type is not None:  # pragma: no cover
         warn(
-            "Keyword argument 'buffer_size' is deprecated and will be removed on or after September 1st, 2022."
-            "Specify as a key in the new 'iterator_options' dictionary instead."
+            message=(
+                "The options 'iterator_type' will soon be deprecated! "
+                "Please use 'iterator_options' with keyword 'method' instead."
+            ),
+            category=DeprecationWarning,
+            stacklevel=2,
         )
 
-    iterator_options = iterator_options or dict()
+        old_iterator_options = iterator_options
+        iterator_options = dict(method=iterator_type)
+        if old_iterator_options is not None:  # Old usage together with `iterator_type`
+            iterator_options.update(method_options=old_iterator_options)
+        elif iterator_options["method"] == "v1":
+            iterator_options.update(method_options=dict(buffer_size=10))  # To maintain default behavior
+    compression_options = compression_options or dict(method="gzip")
+    iterator_options = iterator_options or dict(method="v2")
+
+    if use_times:
+        warn("Keyword argument 'use_times' is deprecated and will be removed on or after August 1st, 2022.")
 
     metadata_copy = deepcopy(metadata)
     metadata_copy = dict_deep_update(get_nwb_imaging_metadata(imaging), metadata_copy, append_list=False)
@@ -308,10 +320,13 @@ def add_two_photon_series(
     two_p_series_kwargs = two_photon_series_metadata
     frames_to_iterator = _imaging_frames_to_hdmf_iterator(
         imaging=imaging,
-        iterator_type=iterator_type,
         iterator_options=iterator_options,
     )
-    data = H5DataIO(data=frames_to_iterator, compression=True)
+    data = H5DataIO(
+        data=frames_to_iterator,
+        compression=compression_options["method"],
+        compression_opts=compression_options.get("method_options"),
+    )
     two_p_series_kwargs.update(data=data)
 
     # Add dimension
@@ -324,7 +339,14 @@ def add_two_photon_series(
         if estimated_rate:
             two_p_series_kwargs.update(starting_time=timestamps[0], rate=estimated_rate)
         else:
-            two_p_series_kwargs.update(timestamps=H5DataIO(data=timestamps, compression="gzip"), rate=None)
+            two_p_series_kwargs.update(
+                timestamps=H5DataIO(
+                    data=timestamps,
+                    compression=compression_options["method"],
+                    compression_opts=compression_options.get("method_options"),
+                ),
+                rate=None,
+            )
     else:
         rate = float(imaging.get_sampling_frequency())
         two_p_series_kwargs.update(starting_time=0.0, rate=rate)
@@ -366,8 +388,8 @@ def check_if_imaging_fits_into_memory(imaging: ImagingExtractor) -> None:
 
 def _imaging_frames_to_hdmf_iterator(
     imaging: ImagingExtractor,
-    iterator_type: Optional[str] = "v2",
     iterator_options: Optional[dict] = None,
+    iterator_type: Optional[str] = None,  # TODO: to be removed
 ):
     """
     Private auxiliary method to wrap frames from an ImagingExtractor into a DataChunkIterator.
@@ -393,24 +415,45 @@ def _imaging_frames_to_hdmf_iterator(
     DataChunkIterator
         The frames of the imaging extractor wrapped in an iterator object.
     """
+    if iterator_type is not None:  # pragma: no cover
+        warn(
+            message=(
+                "The options 'iterator_type' will soon be deprecated! "
+                "Please use 'iterator_options' with keyword 'method' instead."
+            ),
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+
+        old_iterator_options = iterator_options
+        iterator_options = dict(method=iterator_type)
+        if old_iterator_options is not None:  # Old usage together with `iterator_type`
+            iterator_options.update(method_options=old_iterator_options)
+    iterator_options = iterator_options or dict(method="v2")
+
+    supported_iterator_types = ["v1", "v2", None]
+    if iterator_options["method"] not in supported_iterator_types:
+        raise ValueError(
+            "The `method` of `iterator_options` should be either 'v1', 'v2' (recommended) or None! "
+            f"Received '{iterator_options['method']}'."
+        )
 
     def data_generator(imaging):
         for i in range(imaging.get_num_frames()):
             yield imaging.get_frames(frame_idxs=[i]).squeeze().T
 
-    assert iterator_type in ["v1", "v2", None], "'iterator_type' must be either 'v1', 'v2' (recommended), or None."
-    iterator_options = dict() if iterator_options is None else iterator_options
-
-    if iterator_type is None:
+    if iterator_options["method"] is None:
         check_if_imaging_fits_into_memory(imaging=imaging)
         return imaging.get_video().transpose((0, 2, 1))
 
-    if iterator_type == "v1":
-        if "buffer_size" not in iterator_options:
-            iterator_options.update(buffer_size=10)
-        return DataChunkIterator(data=data_generator(imaging), **iterator_options)
+    if iterator_options["method"] == "v1":
+        if "buffer_size" not in iterator_options.get("method_options", dict()):
+            iterator_options.get("method_options", dict()).update(buffer_size=10)
+        return DataChunkIterator(data=data_generator(imaging), **iterator_options.get("method_options", dict()))
 
-    return ImagingExtractorDataChunkIterator(imaging_extractor=imaging, **iterator_options)
+    return ImagingExtractorDataChunkIterator(
+        imaging_extractor=imaging, **iterator_options.get("method_options", dict())
+    )
 
 
 def write_imaging(
@@ -420,10 +463,10 @@ def write_imaging(
     metadata: Optional[dict] = None,
     overwrite: bool = False,
     verbose: bool = True,
-    iterator_type: Optional[str] = "v2",
+    compression_options: Optional[dict] = None,
     iterator_options: Optional[dict] = None,
+    iterator_type: Optional[str] = None,  # TODO: remove
     use_times=False,  # TODO: to be removed
-    buffer_size: Optional[int] = None,  # TODO: to be removed
 ):
     """
     Primary method for writing an ImagingExtractor object to an NWBFile.
@@ -464,20 +507,31 @@ def write_imaging(
         https://hdmf.readthedocs.io/en/stable/hdmf.data_utils.html#hdmf.data_utils.GenericDataChunkIterator
         for the full list of options.
     """
+    if iterator_type is not None:  # pragma: no cover
+        warn(
+            message=(
+                "The options 'iterator_type' will soon be deprecated! "
+                "Please use 'iterator_options' with keyword 'method' instead."
+            ),
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+
+        old_iterator_options = iterator_options
+        iterator_options = dict(method=iterator_type)
+        if old_iterator_options is not None:  # Old usage together with `iterator_type`
+            iterator_options.update(method_options=old_iterator_options)
+    compression_options = compression_options or dict(method="gzip")
+    iterator_options = iterator_options or dict(method="v2")
+
     assert (
         nwbfile_path is None or nwbfile is None
     ), "Either pass a nwbfile_path location, or nwbfile object, but not both!"
     if nwbfile is not None:
         assert isinstance(nwbfile, NWBFile), "'nwbfile' should be of type pynwb.NWBFile"
 
-    iterator_options = iterator_options or dict()
     if use_times:
         warn("Keyword argument 'use_times' is deprecated and will be removed on or after August 1st, 2022.")
-    if buffer_size:
-        warn(
-            "Keyword argument 'buffer_size' is deprecated and will be removed on or after September 1st, 2022."
-            "Specify as a key in the new 'iterator_options' dictionary instead."
-        )
 
     if metadata is None:
         metadata = dict()
@@ -492,7 +546,7 @@ def write_imaging(
             imaging=imaging,
             nwbfile=nwbfile_out,
             metadata=metadata,
-            iterator_type=iterator_type,
+            compression_options=compression_options,
             iterator_options=iterator_options,
         )
     return nwbfile_out
@@ -541,8 +595,8 @@ def add_plane_segmentation(
     include_roi_centroids: bool = True,
     include_roi_acceptance: bool = True,
     mask_type: Optional[str] = "image",  # Optional[Literal["image", "pixel"]]
-    iterator_options: Optional[dict] = None,
     compression_options: Optional[dict] = None,
+    iterator_options: Optional[dict] = None,
 ) -> NWBFile:
     """
     Adds the plane segmentation specified by the metadata to the image segmentation.
@@ -593,8 +647,8 @@ def add_plane_segmentation(
         f"or None (to not write any masks)! Received '{mask_type}'."
     )
 
-    iterator_options = iterator_options or dict()
-    compression_options = compression_options or dict(compression="gzip")
+    compression_options = compression_options or dict(method="gzip")
+    iterator_options = iterator_options or dict(method="v2")
 
     # Set the defaults and required infrastructure
     metadata_copy = deepcopy(metadata)
@@ -632,7 +686,11 @@ def add_plane_segmentation(
             plane_segmentation.add_column(
                 name="image_mask",
                 description="Image masks for each ROI.",
-                data=H5DataIO(segmentation_extractor.get_roi_image_masks().T, **compression_options),
+                data=H5DataIO(
+                    segmentation_extractor.get_roi_image_masks().T,
+                    compression=compression_options["method"],
+                    compression_opts=compression_options.get("method_options"),
+                ),
             )
         elif mask_type == "pixel" or mask_type == "voxel":
             pixel_masks = segmentation_extractor.get_roi_pixel_masks()
@@ -668,19 +726,31 @@ def add_plane_segmentation(
             plane_segmentation.add_column(
                 name="ROICentroids",
                 description="The x, y, (z) centroids of each ROI.",
-                data=H5DataIO(roi_locations, **compression_options),
+                data=H5DataIO(
+                    roi_locations,
+                    compression=compression_options["method"],
+                    compression_opts=compression_options.get("method_options"),
+                ),
             )
 
         if include_roi_acceptance:
             plane_segmentation.add_column(
                 name="Accepted",
                 description="1 if ROI was accepted or 0 if rejected as a cell during segmentation operation.",
-                data=H5DataIO(accepted_ids, **compression_options),
+                data=H5DataIO(
+                    accepted_ids,
+                    compression=compression_options["method"],
+                    compression_opts=compression_options.get("method_options"),
+                ),
             )
             plane_segmentation.add_column(
                 name="Rejected",
                 description="1 if ROI was rejected or 0 if accepted as a cell during segmentation operation.",
-                data=H5DataIO(rejected_ids, **compression_options),
+                data=H5DataIO(
+                    rejected_ids,
+                    compression=compression_options["method"],
+                    compression_opts=compression_options.get("method_options"),
+                ),
             )
 
         image_segmentation.add_plane_segmentation(plane_segmentations=[plane_segmentation])
@@ -692,8 +762,8 @@ def add_fluorescence_traces(
     nwbfile: NWBFile,
     metadata: Optional[dict],
     plane_index: int = 0,
-    iterator_options: Optional[dict] = None,
     compression_options: Optional[dict] = None,
+    iterator_options: Optional[dict] = None,
 ) -> NWBFile:
     """
     Adds the fluorescence traces specified by the metadata to the nwb file.
@@ -718,8 +788,8 @@ def add_fluorescence_traces(
     NWBFile
         The nwbfile passed as an input with the fluorescence traces added.
     """
-    iterator_options = iterator_options or dict()
-    compression_options = compression_options or dict(compression="gzip")
+    compression_options = compression_options or dict(method="gzip")
+    iterator_options = iterator_options or dict(method="v2")
 
     # Set the defaults and required infrastructure
     metadata_copy = deepcopy(metadata)
@@ -765,7 +835,14 @@ def add_fluorescence_traces(
         if estimated_rate:
             roi_response_series_kwargs.update(starting_time=timestamps[0], rate=estimated_rate)
         else:
-            roi_response_series_kwargs.update(timestamps=H5DataIO(data=timestamps, compression="gzip"), rate=None)
+            roi_response_series_kwargs.update(
+                timestamps=H5DataIO(
+                    data=timestamps,
+                    compression=compression_options["method"],
+                    compression_opts=compression_options.get("method_options"),
+                ),
+                rate=None,
+            )
     else:
         rate = float(segmentation_extractor.get_sampling_frequency())
         roi_response_series_kwargs.update(starting_time=0.0, rate=rate)
@@ -807,8 +884,21 @@ def add_fluorescence_traces(
             trace_metadata.pop("rate")
 
         # Build the roi response series
+        if iterator_options["method"] is None:
+            roi_response_series_data = trace
+        elif iterator_options["method"] == "v1":
+            raise NotImplementedError("The 'v1' iteration method has not been implemented for segmentation data.")
+        elif iterator_options["method"] == "v2":
+            roi_response_series_data = SliceableDataChunkIterator(
+                trace, **iterator_options.get("method_options", dict())
+            )
+
         roi_response_series_kwargs.update(
-            data=H5DataIO(SliceableDataChunkIterator(trace, **iterator_options), **compression_options),
+            data=H5DataIO(
+                roi_response_series_data,
+                compression=compression_options["method"],
+                compression_opts=compression_options.get("method_options"),
+            ),
             rois=roi_table_region,
             **trace_metadata,
         )
@@ -919,8 +1009,8 @@ def write_segmentation(
     include_roi_centroids: bool = True,
     include_roi_acceptance: bool = True,
     mask_type: Optional[str] = "image",  # Optional[Literal["image", "pixel"]]
-    iterator_options: Optional[dict] = None,
     compression_options: Optional[dict] = None,
+    iterator_options: Optional[dict] = None,
 ):
     """
     Primary method for writing an SegmentationExtractor object to an NWBFile.
@@ -977,8 +1067,8 @@ def write_segmentation(
         nwbfile_path is None or nwbfile is None
     ), "Either pass a nwbfile_path location, or nwbfile object, but not both!"
 
-    iterator_options = iterator_options or dict()
-    compression_options = compression_options or dict(compression="gzip")
+    compression_options = compression_options or dict(method="gzip")
+    iterator_options = iterator_options or dict(method="v2")
 
     # parse metadata correctly considering the MultiSegmentationExtractor function:
     if isinstance(segmentation_extractor, MultiSegmentationExtractor):
@@ -1036,8 +1126,8 @@ def write_segmentation(
                 include_roi_centroids=include_roi_centroids,
                 include_roi_acceptance=include_roi_acceptance,
                 mask_type=mask_type,
-                iterator_options=iterator_options,
                 compression_options=compression_options,
+                iterator_options=iterator_options,
             )
 
             # Add fluorescence traces:
@@ -1045,8 +1135,8 @@ def write_segmentation(
                 segmentation_extractor=segmentation_extractor,
                 nwbfile=nwbfile_out,
                 metadata=metadata,
-                iterator_options=iterator_options,
                 compression_options=compression_options,
+                iterator_options=iterator_options,
             )
 
             # Adding summary images (mean and correlation)
diff --git a/src/neuroconv/tools/spikeinterface/spikeinterface.py b/src/neuroconv/tools/spikeinterface/spikeinterface.py
index 244b73b3..f99798df 100644
--- a/src/neuroconv/tools/spikeinterface/spikeinterface.py
+++ b/src/neuroconv/tools/spikeinterface/spikeinterface.py
@@ -519,8 +519,9 @@ def _recording_traces_to_hdmf_iterator(
     recording: BaseRecording,
     segment_index: int = None,
     return_scaled: bool = False,
-    iterator_type: str = "v2",
-    iterator_opts: dict = None,
+    iterator_options: Optional[dict] = None,
+    iterator_type: str = None,  # TODO: remove
+    iterator_opts: dict = None,  # TODO: remove
 ) -> AbstractDataChunkIterator:
     """Function to wrap traces of spikeinterface recording into an AbstractDataChunkIterator.
 
@@ -552,27 +553,46 @@ def _recording_traces_to_hdmf_iterator(
     ValueError
         If the iterator_type is not 'v1', 'v2' or None.
     """
+    if any([x is not None for x in [iterator_type, iterator_opts]]):  # pragma: no cover
+        assert iterator_options is None, (
+            "You may not specify both 'iterator_type' and 'iterator_opts' with 'iterator_options'! "
+            "Please use only 'iterator_options'."
+        )
+        warn(
+            message=(
+                "The options 'iterator_type' and 'iterator_opts' will soon be deprecated! "
+                "Please use 'iterator_options' instead."
+            ),
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        iterator_options = dict(
+            method=iterator_type or "v2",
+            method_options=iterator_opts or dict(),
+        )
+    iterator_options = iterator_options or dict(method="v2")
 
     supported_iterator_types = ["v1", "v2", None]
-    if iterator_type not in supported_iterator_types:
-        message = f"iterator_type {iterator_type} should be either 'v1', 'v2' (recommended) or None"
-        raise ValueError(message)
-
-    iterator_opts = dict() if iterator_opts is None else iterator_opts
+    if iterator_options["method"] not in supported_iterator_types:
+        raise ValueError(
+            "The `method` of `iterator_options` should be either 'v1', 'v2' (recommended) or None! "
+            f"Received '{iterator_options['method']}'."
+        )
 
-    if iterator_type is None:
+    if iterator_options["method"] is None:
         check_if_recording_traces_fit_into_memory(recording=recording, segment_index=segment_index)
         traces_as_iterator = recording.get_traces(return_scaled=return_scaled, segment_index=segment_index)
-    elif iterator_type == "v2":
+    elif iterator_options["method"] == "v2":
         traces_as_iterator = SpikeInterfaceRecordingDataChunkIterator(
             recording=recording,
             segment_index=segment_index,
             return_scaled=return_scaled,
-            **iterator_opts,
+            **iterator_options.get("method_options", dict()),
         )
-    elif iterator_type == "v1":
+    elif iterator_options["method"] == "v1":
         traces_as_iterator = DataChunkIterator(
-            data=recording.get_traces(return_scaled=return_scaled, segment_index=segment_index), **iterator_opts
+            data=recording.get_traces(return_scaled=return_scaled, segment_index=segment_index),
+            **iterator_options.get("method_options", dict()),
         )
 
     return traces_as_iterator
@@ -588,10 +608,12 @@ def add_electrical_series(
     write_as: str = "raw",
     es_key: str = None,
     write_scaled: bool = False,
-    compression: Optional[str] = "gzip",
-    compression_opts: Optional[int] = None,
-    iterator_type: str = "v2",
-    iterator_opts: Optional[dict] = None,
+    compression_options: Optional[dict] = None,
+    iterator_options: Optional[dict] = None,
+    compression: Optional[str] = None,  # TODO: remove
+    compression_opts: Optional[int] = None,  # TODO: remove
+    iterator_type: Optional[str] = None,  # TODO: remove
+    iterator_opts: Optional[dict] = None,  # TODO: remove
 ):
     """
     Adds traces from recording object as ElectricalSeries to an NWBFile object.
@@ -640,6 +662,44 @@ def add_electrical_series(
     Missing keys in an element of metadata['Ecephys']['ElectrodeGroup'] will be auto-populated with defaults
     whenever possible.
     """
+    if any([x is not None for x in [compression, compression_opts]]):  # pragma: no cover
+        assert compression_options is None, (
+            "You may not specify both 'compression' and 'compression_opts' with 'compression_options'! "
+            "Please use only 'compression_options'."
+        )
+        warn(
+            message=(
+                "The options 'compression' and 'compression_opts' will soon be deprecated! "
+                "Please use 'compression_options' instead."
+            ),
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        compression_options = dict(
+            method=compression if isinstance(compression, str) else "gzip",
+            method_options=compression_opts,
+        )
+    if any([x is not None for x in [iterator_type, iterator_opts]]):  # pragma: no cover
+        assert iterator_options is None, (
+            "You may not specify both 'iterator_type' and 'iterator_opts' with 'iterator_options'! "
+            "Please use only 'iterator_options'."
+        )
+        warn(
+            message=(
+                "The options 'iterator_type' and 'iterator_opts' will soon be deprecated! "
+                "Please use 'iterator_options' instead."
+            ),
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        iterator_options = dict(
+            method=iterator_type or "v2",
+            method_options=iterator_opts or dict(),
+        )
+
+    compression_options = compression_options or dict(method="gzip")
+    iterator_options = iterator_options or dict(method="v2")
+
     if use_times:
         warn("Keyword argument 'use_times' is deprecated and will be removed on or after August 1st, 2022.")
 
@@ -725,15 +785,15 @@ def add_electrical_series(
     if not write_scaled:
         eseries_kwargs.update(offset=unique_offset * micro_to_volts_conversion_factor)
 
-    # Iterator
     ephys_data_iterator = _recording_traces_to_hdmf_iterator(
-        recording=checked_recording,
-        segment_index=segment_index,
-        iterator_type=iterator_type,
-        iterator_opts=iterator_opts,
+        recording=checked_recording, segment_index=segment_index, iterator_options=iterator_options
     )
     eseries_kwargs.update(
-        data=H5DataIO(data=ephys_data_iterator, compression=compression, compression_opts=compression_opts)
+        data=H5DataIO(
+            data=ephys_data_iterator,
+            compression=compression_options["method"],
+            compression_opts=compression_options.get("method_options"),
+        )
     )
 
     # Timestamps vs rate
@@ -747,7 +807,9 @@ def add_electrical_series(
     else:
         shifted_time_stamps = starting_time + timestamps
         wrapped_timestamps = H5DataIO(
-            data=shifted_time_stamps, compression=compression, compression_opts=compression_opts
+            data=shifted_time_stamps,
+            compression=compression_options["method"],
+            compression_opts=compression_options.get("method_options"),
         )
         eseries_kwargs.update(timestamps=wrapped_timestamps)
 
@@ -847,7 +909,8 @@ def add_electrodes_info(recording: RecordingExtractor, nwbfile: pynwb.NWBFile, m
     add_electrodes(recording=recording, nwbfile=nwbfile, metadata=metadata)
 
 
-def add_all_to_nwbfile(
+# TODO: remove function
+def add_all_to_nwbfile(  # pragma: no cover
     recording: SpikeInterfaceRecording,
     nwbfile=None,
     starting_time: Optional[float] = None,
@@ -857,7 +920,9 @@ def add_all_to_nwbfile(
     es_key: str = None,
     write_electrical_series: bool = True,
     write_scaled: bool = False,
-    compression: Optional[str] = "gzip",
+    compression_options: Optional[dict] = None,
+    iterator_options: Optional[dict] = None,
+    compression: Optional[str] = None,
     compression_opts: Optional[int] = None,
     iterator_type: Optional[str] = None,
     iterator_opts: Optional[dict] = None,
@@ -912,6 +977,16 @@ def add_all_to_nwbfile(
                 Should be below 1 MB. Automatically calculates suitable chunk shape.
         If manual specification of buffer_shape and chunk_shape are desired, these may be specified as well.
     """
+    warnings.warn(
+        message=(
+            "The function 'add_all_to_nwbfile' will soon be deprecated! "
+            "Please use either 'write_recording' or directly call the sub-functions "
+            "'add_electrodes_info' and 'add_electrical_series'."
+        ),
+        category=DeprecationWarning,
+        stacklevel=2,
+    )
+
     if nwbfile is not None:
         assert isinstance(nwbfile, pynwb.NWBFile), "'nwbfile' should be of type pynwb.NWBFile"
     add_electrodes_info(recording=recording, nwbfile=nwbfile, metadata=metadata)
@@ -948,10 +1023,12 @@ def write_recording(
     es_key: Optional[str] = None,
     write_electrical_series: bool = True,
     write_scaled: bool = False,
-    compression: Optional[str] = None,
-    compression_opts: Optional[int] = None,
-    iterator_type: str = "v2",
-    iterator_opts: Optional[dict] = None,
+    compression_options: Optional[dict] = None,
+    iterator_options: Optional[dict] = None,
+    compression: Optional[str] = None,  # TODO: remove
+    compression_opts: Optional[int] = None,  # TODO: remove
+    iterator_type: Optional[str] = None,  # TODO: remove
+    iterator_opts: Optional[dict] = None,  # TODO: remove
 ):
     """
     Primary method for writing a RecordingExtractor object to an NWBFile.
@@ -1052,7 +1129,6 @@ def write_recording(
         "1.3.3"
     ), "'write_recording' not supported for version < 1.3.3. Run pip install --upgrade pynwb"
     write_as = "raw" if write_as is None else write_as
-    compression = "gzip" if compression is None else compression
 
     if hasattr(recording, "nwb_metadata"):
         metadata = dict_deep_update(recording.nwb_metadata, metadata)
@@ -1078,10 +1154,8 @@ def write_recording(
                     write_as=write_as,
                     es_key=es_key,
                     write_scaled=write_scaled,
-                    compression=compression,
-                    compression_opts=compression_opts,
-                    iterator_type=iterator_type,
-                    iterator_opts=iterator_opts,
+                    compression_options=compression_options,
+                    iterator_options=iterator_options,
                 )
 
         # For objects of the legacy spikeextractors we support adding epochs
diff --git a/tests/test_ecephys/test_tools_spikeinterface.py b/tests/test_ecephys/test_tools_spikeinterface.py
index 7ab78ed5..dc61b84b 100644
--- a/tests/test_ecephys/test_tools_spikeinterface.py
+++ b/tests/test_ecephys/test_tools_spikeinterface.py
@@ -57,7 +57,9 @@ class TestAddElectricalSeriesWriting(unittest.TestCase):
 
     def test_default_values(self):
 
-        add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None)
+        add_electrical_series(
+            recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_options=dict(method=None)
+        )
 
         acquisition_module = self.nwbfile.acquisition
         assert "ElectricalSeriesRaw" in acquisition_module
@@ -75,7 +77,10 @@ class TestAddElectricalSeriesWriting(unittest.TestCase):
     def test_write_as_lfp(self):
         write_as = "lfp"
         add_electrical_series(
-            recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None, write_as=write_as
+            recording=self.test_recording_extractor,
+            nwbfile=self.nwbfile,
+            iterator_options=dict(method=None),
+            write_as=write_as,
         )
 
         processing_module = self.nwbfile.processing
@@ -96,7 +101,10 @@ class TestAddElectricalSeriesWriting(unittest.TestCase):
     def test_write_as_processing(self):
         write_as = "processed"
         add_electrical_series(
-            recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None, write_as=write_as
+            recording=self.test_recording_extractor,
+            nwbfile=self.nwbfile,
+            iterator_options=dict(method=None),
+            write_as=write_as,
         )
 
         processing_module = self.nwbfile.processing
@@ -122,7 +130,10 @@ class TestAddElectricalSeriesWriting(unittest.TestCase):
 
         with self.assertRaisesRegex(AssertionError, reg_expression):
             add_electrical_series(
-                recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None, write_as=write_as
+                recording=self.test_recording_extractor,
+                nwbfile=self.nwbfile,
+                iterator_options=dict(method=None),
+                write_as=write_as,
             )
 
     def test_write_with_higher_gzip_level(self):
@@ -131,7 +142,7 @@ class TestAddElectricalSeriesWriting(unittest.TestCase):
         add_electrical_series(
             recording=self.test_recording_extractor,
             nwbfile=self.nwbfile,
-            iterator_type=None,
+            iterator_options=dict(method=None),
             compression=compression,
             compression_opts=compression_opts,
         )
@@ -145,7 +156,10 @@ class TestAddElectricalSeriesWriting(unittest.TestCase):
     def test_write_with_lzf_compression(self):
         compression = "lzf"
         add_electrical_series(
-            recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None, compression=compression
+            recording=self.test_recording_extractor,
+            nwbfile=self.nwbfile,
+            iterator_options=dict(method=None),
+            compression=compression,
         )
 
         acquisition_module = self.nwbfile.acquisition
@@ -173,7 +187,9 @@ class TestAddElectricalSeriesSavingTimestampsVsRates(unittest.TestCase):
         )
 
     def test_uniform_timestamps(self):
-        add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None)
+        add_electrical_series(
+            recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_options=dict(method=None)
+        )
 
         acquisition_module = self.nwbfile.acquisition
         electrical_series = acquisition_module["ElectricalSeriesRaw"]
@@ -186,7 +202,9 @@ class TestAddElectricalSeriesSavingTimestampsVsRates(unittest.TestCase):
     def test_non_uniform_timestamps(self):
         expected_timestamps = np.array([0.0, 2.0, 10.0])
         self.test_recording_extractor.set_times(times=expected_timestamps, with_warning=False)
-        add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None)
+        add_electrical_series(
+            recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_options=dict(method=None)
+        )
 
         acquisition_module = self.nwbfile.acquisition
         electrical_series = acquisition_module["ElectricalSeriesRaw"]
@@ -233,7 +251,9 @@ class TestAddElectricalSeriesVoltsScaling(unittest.TestCase):
         self.test_recording_extractor.set_channel_gains(gains=gains)
         self.test_recording_extractor.set_channel_offsets(offsets=offsets)
 
-        add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None)
+        add_electrical_series(
+            recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_options=dict(method=None)
+        )
 
         acquisition_module = self.nwbfile.acquisition
         electrical_series = acquisition_module["ElectricalSeriesRaw"]
@@ -259,7 +279,9 @@ class TestAddElectricalSeriesVoltsScaling(unittest.TestCase):
         self.test_recording_extractor.set_channel_gains(gains=gains)
         self.test_recording_extractor.set_channel_offsets(offsets=offsets)
 
-        add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None)
+        add_electrical_series(
+            recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_options=dict(method=None)
+        )
 
         acquisition_module = self.nwbfile.acquisition
         electrical_series = acquisition_module["ElectricalSeriesRaw"]
@@ -285,7 +307,9 @@ class TestAddElectricalSeriesVoltsScaling(unittest.TestCase):
         self.test_recording_extractor.set_channel_gains(gains=gains)
         self.test_recording_extractor.set_channel_offsets(offsets=offsets)
 
-        add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None)
+        add_electrical_series(
+            recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_options=dict(method=None)
+        )
 
         acquisition_module = self.nwbfile.acquisition
         electrical_series = acquisition_module["ElectricalSeriesRaw"]
@@ -313,7 +337,9 @@ class TestAddElectricalSeriesVoltsScaling(unittest.TestCase):
         gains = self.gains_default
         self.test_recording_extractor.set_channel_gains(gains=gains)
 
-        add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None)
+        add_electrical_series(
+            recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_options=dict(method=None)
+        )
 
         acquisition_module = self.nwbfile.acquisition
         electrical_series = acquisition_module["ElectricalSeriesRaw"]
@@ -345,10 +371,12 @@ class TestAddElectricalSeriesVoltsScaling(unittest.TestCase):
         reg_expression = f"Recording extractors with heterogeneous offsets are not supported"
 
         with self.assertRaisesRegex(ValueError, reg_expression):
-            add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None)
+            add_electrical_series(
+                recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_options=dict(method=None)
+            )
 
 
-class TestAddElectricalSeriesChunking(unittest.TestCase):
+class TestAddElectricalSeriesChunking(TestCase):
     @classmethod
     def setUpClass(cls):
         """Use common recording objects and values."""
@@ -404,7 +432,7 @@ class TestAddElectricalSeriesChunking(unittest.TestCase):
 
         assert electrical_series_data_iterator.chunk_shape == iterator_opts["chunk_shape"]
 
-    def test_hdfm_iterator(self):
+    def test_hdmf_iterator(self):
 
         add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type="v1")
 
@@ -420,7 +448,9 @@ class TestAddElectricalSeriesChunking(unittest.TestCase):
         np.testing.assert_array_almost_equal(expected_data, extracted_data)
 
     def test_non_iterative_write(self):
-        add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None)
+        add_electrical_series(
+            recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_options=dict(method=None)
+        )
 
         acquisition_module = self.nwbfile.acquisition
         electrical_series = acquisition_module["ElectricalSeriesRaw"]
@@ -450,13 +480,12 @@ class TestAddElectricalSeriesChunking(unittest.TestCase):
             check_if_recording_traces_fit_into_memory(recording=mock_recorder)
 
     def test_invalid_iterator_type_assertion(self):
-
-        iterator_type = "invalid_iterator_type"
-
-        reg_expression = "iterator_type (.*?)"
-        with self.assertRaisesRegex(ValueError, reg_expression):
+        with self.assertRaisesWith(
+            exc_type=ValueError,
+            exc_msg="The `method` of `iterator_options` should be either 'v1', 'v2' (recommended) or None! Received 'invalid_iterator_type'.",
+        ):
             add_electrical_series(
-                recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=iterator_type
+                recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type="invalid_iterator_type"
             )
 
 
@@ -492,7 +521,9 @@ class TestWriteRecording(unittest.TestCase):
 
     def test_default_values_single_segment(self):
         """This test that the names are written appropiately for the single segment case (numbers not added)"""
-        write_recording(recording=self.single_segment_recording_extractor, nwbfile=self.nwbfile, iterator_type=None)
+        write_recording(
+            recording=self.single_segment_recording_extractor, nwbfile=self.nwbfile, iterator_options=dict(method=None)
+        )
 
         acquisition_module = self.nwbfile.acquisition
         assert "ElectricalSeriesRaw" in acquisition_module
@@ -509,7 +540,11 @@ class TestWriteRecording(unittest.TestCase):
 
     def test_write_multiple_segments(self):
 
-        write_recording(recording=self.multiple_segment_recording_extractor, nwbfile=self.nwbfile, iterator_type=None)
+        write_recording(
+            recording=self.multiple_segment_recording_extractor,
+            nwbfile=self.nwbfile,
+            iterator_options=dict(method=None),
+        )
 
         acquisition_module = self.nwbfile.acquisition
         assert len(acquisition_module) == 2
diff --git a/tests/test_ophys/test_tools_roiextractors.py b/tests/test_ophys/test_tools_roiextractors.py
index 1b3f0260..d119613d 100644
--- a/tests/test_ophys/test_tools_roiextractors.py
+++ b/tests/test_ophys/test_tools_roiextractors.py
@@ -1207,8 +1207,8 @@ class TestAddTwoPhotonSeries(TestCase):
     def test_invalid_iterator_type_raises_error(self):
         """Test error is raised when adding two photon series with invalid iterator type."""
         with self.assertRaisesWith(
-            AssertionError,
-            "'iterator_type' must be either 'v1', 'v2' (recommended), or None.",
+            exc_type=ValueError,
+            exc_msg="The `method` of `iterator_options` should be either 'v1', 'v2' (recommended) or None! Received 'invalid'.",
         ):
             add_two_photon_series(
                 imaging=self.imaging_extractor,
@@ -1248,7 +1248,7 @@ class TestAddTwoPhotonSeries(TestCase):
             imaging=self.imaging_extractor,
             nwbfile=self.nwbfile,
             metadata=self.metadata,
-            iterator_type=None,
+            iterator_options=dict(method=None),
         )
 
         # Check data
['tests/test_ophys/test_tools_roiextractors.py', 'src/neuroconv/datainterfaces/ecephys/baserecordingextractorinterface.py', 'src/neuroconv/tools/spikeinterface/spikeinterface.py', 'src/neuroconv/datainterfaces/ophys/basesegmentationextractorinterface.py', 'tests/test_ecephys/test_tools_spikeinterface.py', 'CHANGELOG.md', 'src/neuroconv/datainterfaces/ophys/baseimagingextractorinterface.py', 'src/neuroconv/basedatainterface.py', 'src/neuroconv/datainterfaces/ecephys/baselfpextractorinterface.py', 'src/neuroconv/tools/roiextractors/roiextractors.py']