eodag 3.10.1__py3-none-any.whl → 4.0.0a2__py3-none-any.whl

eodag/api/core.py

@@ -23,14 +23,17 @@ import os
 import re
 import shutil
 import tempfile
+import warnings
+from collections import deque
 from importlib.metadata import version
 from importlib.resources import files as res_files
-from operator import itemgetter
+from operator import attrgetter, itemgetter
 from typing import TYPE_CHECKING, Any, Iterator, Optional, Union
 
 import geojson
-import yaml.parser
+import yaml
 
+from eodag.api.collection import Collection, CollectionsDict, CollectionsList
 from eodag.api.product.metadata_mapping import (
     NOT_AVAILABLE,
     mtd_cfg_as_conversion_and_querypath,
@@ -41,7 +44,7 @@ from eodag.config import (
     PluginConfig,
     SimpleYamlProxyConfig,
     credentials_in_auth,
-    get_ext_product_types_conf,
+    get_ext_collections_conf,
     load_default_config,
     load_stac_provider_config,
     load_yml_config,
@@ -53,7 +56,10 @@ from eodag.config import (
 )
 from eodag.plugins.manager import PluginManager
 from eodag.plugins.search import PreparedSearch
-from eodag.plugins.search.build_search_result import MeteoblueSearch
+from eodag.plugins.search.build_search_result import (
+    ALLOWED_KEYWORDS as ECMWF_ALLOWED_KEYWORDS,
+)
+from eodag.plugins.search.build_search_result import ECMWF_PREFIX, MeteoblueSearch
 from eodag.plugins.search.qssearch import PostJsonSearch
 from eodag.types import model_fields_to_annotated
 from eodag.types.queryables import CommonQueryables, Queryables, QueryablesDict
@@ -63,10 +69,8 @@ from eodag.utils import (
     DEFAULT_ITEMS_PER_PAGE,
     DEFAULT_MAX_ITEMS_PER_PAGE,
     DEFAULT_PAGE,
-    GENERIC_PRODUCT_TYPE,
+    GENERIC_COLLECTION,
     GENERIC_STAC_PROVIDER,
-    HTTP_REQ_TIMEOUT,
-    MockResponse,
     _deprecated,
     get_geometry_from_various,
     makedirs,
@@ -78,11 +82,12 @@ from eodag.utils.dates import rfc3339_str_to_datetime
 from eodag.utils.env import is_env_var_true
 from eodag.utils.exceptions import (
     AuthenticationError,
-    NoMatchingProductType,
+    NoMatchingCollection,
     PluginImplementationError,
     RequestError,
-    UnsupportedProductType,
+    UnsupportedCollection,
     UnsupportedProvider,
+    ValidationError,
 )
 from eodag.utils.free_text_search import compile_free_text_query
 from eodag.utils.stac_reader import fetch_stac_items
@@ -114,10 +119,11 @@ class EODataAccessGateway:
         user_conf_file_path: Optional[str] = None,
         locations_conf_path: Optional[str] = None,
     ) -> None:
-        product_types_config_path = os.getenv("EODAG_PRODUCT_TYPES_CFG_FILE") or str(
-            res_files("eodag") / "resources" / "product_types.yml"
+        collections_config_path = os.getenv("EODAG_COLLECTIONS_CFG_FILE") or str(
+            res_files("eodag") / "resources" / "collections.yml"
         )
-        self.product_types_config = SimpleYamlProxyConfig(product_types_config_path)
+        collections_config_dict = SimpleYamlProxyConfig(collections_config_path).source
+        self.collections_config = self._collections_config_init(collections_config_dict)
         self.providers_config = load_default_config()
 
         env_var_cfg_dir = "EODAG_CFG_DIR"
@@ -169,8 +175,8 @@ class EODataAccessGateway:
         share_credentials(self.providers_config)
 
         # init updated providers conf
-        strict_mode = is_env_var_true("EODAG_STRICT_PRODUCT_TYPES")
-        available_product_types = set(self.product_types_config.source.keys())
+        strict_mode = is_env_var_true("EODAG_STRICT_COLLECTIONS")
+        available_collections = set(self.collections_config.keys())
 
         for provider in self.providers_config.keys():
             provider_config_init(
@@ -178,11 +184,9 @@ class EODataAccessGateway:
                 load_stac_provider_config(),
             )
 
-            self._sync_provider_product_types(
-                provider, available_product_types, strict_mode
+            self._sync_provider_collections(
+                provider, available_collections, strict_mode
             )
-        # init product types configuration
-        self._product_types_config_init()
 
         # re-build _plugins_manager using up-to-date providers_config
         self._plugins_manager.rebuild(self.providers_config)
@@ -225,26 +229,35 @@ class EODataAccessGateway:
                     )
         self.set_locations_conf(locations_conf_path)
 
-    def _product_types_config_init(self) -> None:
-        """Initialize product types configuration."""
-        for pt_id, pd_dict in self.product_types_config.source.items():
-            self.product_types_config.source[pt_id].setdefault("_id", pt_id)
+    def _collections_config_init(
+        self, collections_config_dict: dict[str, Any]
+    ) -> CollectionsDict:
+        """Initialize collections configuration.
 
-    def _sync_provider_product_types(
+        :param collections_config_dict: The collections config as a dictionary
+        """
+        # Turn the collections config from a dict into a CollectionsDict() object
+        collections = [
+            Collection.create_with_dag(self, id=col, **col_f)
+            for col, col_f in collections_config_dict.items()
+        ]
+        return CollectionsDict(collections)
+
+    def _sync_provider_collections(
         self,
         provider: str,
-        available_product_types: set[str],
+        available_collections: set[str],
         strict_mode: bool,
     ) -> None:
         """
-        Synchronize product types for a provider based on strict or permissive mode.
+        Synchronize collections for a provider based on strict or permissive mode.
 
-        In strict mode, removes product types not in available_product_types.
-        In permissive mode, adds empty product type configs for missing types.
+        In strict mode, removes collections not in available_collections.
+        In permissive mode, adds empty collection configs for missing types.
 
-        :param provider: The provider name whose product types should be synchronized.
-        :param available_product_types: The set of available product type IDs.
-        :param strict_mode: If True, remove unknown product types; if False, add empty configs for them.
+        :param provider: The provider name whose collections should be synchronized.
+        :param available_collections: The set of available collection IDs.
+        :param strict_mode: If True, remove unknown collections; if False, add empty configs for them.
         :returns: None
         """
         provider_products = self.providers_config[provider].products
@@ -252,33 +265,30 @@ class EODataAccessGateway:
         products_to_add: list[str] = []
 
         for product_id in provider_products:
-            if product_id == GENERIC_PRODUCT_TYPE:
+            if product_id == GENERIC_COLLECTION:
                 continue
 
-            if product_id not in available_product_types:
+            if product_id not in available_collections:
                 if strict_mode:
                     products_to_remove.append(product_id)
                     continue
 
-                empty_product = {
-                    "title": product_id,
-                    "abstract": NOT_AVAILABLE,
-                }
-                self.product_types_config.source[
-                    product_id
-                ] = empty_product  # will update available_product_types
+                empty_product = Collection.create_with_dag(
+                    self, id=product_id, title=product_id, description=NOT_AVAILABLE
+                )
+                self.collections_config[product_id] = empty_product
                 products_to_add.append(product_id)
 
         if products_to_add:
             logger.debug(
-                "Product types permissive mode, %s added (provider %s)",
+                "Collections permissive mode, %s added (provider %s)",
                 ", ".join(products_to_add),
                 provider,
             )
 
         if products_to_remove:
             logger.debug(
-                "Product types strict mode, ignoring %s (provider %s)",
+                "Collections strict mode, ignoring %s (provider %s)",
                 ", ".join(products_to_remove),
                 provider,
             )
@@ -357,9 +367,9 @@ class EODataAccessGateway:
                 self.providers_config[provider],
                 load_stac_provider_config(),
             )
-            setattr(self.providers_config[provider], "product_types_fetched", False)
+            setattr(self.providers_config[provider], "collections_fetched", False)
         # re-create _plugins_manager using up-to-date providers_config
-        self._plugins_manager.build_product_type_to_provider_config_map()
+        self._plugins_manager.build_collection_to_provider_config_map()
 
     def add_provider(
         self,
@@ -368,7 +378,7 @@ class EODataAccessGateway:
         priority: Optional[int] = None,
         search: dict[str, Any] = {"type": "StacSearch"},
         products: dict[str, Any] = {
-            GENERIC_PRODUCT_TYPE: {"productType": "{productType}"}
+            GENERIC_COLLECTION: {"_collection": "{collection}"}
         },
         download: dict[str, Any] = {"type": "HTTPDownload", "auth_error_code": 401},
         **kwargs: dict[str, Any],
@@ -379,14 +389,14 @@ class EODataAccessGateway:
         updated (not replaced), with user provided ones:
 
             * ``search`` : ``{"type": "StacSearch"}``
-            * ``products`` : ``{"GENERIC_PRODUCT_TYPE": {"productType": "{productType}"}}``
+            * ``products`` : ``{"GENERIC_COLLECTION": {"_collection": "{collection}"}}``
             * ``download`` : ``{"type": "HTTPDownload", "auth_error_code": 401}``
 
         :param name: Name of provider
         :param url: Provider url, also used as ``search["api_endpoint"]`` if not defined
         :param priority: Provider priority. If None, provider will be set as preferred (highest priority)
         :param search: Search :class:`~eodag.config.PluginConfig` mapping
-        :param products: Provider product types mapping
+        :param products: Provider collections mapping
         :param download: Download :class:`~eodag.config.PluginConfig` mapping
         :param kwargs: Additional :class:`~eodag.config.ProviderConfig` mapping
         """
@@ -395,7 +405,7 @@ class EODataAccessGateway:
                 "url": url,
                 "search": {"type": "StacSearch", **search},
                 "products": {
-                    GENERIC_PRODUCT_TYPE: {"productType": "{productType}"},
+                    GENERIC_COLLECTION: {"_collection": "{collection}"},
                     **products,
                 },
                 "download": {
@@ -541,23 +551,23 @@ class EODataAccessGateway:
             )
             self.locations_config = []
 
-    def list_product_types(
+    def list_collections(
         self, provider: Optional[str] = None, fetch_providers: bool = True
-    ) -> list[dict[str, Any]]:
-        """Lists supported product types.
+    ) -> CollectionsList:
+        """Lists supported collections.
 
         :param provider: (optional) The name of a provider that must support the product
                          types we are about to list
         :param fetch_providers: (optional) Whether to fetch providers for new product
                                 types or not
-        :returns: The list of the product types that can be accessed using eodag.
+        :returns: The list of the collections that can be accessed using eodag.
         :raises: :class:`~eodag.utils.exceptions.UnsupportedProvider`
         """
         if fetch_providers:
-            # First, update product types list if possible
-            self.fetch_product_types_list(provider=provider)
+            # First, update collections list if possible
+            self.fetch_collections_list(provider=provider)
 
-        product_types: list[dict[str, Any]] = []
+        collections: CollectionsList = CollectionsList([])
 
         providers_configs = (
             list(self.providers_config.values())
@@ -575,31 +585,29 @@ class EODataAccessGateway:
             )
 
         for p in providers_configs:
-            for product_type_id in p.products:  # type: ignore
-                if product_type_id == GENERIC_PRODUCT_TYPE:
+            for collection_id in p.products:
+                if collection_id == GENERIC_COLLECTION:
                     continue
 
-                config = self.product_types_config[product_type_id]
-                if "alias" in config:
-                    product_type_id = config["alias"]
-                product_type = {"ID": product_type_id, **config}
-
-                if product_type not in product_types:
-                    product_types.append(product_type)
+                if (
+                    collection := self.collections_config[collection_id]
+                ) not in collections:
+                    collections.append(collection)
 
-        # Return the product_types sorted in lexicographic order of their ID
-        return sorted(product_types, key=itemgetter("ID"))
+        # Return the collections sorted in lexicographic order of their id
+        collections.sort(key=attrgetter("id"))
+        return collections
 
-    def fetch_product_types_list(self, provider: Optional[str] = None) -> None:
-        """Fetch product types list and update if needed.
+    def fetch_collections_list(self, provider: Optional[str] = None) -> None:
+        """Fetch collections list and update if needed.
 
-        If strict mode is enabled (by setting the ``EODAG_STRICT_PRODUCT_TYPES`` environment variable
-        to a truthy value), this method will not fetch or update product types and will return immediately.
+        If strict mode is enabled (by setting the ``EODAG_STRICT_COLLECTIONS`` environment variable
+        to a truthy value), this method will not fetch or update collections and will return immediately.
 
-        :param provider: The name of a provider or provider-group for which product types
+        :param provider: The name of a provider or provider-group for which collections
                          list should be updated. Defaults to all providers (None value).
         """
-        strict_mode = is_env_var_true("EODAG_STRICT_PRODUCT_TYPES")
+        strict_mode = is_env_var_true("EODAG_STRICT_COLLECTIONS")
         if strict_mode:
             return
 
@@ -613,7 +621,7 @@ class EODataAccessGateway:
             ]
             if providers_to_fetch:
                 logger.info(
-                    f"Fetch product types for {provider} group: {', '.join(providers_to_fetch)}"
+                    f"Fetch collections for {provider} group: {', '.join(providers_to_fetch)}"
                 )
             else:
                 return None
@@ -622,7 +630,7 @@ class EODataAccessGateway:
 
         # providers discovery confs that are fetchable
         providers_discovery_configs_fetchable: dict[str, Any] = {}
-        # check if any provider has not already been fetched for product types
+        # check if any provider has not already been fetched for collections
         already_fetched = True
         for provider_to_fetch in providers_to_fetch:
             provider_config = self.providers_config[provider_to_fetch]
@@ -633,45 +641,43 @@ class EODataAccessGateway:
                 provider_search_config = provider_config.api
             else:
                 continue
-            discovery_conf = getattr(
-                provider_search_config, "discover_product_types", {}
-            )
+            discovery_conf = getattr(provider_search_config, "discover_collections", {})
             if discovery_conf.get("fetch_url"):
                 providers_discovery_configs_fetchable[
                     provider_to_fetch
                 ] = discovery_conf
-                if not getattr(provider_config, "product_types_fetched", False):
+                if not getattr(provider_config, "collections_fetched", False):
                     already_fetched = False
 
         if not already_fetched:
-            # get ext_product_types conf
-            ext_product_types_cfg_file = os.getenv("EODAG_EXT_PRODUCT_TYPES_CFG_FILE")
-            if ext_product_types_cfg_file is not None:
-                ext_product_types_conf = get_ext_product_types_conf(
-                    ext_product_types_cfg_file
+            # get ext_collections conf
+            ext_collections_cfg_file = os.getenv("EODAG_EXT_COLLECTIONS_CFG_FILE")
+            if ext_collections_cfg_file is not None:
+                ext_collections_conf = get_ext_collections_conf(
+                    ext_collections_cfg_file
                 )
             else:
-                ext_product_types_conf = get_ext_product_types_conf()
+                ext_collections_conf = get_ext_collections_conf()
 
-                if not ext_product_types_conf:
-                    # empty ext_product_types conf
-                    ext_product_types_conf = (
-                        self.discover_product_types(provider=provider) or {}
+                if not ext_collections_conf:
+                    # empty ext_collections conf
+                    ext_collections_conf = (
+                        self.discover_collections(provider=provider) or {}
                     )
 
-            # update eodag product types list with new conf
-            self.update_product_types_list(ext_product_types_conf)
+            # update eodag collections list with new conf
+            self.update_collections_list(ext_collections_conf)
 
         # Compare current provider with default one to see if it has been modified
-        # and product types list would need to be fetched
+        # and collections list would need to be fetched
 
-        # get ext_product_types conf for user modified providers
+        # get ext_collections conf for user modified providers
         default_providers_config = load_default_config()
         for (
             provider,
             user_discovery_conf,
         ) in providers_discovery_configs_fetchable.items():
-            # default discover_product_types conf
+            # default discover_collections conf
             if provider in default_providers_config:
                 default_provider_config = default_providers_config[provider]
                 if hasattr(default_provider_config, "search"):
@@ -681,7 +687,7 @@ class EODataAccessGateway:
                 else:
                     continue
                 default_discovery_conf = getattr(
-                    default_provider_search_config, "discover_product_types", {}
+                    default_provider_search_config, "discover_collections", {}
                 )
                 # compare confs
                 if default_discovery_conf["result_type"] == "json" and isinstance(
@@ -696,22 +702,22 @@ class EODataAccessGateway:
                         },
                         **mtd_cfg_as_conversion_and_querypath(
                             dict(
-                                generic_product_type_id=default_discovery_conf[
-                                    "generic_product_type_id"
+                                generic_collection_id=default_discovery_conf[
+                                    "generic_collection_id"
                                 ]
                             )
                         ),
                         **dict(
-                            generic_product_type_parsable_properties=mtd_cfg_as_conversion_and_querypath(
+                            generic_collection_parsable_properties=mtd_cfg_as_conversion_and_querypath(
                                 default_discovery_conf[
-                                    "generic_product_type_parsable_properties"
+                                    "generic_collection_parsable_properties"
                                 ]
                             )
                         ),
                         **dict(
-                            generic_product_type_parsable_metadata=mtd_cfg_as_conversion_and_querypath(
+                            generic_collection_parsable_metadata=mtd_cfg_as_conversion_and_querypath(
                                 default_discovery_conf[
-                                    "generic_product_type_parsable_metadata"
+                                    "generic_collection_parsable_metadata"
                                 ]
                             )
                         ),
@@ -723,33 +729,33 @@ class EODataAccessGateway:
                     or user_discovery_conf == default_discovery_conf_parsed
                 ) and (
                     not default_discovery_conf.get("fetch_url")
-                    or "ext_product_types_conf" not in locals()
-                    or "ext_product_types_conf" in locals()
+                    or "ext_collections_conf" not in locals()
+                    or "ext_collections_conf" in locals()
                     and (
-                        provider in ext_product_types_conf
-                        or len(ext_product_types_conf.keys()) == 0
+                        provider in ext_collections_conf
+                        or len(ext_collections_conf.keys()) == 0
                     )
                 ):
                     continue
                 # providers not skipped here should be user-modified
-                # or not in ext_product_types_conf (if eodag system conf != eodag conf used for ext_product_types_conf)
+                # or not in ext_collections_conf (if eodag system conf != eodag conf used for ext_collections_conf)
 
             if not already_fetched:
-                # discover product types for user configured provider
-                provider_ext_product_types_conf = (
-                    self.discover_product_types(provider=provider) or {}
+                # discover collections for user configured provider
+                provider_ext_collections_conf = (
+                    self.discover_collections(provider=provider) or {}
                 )
-                # update eodag product types list with new conf
-                self.update_product_types_list(provider_ext_product_types_conf)
+                # update eodag collections list with new conf
+                self.update_collections_list(provider_ext_collections_conf)
 
-    def discover_product_types(
+    def discover_collections(
         self, provider: Optional[str] = None
     ) -> Optional[dict[str, Any]]:
-        """Fetch providers for product types
+        """Fetch providers for collections
 
         :param provider: The name of a provider or provider-group to fetch. Defaults to
                          all providers (None value).
-        :returns: external product types configuration
+        :returns: external collections configuration
         """
         grouped_providers = [
             p
@@ -758,13 +764,13 @@ class EODataAccessGateway:
         ]
         if provider and provider not in self.providers_config and grouped_providers:
             logger.info(
-                f"Discover product types for {provider} group: {', '.join(grouped_providers)}"
+                f"Discover collections for {provider} group: {', '.join(grouped_providers)}"
             )
         elif provider and provider not in self.providers_config:
             raise UnsupportedProvider(
                 f"The requested provider is not (yet) supported: {provider}"
             )
-        ext_product_types_conf: dict[str, Any] = {}
+        ext_collections_conf: dict[str, Any] = {}
         providers_to_fetch = [
             p
             for p in (
@@ -785,14 +791,14 @@ class EODataAccessGateway:
                 search_plugin_config = self.providers_config[provider].api
             else:
                 return None
-            if getattr(search_plugin_config, "discover_product_types", {}).get(
+            if getattr(search_plugin_config, "discover_collections", {}).get(
                 "fetch_url", None
             ):
                 search_plugin: Union[Search, Api] = next(
                     self._plugins_manager.get_search_plugins(provider=provider)
                 )
                 # check after plugin init if still fetchable
-                if not getattr(search_plugin.config, "discover_product_types", {}).get(
+                if not getattr(search_plugin.config, "discover_collections", {}).get(
                     "fetch_url"
                 ):
                     continue
@@ -806,26 +812,26 @@ class EODataAccessGateway:
                         kwargs["auth"] = auth
                     else:
                         logger.debug(
-                            f"Could not authenticate on {provider} for product types discovery"
+                            f"Could not authenticate on {provider} for collections discovery"
                         )
-                        ext_product_types_conf[provider] = None
+                        ext_collections_conf[provider] = None
                         continue
 
-                ext_product_types_conf[provider] = search_plugin.discover_product_types(
+                ext_collections_conf[provider] = search_plugin.discover_collections(
                     **kwargs
                 )
 
-        return sort_dict(ext_product_types_conf)
+        return sort_dict(ext_collections_conf)
 
-    def update_product_types_list(
-        self, ext_product_types_conf: dict[str, Optional[dict[str, dict[str, Any]]]]
+    def update_collections_list(
+        self, ext_collections_conf: dict[str, Optional[dict[str, dict[str, Any]]]]
     ) -> None:
-        """Update eodag product types list
+        """Update eodag collections list
 
-        :param ext_product_types_conf: external product types configuration
+        :param ext_collections_conf: external collections configuration
         """
-        for provider, new_product_types_conf in ext_product_types_conf.items():
-            if new_product_types_conf and provider in self.providers_config:
+        for provider, new_collections_conf in ext_collections_conf.items():
+            if new_collections_conf and provider in self.providers_config:
                 try:
                     search_plugin_config = getattr(
                         self.providers_config[provider], "search", None
@@ -833,77 +839,108 @@ class EODataAccessGateway:
                     if search_plugin_config is None:
                         continue
                     if not getattr(
-                        search_plugin_config, "discover_product_types", {}
+                        search_plugin_config, "discover_collections", {}
                     ).get("fetch_url"):
-                        # conf has been updated and provider product types are no more discoverable
+                        # conf has been updated and provider collections are no more discoverable
                         continue
                     provider_products_config = (
                         self.providers_config[provider].products or {}
                     )
                 except UnsupportedProvider:
                     logger.debug(
-                        "Ignoring external product types for unknown provider %s",
+                        "Ignoring external collections for unknown provider %s",
                         provider,
                     )
                     continue
-                new_product_types: list[str] = []
+                new_collections: list[str] = []
+                bad_formatted_col_count = 0
                 for (
-                    new_product_type,
-                    new_product_type_conf,
-                ) in new_product_types_conf["providers_config"].items():
-                    if new_product_type not in provider_products_config:
-                        for existing_product_type in provider_products_config.copy():
+                    new_collection,
+                    new_collection_conf,
+                ) in new_collections_conf["providers_config"].items():
+                    if new_collection not in provider_products_config:
+                        for existing_collection in provider_products_config.copy():
                             # compare parsed extracted conf (without metadata_mapping entry)
                             unparsable_keys = (
-                                search_plugin_config.discover_product_types.get(
-                                    "generic_product_type_unparsable_properties", {}
+                                search_plugin_config.discover_collections.get(
+                                    "generic_collection_unparsable_properties", {}
                                 ).keys()
                             )
-                            new_parsed_product_types_conf = {
+                            new_parsed_collections_conf = {
                                 k: v
-                                for k, v in new_product_type_conf.items()
+                                for k, v in new_collection_conf.items()
                                 if k not in unparsable_keys
                             }
                             if (
-                                new_parsed_product_types_conf.items()
-                                <= provider_products_config[
-                                    existing_product_type
-                                ].items()
+                                new_parsed_collections_conf.items()
+                                <= provider_products_config[existing_collection].items()
                             ):
-                                # new_product_types_conf is a subset on an existing conf
+                                # new_collections_conf is a subset on an existing conf
                                 break
                         else:
-                            # new_product_type_conf does not already exist, append it
-                            # to provider_products_config
-                            provider_products_config[
-                                new_product_type
-                            ] = new_product_type_conf
-                            # to self.product_types_config
-                            self.product_types_config.source.update(
-                                {
-                                    new_product_type: {"_id": new_product_type}
-                                    | new_product_types_conf["product_types_config"][
-                                        new_product_type
-                                    ]
+                            try:
+                                # new_collection_conf does not already exist, append it
+                                # to self.collections_config
+                                self.collections_config[
+                                    new_collection
+                                ] = Collection.create_with_dag(
+                                    self,
+                                    id=new_collection,
+                                    **new_collections_conf["collections_config"][
+                                        new_collection
+                                    ],
+                                )
+                            except ValidationError:
+                                # skip collection if there is a problem with its id (missing or not a string)
+                                logger.debug(
+                                    (
+                                        "Collection %s has been pruned on provider %s "
+                                        "because its id was incorrectly parsed for eodag"
+                                    ),
+                                    new_collection,
+                                    provider,
+                                )
+                            else:
+                                # to provider_products_config
+                                provider_products_config[
+                                    new_collection
+                                ] = new_collection_conf
+                                ext_collections_conf[provider] = new_collections_conf
+                                new_collections.append(new_collection)
+                                # increase the increment if the new collection had
+                                # bad formatted attributes in the external config
+                                dumped_collection = self.collections_config[
+                                    new_collection
+                                ].model_dump()
+                                dumped_ext_conf_col = {
+                                    **dumped_collection,
+                                    **new_collections_conf["collections_config"][
+                                        new_collection
+                                    ],
                                 }
-                            )
-                            ext_product_types_conf[provider] = new_product_types_conf
-                            new_product_types.append(new_product_type)
-                if new_product_types:
+                                if dumped_ext_conf_col != dumped_collection:
+                                    bad_formatted_col_count += 1
+                if new_collections:
                     logger.debug(
-                        f"Added {len(new_product_types)} product types for {provider}"
+                        "Added %s collections for %s", len(new_collections), provider
                     )
+                    if bad_formatted_col_count > 0:
+                        logger.debug(
+                            "bad formatted attributes skipped for %s collection(s) on %s",
+                            bad_formatted_col_count,
+                            provider,
+                        )
 
             elif provider not in self.providers_config:
                 # unknown provider
                 continue
-            self.providers_config[provider].product_types_fetched = True
+            self.providers_config[provider].collections_fetched = True
 
         # re-create _plugins_manager using up-to-date providers_config
-        self._plugins_manager.build_product_type_to_provider_config_map()
+        self._plugins_manager.build_collection_to_provider_config_map()
 
     def available_providers(
-        self, product_type: Optional[str] = None, by_group: bool = False
+        self, collection: Optional[str] = None, by_group: bool = False
     ) -> list[str]:
         """Gives the sorted list of the available providers or groups
 
@@ -911,17 +948,17 @@ class EODataAccessGateway:
         and then alphabetically in ascending order for providers or groups with the same
         priority level.
 
-        :param product_type: (optional) Only list providers configured for this product_type
+        :param collection: (optional) Only list providers configured for this collection
         :param by_group: (optional) If set to True, list groups when available instead
                          of providers, mixed with other providers
         :returns: the sorted list of the available providers or groups
         """
 
-        if product_type:
+        if collection:
             providers = [
                 (v.group if by_group and hasattr(v, "group") else k, v.priority)
                 for k, v in self.providers_config.items()
-                if product_type in getattr(v, "products", {}).keys()
+                if collection in getattr(v, "products", {}).keys()
             ]
         else:
             providers = [
@@ -943,97 +980,103 @@ class EODataAccessGateway:
         # Return only the names of the providers or groups
         return [name for name, _ in providers]
 
-    def get_product_type_from_alias(self, alias_or_id: str) -> str:
-        """Return the ID of a product type by either its ID or alias
+    def get_collection_from_alias(self, alias_or_id: str) -> str:
+        """Return the id of a collection by either its id or alias
 
-        :param alias_or_id: Alias of the product type. If an existing ID is given, this
+        :param alias_or_id: Alias of the collection. If an existing id is given, this
                             method will directly return the given value.
-        :returns: Internal name of the product type.
+        :returns: Internal name of the collection.
         """
-        product_types = [
-            k
-            for k, v in self.product_types_config.items()
-            if v.get("alias") == alias_or_id
+        collections = [
+            k for k, v in self.collections_config.items() if v.alias == alias_or_id
         ]
 
-        if len(product_types) > 1:
-            raise NoMatchingProductType(
-                f"Too many matching product types for alias {alias_or_id}: {product_types}"
+        if len(collections) > 1:
+            raise NoMatchingCollection(
+                f"Too many matching collections for alias {alias_or_id}: {collections}"
             )
 
-        if len(product_types) == 0:
-            if alias_or_id in self.product_types_config:
+        if len(collections) == 0:
+            if alias_or_id in self.collections_config:
                 return alias_or_id
             else:
-                raise NoMatchingProductType(
-                    f"Could not find product type from alias or ID {alias_or_id}"
+                raise NoMatchingCollection(
+                    f"Could not find collection from alias or id {alias_or_id}"
                 )
 
-        return product_types[0]
+        return collections[0]
 
-    def get_alias_from_product_type(self, product_type: str) -> str:
-        """Return the alias of a product type by its ID. If no alias was defined for the
-        given product type, its ID is returned instead.
+    def get_alias_from_collection(self, collection: str) -> str:
+        """Return the alias of a collection by its id. If no alias was defined for the
+        given collection, its id is returned instead.
 
-        :param product_type: product type ID
-        :returns: Alias of the product type or its ID if no alias has been defined for it.
+        :param collection: collection id
+        :returns: Alias of the collection or its id if no alias has been defined for it.
         """
-        if product_type not in self.product_types_config:
-            raise NoMatchingProductType(product_type)
+        if collection not in self.collections_config:
+            raise NoMatchingCollection(collection)
 
-        return self.product_types_config[product_type].get("alias", product_type)
+        if alias := self.collections_config[collection].alias:
+            return alias
+        return collection
 
-    def guess_product_type(
+    def guess_collection(
         self,
         free_text: Optional[str] = None,
         intersect: bool = False,
-        instrument: Optional[str] = None,
+        instruments: Optional[str] = None,
         platform: Optional[str] = None,
-        platformSerialIdentifier: Optional[str] = None,
-        processingLevel: Optional[str] = None,
-        sensorType: Optional[str] = None,
+        constellation: Optional[str] = None,
+        processing_level: Optional[str] = None,
+        sensor_type: Optional[str] = None,
         keywords: Optional[str] = None,
-        abstract: Optional[str] = None,
+        description: Optional[str] = None,
         title: Optional[str] = None,
-        missionStartDate: Optional[str] = None,
-        missionEndDate: Optional[str] = None,
+        start_date: Optional[str] = None,
+        end_date: Optional[str] = None,
         **kwargs: Any,
-    ) -> list[str]:
+    ) -> CollectionsList:
         """
-        Find EODAG product type IDs that best match a set of search parameters.
+        Find EODAG collection IDs that best match a set of search parameters.
 
-        When using several filters, product types that match most of them will be returned at first.
+        When using several filters, collections that match most of them will be returned at first.
 
         :param free_text: Free text search filter used to search accross all the following parameters. Handles logical
                           operators with parenthesis (``AND``/``OR``/``NOT``), quoted phrases (``"exact phrase"``),
                           ``*`` and ``?`` wildcards.
         :param intersect: Join results for each parameter using INTERSECT instead of UNION.
-        :param instrument: Instrument parameter.
+        :param instruments: Instruments parameter.
         :param platform: Platform parameter.
-        :param platformSerialIdentifier: Platform serial identifier parameter.
-        :param processingLevel: Processing level parameter.
-        :param sensorType: Sensor type parameter.
+        :param constellation: Constellation parameter.
+        :param processing_level: Processing level parameter.
+        :param sensor_type: Sensor type parameter.
         :param keywords: Keywords parameter.
-        :param abstract: Abstract parameter.
+        :param description: description parameter.
         :param title: Title parameter.
-        :param missionStartDate: start date for datetime filtering. Not used by free_text
-        :param missionEndDate: end date for datetime filtering. Not used by free_text
+        :param start_date: start date for datetime filtering. Not used by free_text
+        :param end_date: end date for datetime filtering. Not used by free_text
         :returns: The best match for the given parameters.
-        :raises: :class:`~eodag.utils.exceptions.NoMatchingProductType`
+        :raises: :class:`~eodag.utils.exceptions.NoMatchingCollection`
         """
-        if productType := kwargs.get("productType"):
-            return [productType]
+        if collection := kwargs.get("collection"):
+            try:
+                collection = self.get_collection_from_alias(collection)
+                return CollectionsList([self.collections_config[collection]])
+            except NoMatchingCollection:
+                return CollectionsList(
+                    [Collection.create_with_dag(self, id=collection)]
+                )
 
         filters: dict[str, str] = {
             k: v
             for k, v in {
-                "instrument": instrument,
+                "instruments": instruments,
+                "constellation": constellation,
                 "platform": platform,
-                "platformSerialIdentifier": platformSerialIdentifier,
-                "processingLevel": processingLevel,
-                "sensorType": sensorType,
+                "processing:level": processing_level,
+                "eodag:sensor_type": sensor_type,
                 "keywords": keywords,
-                "abstract": abstract,
+                "description": description,
                 "title": title,
             }.items()
             if v is not None
@@ -1041,7 +1084,7 @@ class EODataAccessGateway:
 
         only_dates = (
             True
-            if (not free_text and not filters and (missionStartDate or missionEndDate))
+            if (not free_text and not filters and (start_date or end_date))
             else False
         )
 
@@ -1051,11 +1094,10 @@ class EODataAccessGateway:
 
         guesses_with_score: list[tuple[str, int]] = []
 
-        for pt_id, pt_dict in self.product_types_config.source.items():
+        for col, col_f in self.collections_config.items():
             if (
-                pt_id == GENERIC_PRODUCT_TYPE
-                or pt_id
-                not in self._plugins_manager.product_type_to_provider_config_map
+                col == GENERIC_COLLECTION
+                or col not in self._plugins_manager.collection_to_provider_config_map
             ):
                 continue
 
@@ -1063,7 +1105,7 @@ class EODataAccessGateway:
 
             # free text search
             if free_text:
-                match = free_text_evaluator(pt_dict)
+                match = free_text_evaluator(col_f.model_dump())
                 if match:
                     score += 1
                 elif intersect:
@@ -1079,9 +1121,16 @@ class EODataAccessGateway:
                 }
 
                 filter_matches = [
-                    filters_evaluators[filter_name]({filter_name: pt_dict[filter_name]})
+                    filters_evaluators[filter_name](
+                        {
+                            filter_name: col_f.__dict__[
+                                Collection.get_collection_mtd_from_alias(filter_name)
+                            ]
+                        }
+                    )
                     for filter_name, value in filters.items()
-                    if filter_name in pt_dict
+                    if Collection.get_collection_mtd_from_alias(filter_name)
+                    in col_f.__dict__
                 ]
 
                 if filters_matching_method(filter_matches):
@@ -1094,43 +1143,39 @@ class EODataAccessGateway:
                 continue
 
             # datetime filtering
-            if missionStartDate or missionEndDate:
+            if start_date or end_date:
                 min_aware = datetime.datetime.min.replace(tzinfo=datetime.timezone.utc)
                 max_aware = datetime.datetime.max.replace(tzinfo=datetime.timezone.utc)
 
+                col_start = col_f.extent.temporal.interval[0][0]
+                col_end = col_f.extent.temporal.interval[0][1]
+
                 max_start = max(
-                    rfc3339_str_to_datetime(missionStartDate)
-                    if missionStartDate
-                    else min_aware,
-                    rfc3339_str_to_datetime(pt_dict["missionStartDate"])
-                    if pt_dict.get("missionStartDate")
-                    else min_aware,
+                    rfc3339_str_to_datetime(start_date) if start_date else min_aware,
+                    col_start or min_aware,
                 )
                 min_end = min(
-                    rfc3339_str_to_datetime(missionEndDate)
-                    if missionEndDate
-                    else max_aware,
-                    rfc3339_str_to_datetime(pt_dict["missionEndDate"])
-                    if pt_dict.get("missionEndDate")
-                    else max_aware,
+                    rfc3339_str_to_datetime(end_date) if end_date else max_aware,
+                    col_end or max_aware,
                 )
                 if not (max_start <= min_end):
                     continue
 
-            pt_alias = pt_dict.get("alias", pt_id)
-            guesses_with_score.append((pt_alias, score))
+            guesses_with_score.append((col_f._id, score))
 
         if guesses_with_score:
-            # sort by score descending, then pt_id for stability
+            # sort by score descending, then col for stability
             guesses_with_score.sort(key=lambda x: (-x[1], x[0]))
-            return [pt_id for pt_id, _ in guesses_with_score]
+            return CollectionsList(
+                [self.collections_config[col] for col, _ in guesses_with_score]
+            )
 
-        raise NoMatchingProductType()
+        raise NoMatchingCollection()
 
     def search(
         self,
         page: int = DEFAULT_PAGE,
-        items_per_page: int = DEFAULT_ITEMS_PER_PAGE,
+        items_per_page: Optional[int] = DEFAULT_ITEMS_PER_PAGE,
         raise_errors: bool = False,
         start: Optional[str] = None,
         end: Optional[str] = None,
@@ -1138,20 +1183,22 @@ class EODataAccessGateway:
         locations: Optional[dict[str, str]] = None,
         provider: Optional[str] = None,
         count: bool = False,
+        validate: Optional[bool] = True,
         **kwargs: Any,
     ) -> SearchResult:
         """Look for products matching criteria on known providers.
 
         The default behaviour is to look for products on the provider with the
-        highest priority supporting the requested product type. These priorities
+        highest priority supporting the requested collection. These priorities
         are configurable through user configuration file or individual environment variable.
         If the request to the provider with the highest priority fails or is empty, the data
         will be request from the provider with the next highest priority.
         Only if the request fails for all available providers, an error will be thrown.
 
-        :param page: (optional) The page number to return
+        :param page: (optional) The page number to return (**deprecated**, use
+                     :meth:`eodag.api.search_result.SearchResult.next_page` instead)
         :param items_per_page: (optional) The number of results that must appear in one single
-                               page
+                               page. If ``None``, the maximum number possible will be used.
         :param raise_errors:  (optional) When an error occurs when searching, if this is set to
                               True, the error is raised
         :param start: (optional) Start sensing time in ISO 8601 format (e.g. "1990-11-26",
@@ -1178,9 +1225,11 @@ class EODataAccessGateway:
                          If not set, the configured preferred provider will be used at first
                          before trying others until finding results.
         :param count: (optional) Whether to run a query with a count request or not
+        :param validate: (optional) Set to True to validate search parameters
+                         before sending the query to the provider
         :param kwargs: Some other criteria that will be used to do the search,
                        using paramaters compatibles with the provider
-        :returns: A collection of EO products matching the criteria
+        :returns: A set of EO products matching the criteria
 
         .. versionchanged:: v3.0.0b1
             ``search()`` method now returns only a single :class:`~eodag.api.search_result.SearchResult`
@@ -1191,6 +1240,15 @@ class EODataAccessGateway:
             return a list as a result of their processing. This requirement is
             enforced here.
         """
+        if page != DEFAULT_PAGE:
+            warnings.warn(
+                "Usage of deprecated search parameter 'page' "
+                "(Please use 'SearchResult.next_page()' instead)"
+                " -- Deprecated since v3.9.0",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
         search_plugins, search_kwargs = self._prepare_search(
             start=start,
             end=end,
@@ -1200,28 +1258,38 @@ class EODataAccessGateway:
             **kwargs,
         )
         if search_kwargs.get("id"):
+            # Don't validate requests by ID. "id" is not queryable.
             return self._search_by_id(
                 search_kwargs.pop("id"),
                 provider=provider,
                 raise_errors=raise_errors,
+                validate=False,
                 **search_kwargs,
             )
         # remove datacube query string from kwargs which was only needed for search-by-id
         search_kwargs.pop("_dc_qs", None)
-
-        search_kwargs.update(
-            page=page,
-            items_per_page=items_per_page,
-        )
+        # add page parameter
+        search_kwargs["page"] = page
 
         errors: list[tuple[str, Exception]] = []
         # Loop over available providers and return the first non-empty results
         for i, search_plugin in enumerate(search_plugins):
             search_plugin.clear()
+
+            # add appropriate items_per_page value
+            search_kwargs["items_per_page"] = (
+                items_per_page
+                if items_per_page is not None
+                else getattr(search_plugin.config, "pagination", {}).get(
+                    "max_items_per_page", DEFAULT_MAX_ITEMS_PER_PAGE
+                )
+            )
+
             search_results = self._do_search(
                 search_plugin,
                 count=count,
                 raise_errors=raise_errors,
+                validate=validate,
                 **search_kwargs,
             )
             errors.extend(search_results.errors)
@@ -1232,12 +1300,22 @@ class EODataAccessGateway:
                 )
             elif len(search_results) > 0:
                 search_results.errors = errors
+                if count and search_results.number_matched:
+                    logger.info(
+                        "Found %s result(s) on provider '%s'",
+                        search_results.number_matched,
+                        search_results[0].provider,
+                    )
                 return search_results
 
         if i > 1:
             logger.error("No result could be obtained from any available provider")
         return SearchResult([], 0, errors) if count else SearchResult([], errors=errors)
 
+    @_deprecated(
+        reason="Please use 'SearchResult.next_page()' instead",
+        version="v3.9.0",
+    )
     def search_iter_page(
         self,
         items_per_page: int = DEFAULT_ITEMS_PER_PAGE,
@@ -1249,6 +1327,9 @@ class EODataAccessGateway:
     ) -> Iterator[SearchResult]:
         """Iterate over the pages of a products search.
 
+        .. deprecated:: v3.9.0
+            Please use :meth:`eodag.api.search_result.SearchResult.next_page` instead.
+
         :param items_per_page: (optional) The number of results requested per page
         :param start: (optional) Start sensing time in ISO 8601 format (e.g. "1990-11-26",
                       "1990-11-26T14:30:10.153Z", "1990-11-26T14:30:10+02:00", ...).
@@ -1272,7 +1353,7 @@ class EODataAccessGateway:
                           name=country and attr=ISO3
         :param kwargs: Some other criteria that will be used to do the search,
                        using paramaters compatibles with the provider
-        :returns: An iterator that yields page per page a collection of EO products
+        :returns: An iterator that yields page per page a set of EO products
                   matching the criteria
         """
         search_plugins, search_kwargs = self._prepare_search(
@@ -1299,6 +1380,10 @@ class EODataAccessGateway:
                     raise
         raise RequestError("No result could be obtained from any available provider")
 
+    @_deprecated(
+        reason="Please use 'SearchResult.next_page()' instead",
+        version="v3.9.0",
+    )
     def search_iter_page_plugin(
         self,
         search_plugin: Union[Search, Api],
@@ -1307,121 +1392,50 @@ class EODataAccessGateway:
     ) -> Iterator[SearchResult]:
         """Iterate over the pages of a products search using a given search plugin.
 
+        .. deprecated:: v3.9.0
+            Please use :meth:`eodag.api.search_result.SearchResult.next_page` instead.
+
         :param items_per_page: (optional) The number of results requested per page
         :param kwargs: Some other criteria that will be used to do the search,
                        using parameters compatibles with the provider
         :param search_plugin: search plugin to be used
-        :returns: An iterator that yields page per page a collection of EO products
+        :returns: An iterator that yields page per page a set of EO products
                   matching the criteria
         """
-
-        iteration = 1
-        # Store the search plugin config pagination.next_page_url_tpl to reset it later
-        # since it might be modified if the next_page_url mechanism is used by the
-        # plugin. (same thing for next_page_query_obj, next_page_query_obj with POST reqs)
-        pagination_config = getattr(search_plugin.config, "pagination", {})
-        prev_next_page_url_tpl = pagination_config.get("next_page_url_tpl")
-        prev_next_page_query_obj = pagination_config.get("next_page_query_obj")
-        # Page has to be set to a value even if use_next is True, this is required
-        # internally by the search plugin (see collect_search_urls)
         kwargs.update(
             page=1,
             items_per_page=items_per_page,
         )
-        prev_product = None
-        next_page_url = None
-        next_page_query_obj = None
-        number_matched = None
-        while True:
-            # if count is enabled, it will only be performed on 1st iteration
-            if iteration == 2:
-                kwargs["count"] = False
-            if iteration > 1 and next_page_url:
-                pagination_config["next_page_url_tpl"] = next_page_url
-            if iteration > 1 and next_page_query_obj:
-                pagination_config["next_page_query_obj"] = next_page_query_obj
-            logger.info("Iterate search over multiple pages: page #%s", iteration)
-            try:
-                # remove unwanted kwargs for _do_search
-                kwargs.pop("raise_errors", None)
-                search_result = self._do_search(
-                    search_plugin, raise_errors=True, **kwargs
-                )
-                # if count is enabled, it will only be performed on 1st iteration
-                if iteration == 1:
-                    number_matched = search_result.number_matched
-            except Exception:
-                logger.warning(
-                    "error at retrieval of data from %s, for params: %s",
-                    search_plugin.provider,
-                    str(kwargs),
-                )
-                raise
-            finally:
-                # we don't want that next(search_iter_page(...)) modifies the plugin
-                # indefinitely. So we reset after each request, but before the generator
-                # yields, the attr next_page_url (to None) and
-                # config.pagination["next_page_url_tpl"] (to its original value).
-                next_page_url = getattr(search_plugin, "next_page_url", None)
-                next_page_query_obj = getattr(search_plugin, "next_page_query_obj", {})
-                next_page_merge = getattr(search_plugin, "next_page_merge", None)
-
-                if next_page_url:
-                    search_plugin.next_page_url = None
-                    if prev_next_page_url_tpl:
-                        search_plugin.config.pagination[
-                            "next_page_url_tpl"
-                        ] = prev_next_page_url_tpl
-                if next_page_query_obj:
-                    if prev_next_page_query_obj:
-                        search_plugin.config.pagination[
-                            "next_page_query_obj"
-                        ] = prev_next_page_query_obj
-                    # Update next_page_query_obj for next page req
-                    if next_page_merge:
-                        search_plugin.next_page_query_obj = dict(
-                            getattr(search_plugin, "query_params", {}),
-                            **next_page_query_obj,
-                        )
-                    else:
-                        search_plugin.next_page_query_obj = next_page_query_obj
-
-            if len(search_result) > 0:
-                # The first products between two iterations are compared. If they
-                # are actually the same product, it means the iteration failed at
-                # progressing for some reason. This is implemented as a workaround
-                # to some search plugins/providers not handling pagination.
-                product = search_result[0]
-                if (
-                    prev_product
-                    and product.properties["id"] == prev_product.properties["id"]
-                    and product.provider == prev_product.provider
-                ):
-                    logger.warning(
-                        "Iterate over pages: stop iterating since the next page "
-                        "appears to have the same products as in the previous one. "
-                        "This provider may not implement pagination.",
-                    )
-                    last_page_with_products = iteration - 1
-                    break
-                # use count got from 1st iteration
-                search_result.number_matched = number_matched
-                yield search_result
-                prev_product = product
-                # Prevent a last search if the current one returned less than the
-                # maximum number of items asked for.
-                if len(search_result) < items_per_page:
-                    last_page_with_products = iteration
-                    break
-            else:
-                last_page_with_products = iteration - 1
+        try:
+            # remove unwanted kwargs for _do_search
+            kwargs.pop("raise_errors", None)
+            search_result = self._do_search(search_plugin, raise_errors=True, **kwargs)
+            search_result.raise_errors = True
+
+        except Exception:
+            logger.warning(
+                "error at retrieval of data from %s, for params: %s",
+                search_plugin.provider,
+                str(kwargs),
+            )
+            raise
+
+        if len(search_result) == 0:
+            return
+        # remove unwanted kwargs for next_page
+        if kwargs.get("count") is True:
+            kwargs["count"] = False
+        kwargs.pop("page", None)
+        search_result.search_params = kwargs
+        if search_result._dag is None:
+            search_result._dag = self
+
+        yield search_result
+
+        for next_result in search_result.next_page():
+            if len(next_result) == 0:
                 break
-            iteration += 1
-            kwargs["page"] = iteration
-        logger.debug(
-            "Iterate over pages: last products found on page %s",
-            last_page_with_products,
-        )
+            yield next_result
 
     def search_all(
         self,
@@ -1471,84 +1485,45 @@ class EODataAccessGateway:
                           name=country and attr=ISO3
         :param kwargs: Some other criteria that will be used to do the search,
                        using parameters compatible with the provider
-        :returns: An iterator that yields page per page a collection of EO products
+        :returns: An iterator that yields page per page a set of EO products
                   matching the criteria
         """
-        # Get the search plugin and the maximized value
-        # of items_per_page if defined for the provider used.
-        try:
-            product_type = self.get_product_type_from_alias(
-                self.guess_product_type(**kwargs)[0]
-            )
-        except NoMatchingProductType:
-            product_type = GENERIC_PRODUCT_TYPE
-        else:
-            # fetch product types list if product_type is unknown
-            if (
-                product_type
-                not in self._plugins_manager.product_type_to_provider_config_map.keys()
-            ):
-                logger.debug(
-                    f"Fetching external product types sources to find {product_type} product type"
-                )
-                self.fetch_product_types_list()
-
         # remove unwanted count
         kwargs.pop("count", None)
 
-        search_plugins, search_kwargs = self._prepare_search(
-            start=start, end=end, geom=geom, locations=locations, **kwargs
+        # First search
+        search_results = self.search(
+            items_per_page=items_per_page,
+            start=start,
+            end=end,
+            geom=geom,
+            locations=locations,
+            **kwargs,
         )
-        for i, search_plugin in enumerate(search_plugins):
-            itp = (
-                items_per_page
-                or getattr(search_plugin.config, "pagination", {}).get(
-                    "max_items_per_page"
-                )
-                or DEFAULT_MAX_ITEMS_PER_PAGE
-            )
+        if len(search_results) == 0:
+            return search_results
+
+        try:
+            search_results.raise_errors = True
+
+            # consume iterator
+            deque(search_results.next_page(update=True))
+
             logger.info(
-                "Searching for all the products with provider %s and a maximum of %s "
-                "items per page.",
-                search_plugin.provider,
-                itp,
+                "Found %s result(s) on provider '%s'",
+                len(search_results),
+                search_results[0].provider,
+            )
+            search_results.number_matched = len(search_results)
+        except RequestError:
+            logger.warning(
+                "Found %s result(s) on provider '%s', but it may be incomplete "
+                "as it ended with an error",
+                len(search_results),
+                search_results[0].provider,
             )
-            all_results = SearchResult([])
-            try:
-                for page_results in self.search_iter_page_plugin(
-                    items_per_page=itp,
-                    search_plugin=search_plugin,
-                    count=False,
-                    **search_kwargs,
-                ):
-                    all_results.data.extend(page_results.data)
-                logger.info(
-                    "Found %s result(s) on provider '%s'",
-                    len(all_results),
-                    search_plugin.provider,
-                )
-                return all_results
-            except RequestError:
-                if len(all_results) == 0 and i < len(search_plugins) - 1:
-                    logger.warning(
-                        "No result could be obtained from provider %s, "
-                        "we will try to get the data from another provider",
-                        search_plugin.provider,
-                    )
-                elif len(all_results) == 0:
-                    logger.error(
-                        "No result could be obtained from any available provider"
-                    )
-                    raise
-                elif len(all_results) > 0:
-                    logger.warning(
-                        "Found %s result(s) on provider '%s', but it may be incomplete "
-                        "as it ended with an error",
-                        len(all_results),
-                        search_plugin.provider,
-                    )
-                    return all_results
-        raise RequestError("No result could be obtained from any available provider")
+
+        return search_results
 
     def _search_by_id(
         self, uid: str, provider: Optional[str] = None, **kwargs: Any
@@ -1571,13 +1546,13 @@ class EODataAccessGateway:
         :param kwargs: Search criteria to help finding the right product
         :returns: A search result with one EO product or None at all
         """
-        product_type = kwargs.get("productType")
-        if product_type is not None:
+        collection = kwargs.get("collection")
+        if collection is not None:
             try:
-                product_type = self.get_product_type_from_alias(product_type)
-            except NoMatchingProductType:
-                logger.debug("product type %s not found", product_type)
-        get_search_plugins_kwargs = dict(provider=provider, product_type=product_type)
+                collection = self.get_collection_from_alias(collection)
+            except NoMatchingCollection:
+                logger.debug("collection %s not found", collection)
+        get_search_plugins_kwargs = dict(provider=provider, collection=collection)
         search_plugins = self._plugins_manager.get_search_plugins(
             **get_search_plugins_kwargs
         )
@@ -1632,10 +1607,10 @@ class EODataAccessGateway:
                 results = filtered
 
             if len(results) == 1:
-                if not results[0].product_type:
-                    # guess product type from properties
-                    guesses = self.guess_product_type(**results[0].properties)
-                    results[0].product_type = guesses[0]
+                if not results[0].collection:
+                    # guess collection from properties
+                    guesses = self.guess_collection(**results[0].properties)
+                    results[0].collection = guesses[0].id
                     # reset driver
                     results[0].driver = results[0].get_driver()
                 results.number_matched = 1
@@ -1647,15 +1622,15 @@ class EODataAccessGateway:
                 )
         return SearchResult([], 0, results.errors)
 
-    def _fetch_external_product_type(self, provider: str, product_type: str):
+    def _fetch_external_collection(self, provider: str, collection: str):
         plugins = self._plugins_manager.get_search_plugins(provider=provider)
         plugin = next(plugins)
 
         # check after plugin init if still fetchable
-        if not getattr(plugin.config, "discover_product_types", {}).get("fetch_url"):
+        if not getattr(plugin.config, "discover_collections", {}).get("fetch_url"):
             return None
 
-        kwargs: dict[str, Any] = {"productType": product_type}
+        kwargs: dict[str, Any] = {"collection": collection}
 
         # append auth if needed
         if getattr(plugin.config, "need_auth", False):
@@ -1666,8 +1641,8 @@ class EODataAccessGateway:
             ):
                 kwargs["auth"] = auth
 
-        product_type_config = plugin.discover_product_types(**kwargs)
-        self.update_product_types_list({provider: product_type_config})
+        collection_config = plugin.discover_collections(**kwargs)
+        self.update_collections_list({provider: collection_config})
 
     def _prepare_search(
         self,
@@ -1683,9 +1658,9 @@ class EODataAccessGateway:
         Product query:
           * By id (plus optional 'provider')
           * By search params:
-            * productType query:
-              * By product type (e.g. 'S2_MSI_L1C')
-              * By params (e.g. 'platform'), see guess_product_type
+            * collection query:
+              * By collection (e.g. 'S2_MSI_L1C')
+              * By params (e.g. 'platform'), see guess_collection
             * dates: 'start' and/or 'end'
             * geometry: 'geom' or 'bbox' or 'box'
             * search locations
@@ -1700,53 +1675,53 @@ class EODataAccessGateway:
                     If no time offset is given, the time is assumed to be given in UTC.
         :param geom: (optional) Search area that can be defined in different ways (see search)
         :param locations: (optional) Location filtering by name using locations configuration
-        :param provider: provider to be used, if no provider is given or the product type
+        :param provider: provider to be used, if no provider is given or the collection
                         is not available for the provider, the preferred provider is used
         :param kwargs: Some other criteria
                        * id and/or a provider for a search by
-                       * search criteria to guess the product type
+                       * search criteria to guess the collection
                        * other criteria compatible with the provider
         :returns: Search plugins list and the prepared kwargs to make a query.
         """
-        product_type: Optional[str] = kwargs.get("productType")
-        if product_type is None:
+        collection: Optional[str] = kwargs.get("collection")
+        if collection is None:
             try:
-                guesses = self.guess_product_type(**kwargs)
+                guesses = self.guess_collection(**kwargs)
 
-                # guess_product_type raises a NoMatchingProductType error if no product
+                # guess_collection raises a NoMatchingCollection error if no product
                 # is found. Here, the supported search params are removed from the
                 # kwargs if present, not to propagate them to the query itself.
                 for param in (
-                    "instrument",
+                    "instruments",
+                    "constellation",
                     "platform",
-                    "platformSerialIdentifier",
-                    "processingLevel",
-                    "sensorType",
+                    "processing:level",
+                    "eodag:sensor_type",
                 ):
                     kwargs.pop(param, None)
 
                 # By now, only use the best bet
-                product_type = guesses[0]
-            except NoMatchingProductType:
+                collection = guesses[0].id
+            except NoMatchingCollection:
                 queried_id = kwargs.get("id")
                 if queried_id is None:
                     logger.info(
-                        "No product type could be guessed with provided arguments"
+                        "No collection could be guessed with provided arguments"
                     )
                 else:
                     return [], kwargs
 
-        if product_type is not None:
+        if collection is not None:
             try:
-                product_type = self.get_product_type_from_alias(product_type)
-            except NoMatchingProductType:
-                logger.info("unknown product type " + product_type)
-        kwargs["productType"] = product_type
+                collection = self.get_collection_from_alias(collection)
+            except NoMatchingCollection:
+                logger.info("unknown collection " + collection)
+        kwargs["collection"] = collection
 
         if start is not None:
-            kwargs["startTimeFromAscendingNode"] = start
+            kwargs["start_datetime"] = start
         if end is not None:
-            kwargs["completionTimeFromAscendingNode"] = end
+            kwargs["end_datetime"] = end
         if "box" in kwargs or "bbox" in kwargs:
             logger.warning(
                 "'box' or 'bbox' parameters are only supported for backwards "
@@ -1767,33 +1742,44 @@ class EODataAccessGateway:
             kwargs.pop(arg, None)
         del kwargs["locations"]
 
-        # fetch product types list if product_type is unknown
+        # fetch collections list if collection is unknown
         if (
-            product_type
-            not in self._plugins_manager.product_type_to_provider_config_map.keys()
+            collection
+            not in self._plugins_manager.collection_to_provider_config_map.keys()
         ):
-            if provider and product_type:
-                # Try to get specific product type from external provider
-                logger.debug(f"Fetching {provider} to find {product_type} product type")
-                self._fetch_external_product_type(provider, product_type)
+            if provider and collection:
+                # fetch ref for given provider and collection
+                logger.debug(
+                    f"Fetching external collections sources to find {provider} {collection} collection"
+                )
+                self.fetch_collections_list(provider)
+                if (
+                    collection
+                    not in self._plugins_manager.collection_to_provider_config_map.keys()
+                ):
+                    # Try to get specific collection from external provider
+                    logger.debug(
+                        "Fetching %s to find %s collection", provider, collection
+                    )
+                    self._fetch_external_collection(provider, collection)
             if not provider:
-                # no provider or still not found -> fetch all external product types
+                # no provider or still not found -> fetch all external collections
                 logger.debug(
-                    f"Fetching external product types sources to find {product_type} product type"
+                    f"Fetching external collections sources to find {collection} collection"
                 )
-                self.fetch_product_types_list()
+                self.fetch_collections_list()
 
         preferred_provider = self.get_preferred_provider()[0]
 
         search_plugins: list[Union[Search, Api]] = []
         for plugin in self._plugins_manager.get_search_plugins(
-            product_type=product_type, provider=provider
+            collection=collection, provider=provider
         ):
-            # exclude MeteoblueSearch plugins from search fallback for unknown product_type
+            # exclude MeteoblueSearch plugins from search fallback for unknown collection
             if (
                 provider != plugin.provider
                 and preferred_provider != plugin.provider
-                and product_type not in self.product_types_config
+                and collection not in self.collections_config
                 and isinstance(plugin, MeteoblueSearch)
             ):
                 continue
@@ -1804,8 +1790,8 @@ class EODataAccessGateway:
         providers = [plugin.provider for plugin in search_plugins]
         if provider not in providers:
             logger.debug(
-                "Product type '%s' is not available with preferred provider '%s'.",
-                product_type,
+                "Collection '%s' is not available with preferred provider '%s'.",
+                collection,
                 provider,
             )
         else:
@@ -1814,11 +1800,11 @@ class EODataAccessGateway:
             )[0]
             search_plugins.remove(provider_plugin)
             search_plugins.insert(0, provider_plugin)
-        # Add product_types_config to plugin config. This dict contains product
+        # Add collections_config to plugin config. This dict contains product
         # type metadata that will also be stored in each product's properties.
         for search_plugin in search_plugins:
-            if product_type is not None:
-                self._attach_product_type_config(search_plugin, product_type)
+            if collection is not None:
+                self._attach_collection_config(search_plugin, collection)
 
         return search_plugins, kwargs
 
@@ -1827,6 +1813,7 @@ class EODataAccessGateway:
         search_plugin: Union[Search, Api],
         count: bool = False,
         raise_errors: bool = False,
+        validate: Optional[bool] = True,
         **kwargs: Any,
     ) -> SearchResult:
         """Internal method that performs a search on a given provider.
@@ -1836,6 +1823,8 @@ class EODataAccessGateway:
         :param raise_errors: (optional) When an error occurs when searching, if this is set to
                              True, the error is raised
         :param kwargs: Some other criteria that will be used to do the search
+        :param validate: (optional) Set to True to validate search parameters
+                         before sending the query to the provider
         :returns: A collection of EO products matching the criteria
         """
         logger.info("Searching on provider %s", search_plugin.provider)
@@ -1856,13 +1845,11 @@ class EODataAccessGateway:
                 max_items_per_page,
             )
 
-        results: list[EOProduct] = []
-        total_results: Optional[int] = 0 if count else None
-
         errors: list[tuple[str, Exception]] = []
 
         try:
             prep = PreparedSearch(count=count)
+            prep.raise_errors = raise_errors
 
             # append auth if needed
             if getattr(search_plugin.config, "need_auth", False):
@@ -1873,17 +1860,57 @@ class EODataAccessGateway:
                 ):
                     prep.auth = auth
 
-            prep.page = kwargs.pop("page", None)
             prep.items_per_page = kwargs.pop("items_per_page", None)
+            prep.next_page_token = kwargs.pop("next_page_token", None)
+            prep.next_page_token_key = kwargs.pop(
+                "next_page_token_key", None
+            ) or search_plugin.config.pagination.get("next_page_token_key", "page")
+            prep.page = kwargs.pop("page", None)
 
-            res, nb_res = search_plugin.query(prep, **kwargs)
+            if (
+                prep.next_page_token_key == "page"
+                and prep.items_per_page is not None
+                and prep.next_page_token is None
+                and prep.page is not None
+            ):
+                prep.next_page_token = str(
+                    prep.page
+                    - 1
+                    + search_plugin.config.pagination.get("start_page", DEFAULT_PAGE)
+                )
+
+            # remove None values and convert param names to their pydantic alias if any
+            search_params = {}
+            ecmwf_queryables = [
+                f"{ECMWF_PREFIX[:-1]}_{k}" for k in ECMWF_ALLOWED_KEYWORDS
+            ]
+            for param, value in kwargs.items():
+                if value is None:
+                    continue
+                if param in Queryables.model_fields:
+                    param_alias = Queryables.model_fields[param].alias or param
+                    search_params[param_alias] = value
+                elif param in ecmwf_queryables:
+                    # alias equivalent for ECMWF queryables
+                    search_params[
+                        re.sub(rf"^{ECMWF_PREFIX[:-1]}_", f"{ECMWF_PREFIX}", param)
+                    ] = value
+                else:
+                    # remove `provider:` or `provider_` prefix if any
+                    search_params[
+                        re.sub(r"^" + search_plugin.provider + r"[_:]", "", param)
+                    ] = value
+
+            if validate:
+                search_plugin.validate(search_params, prep.auth)
 
-            if not isinstance(res, list):
+            search_result = search_plugin.query(prep, **search_params)
+
+            if not isinstance(search_result.data, list):
                 raise PluginImplementationError(
                     "The query function of a Search plugin must return a list of "
-                    "results, got {} instead".format(type(res))
+                    "results, got {} instead".format(type(search_result.data))
                 )
-
             # Filter and attach to each eoproduct in the result the plugin capable of
             # downloading it (this is done to enable the eo_product to download itself
             # doing: eo_product.download()). The filtering is done by keeping only
@@ -1893,56 +1920,51 @@ class EODataAccessGateway:
             # WARNING: this means an eo_product that has an invalid geometry can still
             # be returned as a search result if there was no search extent (because we
             # will not try to do an intersection)
-            for eo_product in res:
-                # if product_type is not defined, try to guess using properties
-                if eo_product.product_type is None:
+            for eo_product in search_result.data:
+                # if collection is not defined, try to guess using properties
+                if eo_product.collection is None:
                     pattern = re.compile(r"[^\w,]+")
                     try:
-                        guesses = self.guess_product_type(
+                        guesses = self.guess_collection(
                             intersect=False,
                             **{
                                 k: pattern.sub("", str(v).upper())
                                 for k, v in eo_product.properties.items()
                                 if k
                                 in [
-                                    "instrument",
+                                    "instruments",
+                                    "constellation",
                                     "platform",
-                                    "platformSerialIdentifier",
-                                    "processingLevel",
-                                    "sensorType",
+                                    "processing:level",
+                                    "eodag:sensor_type",
                                     "keywords",
                                 ]
                                 and v is not None
                             },
                         )
-                    except NoMatchingProductType:
+                    except NoMatchingCollection:
                         pass
                     else:
-                        eo_product.product_type = guesses[0]
+                        eo_product.collection = guesses[0].id
 
                 try:
-                    if eo_product.product_type is not None:
-                        eo_product.product_type = self.get_product_type_from_alias(
-                            eo_product.product_type
+                    if eo_product.collection is not None:
+                        eo_product.collection = self.get_collection_from_alias(
+                            eo_product.collection
                         )
-                except NoMatchingProductType:
-                    logger.debug("product type %s not found", eo_product.product_type)
+                except NoMatchingCollection:
+                    logger.debug("collection %s not found", eo_product.collection)
 
                 if eo_product.search_intersection is not None:
                     eo_product._register_downloader_from_manager(self._plugins_manager)
 
-            results.extend(res)
-            total_results = (
-                None
-                if (nb_res is None or total_results is None)
-                else total_results + nb_res
-            )
-            if count and nb_res is not None:
-                logger.info(
-                    "Found %s result(s) on provider '%s'",
-                    nb_res,
-                    search_plugin.provider,
-                )
+            # Make next_page not available if the current one returned less than the maximum number of items asked for.
+            if not prep.items_per_page or len(search_result) < prep.items_per_page:
+                search_result.next_page_token = None
+
+            search_result._dag = self
+            return search_result
+
         except Exception as e:
             if raise_errors:
                 # Raise the error, letting the application wrapping eodag know that
@@ -1954,7 +1976,7 @@ class EODataAccessGateway:
                     search_plugin.provider,
                 )
                 errors.append((search_plugin.provider, e))
-        return SearchResult(results, total_results, errors)
+                return SearchResult([], 0, errors)
 
     def crunch(self, results: SearchResult, **kwargs: Any) -> SearchResult:
         """Apply the filters given through the keyword arguments to the results
@@ -2005,7 +2027,7 @@ class EODataAccessGateway:
     ) -> list[str]:
         """Download all products resulting from a search.
 
-        :param search_result: A collection of EO products resulting from a search
+        :param search_result: A set of EO products resulting from a search
         :param downloaded_callback: (optional) A method or a callable object which takes
                                     as parameter the ``product``. You can use the base class
                                     :class:`~eodag.utils.DownloadedCallback` and override
@@ -2058,13 +2080,16 @@ class EODataAccessGateway:
         search_result: SearchResult, filename: str = "search_results.geojson"
     ) -> str:
         """Registers results of a search into a geojson file.
+        The output is a FeatureCollection containing the EO products as features,
+        with additional metadata such as ``number_matched``, ``next_page_token``,
+        and ``search_params`` stored in the properties.
 
-        :param search_result: A collection of EO products resulting from a search
+        :param search_result: A set of EO products resulting from a search
         :param filename: (optional) The name of the file to generate
         :returns: The name of the created file
         """
         with open(filename, "w") as fh:
-            geojson.dump(search_result, fh)
+            geojson.dump(search_result.as_geojson_object(), fh)
         return filename
 
     @staticmethod
@@ -2079,12 +2104,16 @@ class EODataAccessGateway:
 
     def deserialize_and_register(self, filename: str) -> SearchResult:
         """Loads results of a search from a geojson file and register
-        products with the information needed to download itself
+        products with the information needed to download itself.
+
+        This method also sets the internal EODataAccessGateway instance on the products,
+        enabling pagination (e.g. access to next pages) if available.
 
         :param filename: A filename containing a search result encoded as a geojson
-        :returns: The search results encoded in `filename`
+        :returns: The search results encoded in `filename`, ready for download and pagination
         """
         products = self.deserialize(filename)
+        products._dag = self
         for i, product in enumerate(products):
             if product.downloader is None:
                 downloader = self._plugins_manager.get_download_plugin(product)
@@ -2095,69 +2124,6 @@ class EODataAccessGateway:
 
         return products
 
-    @_deprecated(
-        reason="Use the StaticStacSearch search plugin instead", version="2.2.1"
-    )
-    def load_stac_items(
-        self,
-        filename: str,
-        recursive: bool = False,
-        max_connections: int = 100,
-        provider: Optional[str] = None,
-        productType: Optional[str] = None,
-        timeout: int = HTTP_REQ_TIMEOUT,
-        ssl_verify: bool = True,
-        **kwargs: Any,
-    ) -> SearchResult:
-        """Loads STAC items from a geojson file / STAC catalog or collection, and convert to SearchResult.
-
-        Features are parsed using eodag provider configuration, as if they were
-        the response content to an API request.
-
-        :param filename: A filename containing features encoded as a geojson
-        :param recursive: (optional) Browse recursively in child nodes if True
-        :param max_connections: (optional) Maximum number of connections for concurrent HTTP requests
-        :param provider: (optional) Data provider
-        :param productType: (optional) Data product type
-        :param timeout: (optional) Timeout in seconds for each internal HTTP request
-        :param kwargs: Parameters that will be stored in the result as
-                       search criteria
-        :returns: The search results encoded in `filename`
-
-        .. deprecated:: 2.2.1
-           Use the :class:`~eodag.plugins.search.static_stac_search.StaticStacSearch` search plugin instead.
-        """
-        features = fetch_stac_items(
-            filename,
-            recursive=recursive,
-            max_connections=max_connections,
-            timeout=timeout,
-            ssl_verify=ssl_verify,
-        )
-        feature_collection = geojson.FeatureCollection(features)
-
-        plugin = next(
-            self._plugins_manager.get_search_plugins(
-                product_type=productType, provider=provider
-            )
-        )
-        # save plugin._request and mock it to make return loaded static results
-        plugin_request = plugin._request
-        plugin._request = (
-            lambda url, info_message=None, exception_message=None: MockResponse(
-                feature_collection, 200
-            )
-        )
-
-        search_result = self.search(
-            productType=productType, provider=provider, **kwargs
-        )
-
-        # restore plugin._request
-        plugin._request = plugin_request
-
-        return search_result
-
     def download(
         self,
         product: EOProduct,
@@ -2173,16 +2139,16 @@ class EODataAccessGateway:
         checks like verifying that a downloader and authenticator are registered
         for the product before trying to download it.
 
-        If the metadata mapping for ``downloadLink`` is set to something that can be
+        If the metadata mapping for ``eodag:download_link`` is set to something that can be
         interpreted as a link on a
         local filesystem, the download is skipped (by now, only a link starting
         with ``file:/`` is supported). Therefore, any user that knows how to extract
         product location from product metadata on a provider can override the
-        ``downloadLink`` metadata mapping in the right way. For example, using the
+        ``eodag:download_link`` metadata mapping in the right way. For example, using the
         environment variable:
-        ``EODAG__CREODIAS__SEARCH__METADATA_MAPPING__DOWNLOADLINK="file:///{id}"`` will
+        ``EODAG__CREODIAS__SEARCH__METADATA_MAPPING__EODAG_DOWNLOAD_LINK="file:///{id}"`` will
         lead to all :class:`~eodag.api.product._product.EOProduct`'s originating from the
-        provider ``creodias`` to have their ``downloadLink`` metadata point to something like:
+        provider ``creodias`` to have their ``eodag:download_link`` metadata point to something like:
         ``file:///12345-678``, making this method immediately return the later string without
         trying to download the product.
 
@@ -2246,46 +2212,46 @@ class EODataAccessGateway:
         fetch_providers: bool = True,
         **kwargs: Any,
     ) -> QueryablesDict:
-        """Fetch the queryable properties for a given product type and/or provider.
+        """Fetch the queryable properties for a given collection and/or provider.
 
         :param provider: (optional) The provider.
-        :param fetch_providers: If new product types should be fetched from the providers; default: True
-        :param kwargs: additional filters for queryables (`productType` or other search
+        :param fetch_providers: If new collections should be fetched from the providers; default: True
+        :param kwargs: additional filters for queryables (`collection` or other search
                        arguments)
 
-        :raises UnsupportedProductType: If the specified product type is not available for the
+        :raises UnsupportedCollection: If the specified collection is not available for the
                                         provider.
 
         :returns: A :class:`~eodag.api.product.queryables.QuerybalesDict` containing the EODAG queryable
                   properties, associating parameters to their annotated type, and a additional_properties attribute
         """
-        # only fetch providers if product type is not found
-        available_product_types: list[str] = [
-            pt["ID"]
-            for pt in self.list_product_types(provider=provider, fetch_providers=False)
+        # only fetch providers if collection is not found
+        available_collections: list[str] = [
+            col.id
+            for col in self.list_collections(provider=provider, fetch_providers=False)
         ]
-        product_type: Optional[str] = kwargs.get("productType")
-        pt_alias: Optional[str] = product_type
+        collection: Optional[str] = kwargs.get("collection")
+        coll_alias: Optional[str] = collection
 
-        if product_type:
-            if product_type not in available_product_types:
+        if collection:
+            if collection not in available_collections:
                 if fetch_providers:
                     # fetch providers and try again
-                    available_product_types = [
-                        pt["ID"]
-                        for pt in self.list_product_types(
+                    available_collections = [
+                        col.id
+                        for col in self.list_collections(
                             provider=provider, fetch_providers=True
                         )
                     ]
-                raise UnsupportedProductType(f"{product_type} is not available.")
+                raise UnsupportedCollection(f"{collection} is not available.")
             try:
-                kwargs["productType"] = product_type = self.get_product_type_from_alias(
-                    product_type
+                kwargs["collection"] = collection = self.get_collection_from_alias(
+                    collection
                 )
-            except NoMatchingProductType as e:
-                raise UnsupportedProductType(f"{product_type} is not available.") from e
+            except NoMatchingCollection as e:
+                raise UnsupportedCollection(f"{collection} is not available.") from e
 
-        if not provider and not product_type:
+        if not provider and not collection:
             return QueryablesDict(
                 additional_properties=True,
                 **model_fields_to_annotated(CommonQueryables.model_fields),
@@ -2295,16 +2261,16 @@ class EODataAccessGateway:
         additional_information = []
         queryable_properties: dict[str, Any] = {}
 
-        for plugin in self._plugins_manager.get_search_plugins(product_type, provider):
-            # attach product type config
-            product_type_configs: dict[str, Any] = {}
-            if product_type:
-                self._attach_product_type_config(plugin, product_type)
-                product_type_configs[product_type] = plugin.config.product_type_config
+        for plugin in self._plugins_manager.get_search_plugins(collection, provider):
+            # attach collection config
+            collection_configs: dict[str, Any] = {}
+            if collection:
+                self._attach_collection_config(plugin, collection)
+                collection_configs[collection] = plugin.config.collection_config
             else:
-                for pt in available_product_types:
-                    self._attach_product_type_config(plugin, pt)
-                    product_type_configs[pt] = plugin.config.product_type_config
+                for col in available_collections:
+                    self._attach_collection_config(plugin, col)
+                    collection_configs[col] = plugin.config.collection_config
 
             # authenticate if required
             if getattr(plugin.config, "need_auth", False) and (
@@ -2326,10 +2292,10 @@ class EODataAccessGateway:
 
             plugin_queryables = plugin.list_queryables(
                 kwargs_alias,
-                available_product_types,
-                product_type_configs,
-                product_type,
-                pt_alias,
+                available_collections,
+                collection_configs,
+                collection,
+                coll_alias,
             )
 
             if plugin_queryables.additional_information:
@@ -2379,32 +2345,31 @@ class EODataAccessGateway:
             }
         return sortables
 
-    def _attach_product_type_config(self, plugin: Search, product_type: str) -> None:
+    def _attach_collection_config(self, plugin: Search, collection: str) -> None:
         """
-        Attach product_types_config to plugin config. This dict contains product
+        Attach collections_config to plugin config. This dict contains product
         type metadata that will also be stored in each product's properties.
         """
         try:
-            plugin.config.product_type_config = dict(
+            plugin.config.collection_config = dict(
                 [
-                    p
-                    for p in self.list_product_types(
+                    c.model_dump(mode="json", exclude={"id"})
+                    for c in self.list_collections(
                         plugin.provider, fetch_providers=False
                     )
-                    if p["_id"] == product_type
+                    if c._id == collection
                 ][0],
-                **{"productType": product_type},
+                **{"collection": collection},
             )
-            # If the product isn't in the catalog, it's a generic product type.
+            # If the product isn't in the catalog, it's a generic collection.
         except IndexError:
-            # Construct the GENERIC_PRODUCT_TYPE metadata
-            plugin.config.product_type_config = dict(
-                ID=GENERIC_PRODUCT_TYPE,
-                **self.product_types_config[GENERIC_PRODUCT_TYPE],
-                productType=product_type,
+            # Construct the GENERIC_COLLECTION metadata
+            plugin.config.collection_config = dict(
+                **self.collections_config[GENERIC_COLLECTION].model_dump(
+                    mode="json", exclude={"id"}
+                ),
+                collection=collection,
             )
-        # Remove the ID since this is equal to productType.
-        plugin.config.product_type_config.pop("ID", None)
 
     def import_stac_items(self, items_urls: list[str]) -> SearchResult:
         """Import STAC items from a list of URLs and convert them to SearchResult.