eodag 3.0.1__py3-none-any.whl → 3.1.0__py3-none-any.whl

eodag/rest/stac.py

@@ -21,7 +21,7 @@ import logging
 import os
 from collections import defaultdict
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Optional
 from urllib.parse import (
     parse_qs,
     quote,
@@ -82,6 +82,8 @@ COLLECTION_PROPERTIES = [
     "missionEndDate",
     "keywords",
     "stacCollection",
+    "alias",
+    "productType",
 ]
 IGNORED_ITEM_PROPERTIES = [
     "_id",
@@ -95,6 +97,7 @@ IGNORED_ITEM_PROPERTIES = [
     "qs",
     "defaultGeometry",
     "_date",
+    "productType",
 ]
 
 
@@ -118,7 +121,7 @@ class StacCommon:
     def __init__(
         self,
         url: str,
-        stac_config: Dict[str, Any],
+        stac_config: dict[str, Any],
         provider: Optional[str],
         eodag_api: EODataAccessGateway,
         root: str = "/",
@@ -129,9 +132,9 @@ class StacCommon:
         self.eodag_api = eodag_api
         self.root = root.rstrip("/") if len(root) > 1 else root
 
-        self.data: Dict[str, Any] = {}
+        self.data: dict[str, Any] = {}
 
-    def update_data(self, data: Dict[str, Any]) -> None:
+    def update_data(self, data: dict[str, Any]) -> None:
         """Updates data using given input STAC dict data
 
         :param data: Catalog data (parsed STAC dict)
@@ -165,8 +168,8 @@ class StacCommon:
 
     @staticmethod
     def get_stac_extension(
-        url: str, stac_config: Dict[str, Any], extension: str, **kwargs: Any
-    ) -> Dict[str, str]:
+        url: str, stac_config: dict[str, Any], extension: str, **kwargs: Any
+    ) -> dict[str, str]:
         """Parse STAC extension from config and return as dict
 
         :param url: Requested URL
@@ -185,7 +188,7 @@ class StacCommon:
         }
         return format_dict_items(extension_model, **format_args)
 
-    def get_provider_dict(self, provider: str) -> Dict[str, Any]:
+    def get_provider_dict(self, provider: str) -> dict[str, Any]:
         """Generate STAC provider dict"""
         provider_config = next(
             p
@@ -214,7 +217,7 @@ class StacItem(StacCommon):
     def __init__(
         self,
         url: str,
-        stac_config: Dict[str, Any],
+        stac_config: dict[str, Any],
         provider: Optional[str],
         eodag_api: EODataAccessGateway,
         root: str = "/",
@@ -228,8 +231,8 @@ class StacItem(StacCommon):
         )
 
     def __get_item_list(
-        self, search_results: SearchResult, catalog: Dict[str, Any]
-    ) -> List[Dict[str, Any]]:
+        self, search_results: SearchResult, catalog: dict[str, Any]
+    ) -> list[dict[str, Any]]:
         """Build STAC items list from EODAG search results
 
         :param search_results: EODAG search results
@@ -244,7 +247,7 @@ class StacItem(StacCommon):
         )
 
         # check if some items need to be converted
-        need_conversion: Dict[str, Any] = {}
+        need_conversion: dict[str, Any] = {}
         for k, v in item_model["properties"].items():
             if isinstance(v, str):
                 conversion, item_model["properties"][k] = get_metadata_path(
@@ -264,11 +267,11 @@ class StacItem(StacCommon):
         ]
         ignored_props = COLLECTION_PROPERTIES + item_props + IGNORED_ITEM_PROPERTIES
 
-        item_list: List[Dict[str, Any]] = []
+        item_list: list[dict[str, Any]] = []
         for product in search_results:
             product_dict = deepcopy(product.__dict__)
 
-            product_item: Dict[str, Any] = jsonpath_parse_dict_items(
+            product_item: dict[str, Any] = jsonpath_parse_dict_items(
                 item_model,
                 {
                     "product": product_dict,
@@ -370,10 +373,10 @@ class StacItem(StacCommon):
         product: EOProduct,
         downloadlink_href: str,
         without_arg_url: str,
-        query_dict: Optional[Dict[str, Any]] = None,
+        query_dict: Optional[dict[str, Any]] = None,
         _dc_qs: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        assets: Dict[str, Any] = {}
+    ) -> dict[str, Any]:
+        assets: dict[str, Any] = {}
         settings = Settings.from_environment()
 
         if _dc_qs:
@@ -452,9 +455,9 @@ class StacItem(StacCommon):
         self,
         search_results: SearchResult,
         total: int,
-        catalog: Dict[str, Any],
-        next_link: Optional[Dict[str, Any]],
-    ) -> Dict[str, Any]:
+        catalog: dict[str, Any],
+        next_link: Optional[dict[str, Any]],
+    ) -> dict[str, Any]:
         """Build STAC items from EODAG search results
 
         :param search_results: EODAG search results
@@ -503,8 +506,8 @@ class StacItem(StacCommon):
         return self.data
 
     def __filter_item_model_properties(
-        self, item_model: Dict[str, Any], product_type: str
-    ) -> Dict[str, Any]:
+        self, item_model: dict[str, Any], product_type: str
+    ) -> dict[str, Any]:
         """Filter item model depending on product type metadata and its extensions.
         Removes not needed parameters, and adds supplementary ones as
         part of oseo extension.
@@ -568,13 +571,13 @@ class StacItem(StacCommon):
 
         return result_item_model
 
-    def __filter_item_properties_values(self, item: Dict[str, Any]) -> Dict[str, Any]:
+    def __filter_item_properties_values(self, item: dict[str, Any]) -> dict[str, Any]:
         """Removes empty properties, unused extensions, and add missing extensions
 
         :param item: STAC item data
         :returns: Filtered item model
         """
-        all_extensions_dict: Dict[str, str] = deepcopy(
+        all_extensions_dict: dict[str, str] = deepcopy(
             self.stac_config["stac_extensions"]
         )
         # parse f-strings with root
@@ -599,7 +602,7 @@ class StacItem(StacCommon):
 
         return item
 
-    def get_stac_item_from_product(self, product: EOProduct) -> Dict[str, Any]:
+    def get_stac_item_from_product(self, product: EOProduct) -> dict[str, Any]:
         """Build STAC item from EODAG product
 
         :param product: EODAG product
@@ -659,7 +662,7 @@ class StacCollection(StacCommon):
     """
 
     # External STAC collections
-    ext_stac_collections: Dict[str, Dict[str, Any]] = dict()
+    ext_stac_collections: dict[str, dict[str, Any]] = dict()
 
     @classmethod
     def fetch_external_stac_collections(cls, eodag_api: EODataAccessGateway) -> None:
@@ -688,7 +691,7 @@ class StacCollection(StacCommon):
     def __init__(
         self,
         url: str,
-        stac_config: Dict[str, Any],
+        stac_config: dict[str, Any],
         provider: Optional[str],
         eodag_api: EODataAccessGateway,
         root: str = "/",
@@ -701,7 +704,7 @@ class StacCollection(StacCommon):
             root=root,
         )
 
-    def __list_product_type_providers(self, product_type: Dict[str, Any]) -> List[str]:
+    def __list_product_type_providers(self, product_type: dict[str, Any]) -> list[str]:
         """Retrieve a list of providers for a given product type.
 
         :param product_type: Dictionary containing information about the product type.
@@ -718,8 +721,8 @@ class StacCollection(StacCommon):
         ]
 
     def __generate_stac_collection(
-        self, collection_model: Any, product_type: Dict[str, Any]
-    ) -> Dict[str, Any]:
+        self, collection_model: Any, product_type: dict[str, Any]
+    ) -> dict[str, Any]:
         """Generate a STAC collection dictionary for a given product type.
 
         :param collection_model: The base model for the STAC collection.
@@ -728,7 +731,7 @@ class StacCollection(StacCommon):
         """
         providers = self.__list_product_type_providers(product_type)
 
-        providers_dict: Dict[str, Dict[str, Any]] = {}
+        providers_dict: dict[str, dict[str, Any]] = {}
         for provider in providers:
             p_dict = self.get_provider_dict(provider)
             providers_dict.setdefault(p_dict["name"], p_dict)
@@ -815,7 +818,7 @@ class StacCollection(StacCommon):
         instrument: Optional[str] = None,
         constellation: Optional[str] = None,
         datetime: Optional[str] = None,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Build STAC collections list
 
         :param filters: (optional) Additional filters for collections search
@@ -850,7 +853,7 @@ class StacCollection(StacCommon):
             product_types = all_pt
 
         # list product types with all metadata using guessed ids
-        collection_list: List[Dict[str, Any]] = []
+        collection_list: list[dict[str, Any]] = []
         for product_type in product_types:
             stac_collection = self.__generate_stac_collection(
                 collection_model, product_type
@@ -874,7 +877,7 @@ class StacCatalog(StacCommon):
     def __init__(
         self,
         url: str,
-        stac_config: Dict[str, Any],
+        stac_config: dict[str, Any],
         provider: Optional[str],
         eodag_api: EODataAccessGateway,
         root: str = "/",
@@ -890,8 +893,8 @@ class StacCatalog(StacCommon):
         self.data = {}
 
         self.shp_location_config = eodag_api.locations_config
-        self.search_args: Dict[str, Any] = {}
-        self.children: List[Dict[str, Any]] = []
+        self.search_args: dict[str, Any] = {}
+        self.children: list[dict[str, Any]] = []
 
         self.catalog_config = deepcopy(stac_config["catalog"])
 
@@ -907,7 +910,7 @@ class StacCatalog(StacCommon):
         # build catalog
         self.__build_stac_catalog(collection)
 
-    def __update_data_from_catalog_config(self, catalog_config: Dict[str, Any]) -> bool:
+    def __update_data_from_catalog_config(self, catalog_config: dict[str, Any]) -> bool:
         """Updates configuration and data using given input catalog config
 
         :param catalog_config: Catalog config, from yml stac_config[catalogs]
@@ -959,7 +962,7 @@ class StacCatalog(StacCommon):
 
     def set_stac_product_type_by_id(
         self, product_type: str, **_: Any
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Updates catalog with given product_type
 
         :param product_type: Product type
@@ -991,7 +994,7 @@ class StacCatalog(StacCommon):
         format_args["catalog"] = defaultdict(str, **self.data)
         format_args["collection"] = collections[0]
         try:
-            parsed_dict: Dict[str, Any] = format_dict_items(cat_model, **format_args)
+            parsed_dict: dict[str, Any] = format_dict_items(cat_model, **format_args)
         except Exception:
             logger.error("Could not format product_type catalog")
             raise

eodag/rest/types/collections_search.py

@@ -15,7 +15,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 from pydantic import (
     BaseModel,
@@ -39,6 +39,6 @@ class CollectionsSearchRequest(BaseModel):
     constellation: Optional[str] = Field(default=None)
 
     @model_serializer(mode="wrap")
-    def _serialize(self, handler: SerializerFunctionWrapHandler) -> Dict[str, Any]:
-        dumped: Dict[str, Any] = handler(self)
+    def _serialize(self, handler: SerializerFunctionWrapHandler) -> dict[str, Any]:
+        dumped: dict[str, Any] = handler(self)
         return {EODAGSearch.to_eodag(k): v for k, v in dumped.items()}

eodag/rest/types/eodag_search.py

@@ -17,7 +17,7 @@
 # limitations under the License.
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union, cast
+from typing import TYPE_CHECKING, Any, Optional, Union, cast
 
 from pydantic import (
     AliasChoices,
@@ -52,7 +52,7 @@ if TYPE_CHECKING:
     from typing_extensions import Self
 
 Geometry = Union[
-    Dict[str, Any],
+    dict[str, Any],
     Point,
     MultiPoint,
     LineString,
@@ -73,8 +73,8 @@ class EODAGSearch(BaseModel):
 
     productType: Optional[str] = Field(None, alias="collections", validate_default=True)
     provider: Optional[str] = Field(None)
-    ids: Optional[List[str]] = Field(None)
-    id: Optional[List[str]] = Field(
+    ids: Optional[list[str]] = Field(None)
+    id: Optional[list[str]] = Field(
         None, alias="ids"
     )  # TODO: remove when updating queryables
     geom: Optional[Geometry] = Field(None, alias="geometry")
@@ -101,7 +101,7 @@ class EODAGSearch(BaseModel):
     orbitNumber: Optional[int] = Field(None, alias="sat:absolute_orbit")
     # TODO: colision in property name. Need to handle "sar:product_type"
     sensorMode: Optional[str] = Field(None, alias="sar:instrument_mode")
-    polarizationChannels: Optional[List[str]] = Field(None, alias="sar:polarizations")
+    polarizationChannels: Optional[list[str]] = Field(None, alias="sar:polarizations")
     dopplerFrequency: Optional[str] = Field(None, alias="sar:frequency_band")
     doi: Optional[str] = Field(None, alias="sci:doi")
     illuminationElevationAngle: Optional[float] = Field(
@@ -110,10 +110,10 @@ class EODAGSearch(BaseModel):
     illuminationAzimuthAngle: Optional[float] = Field(None, alias="view:sun_azimuth")
     page: Optional[int] = Field(1)
     items_per_page: int = Field(DEFAULT_ITEMS_PER_PAGE, alias="limit")
-    sort_by: Optional[List[Tuple[str, str]]] = Field(None, alias="sortby")
+    sort_by: Optional[list[tuple[str, str]]] = Field(None, alias="sortby")
     raise_errors: bool = False
 
-    _to_eodag_map: Dict[str, str]
+    _to_eodag_map: dict[str, str]
 
     @model_validator(mode="after")
     def remove_timeFromAscendingNode(self) -> Self:  # pylint: disable=invalid-name
@@ -129,7 +129,7 @@ class EODAGSearch(BaseModel):
         if not self.__pydantic_extra__:
             return self
 
-        keys_to_update: Dict[str, str] = {}
+        keys_to_update: dict[str, str] = {}
         for key in self.__pydantic_extra__.keys():
             if key.startswith("unk:"):
                 keys_to_update[key] = key[len("unk:") :]
@@ -145,7 +145,7 @@ class EODAGSearch(BaseModel):
 
     @model_validator(mode="before")
     @classmethod
-    def remove_keys(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    def remove_keys(cls, values: dict[str, Any]) -> dict[str, Any]:
         """Remove 'datetime', 'crunch', 'intersects', and 'bbox' keys"""
         for key in ["datetime", "crunch", "intersects", "bbox", "filter_lang"]:
             values.pop(key, None)
@@ -154,8 +154,8 @@ class EODAGSearch(BaseModel):
     @model_validator(mode="before")
     @classmethod
     def parse_collections(
-        cls, values: Dict[str, Any], info: ValidationInfo
-    ) -> Dict[str, Any]:
+        cls, values: dict[str, Any], info: ValidationInfo
+    ) -> dict[str, Any]:
         """convert collections to productType"""
 
         if collections := values.pop("collections", None):
@@ -172,7 +172,7 @@ class EODAGSearch(BaseModel):
 
     @model_validator(mode="before")
     @classmethod
-    def parse_query(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    def parse_query(cls, values: dict[str, Any]) -> dict[str, Any]:
         """
         Convert a STAC query parameter filter with the "eq" operator to a dict.
         """
@@ -190,9 +190,9 @@ class EODAGSearch(BaseModel):
         if not query:
             return values
 
-        query_props: Dict[str, Any] = {}
-        errors: List[InitErrorDetails] = []
-        for property_name, conditions in cast(Dict[str, Any], query).items():
+        query_props: dict[str, Any] = {}
+        errors: list[InitErrorDetails] = []
+        for property_name, conditions in cast(dict[str, Any], query).items():
             # Remove the prefix "properties." if present
             prop = property_name.replace("properties.", "", 1)
 
@@ -205,7 +205,7 @@ class EODAGSearch(BaseModel):
                 continue
 
             # Retrieve the operator and its value
-            operator, value = next(iter(cast(Dict[str, Any], conditions).items()))
+            operator, value = next(iter(cast(dict[str, Any], conditions).items()))
 
             # Validate the operator
             # only eq, in and lte are allowed
@@ -239,7 +239,7 @@ class EODAGSearch(BaseModel):
 
     @model_validator(mode="before")
     @classmethod
-    def parse_cql(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    def parse_cql(cls, values: dict[str, Any]) -> dict[str, Any]:
         """
         Process cql2 filter
         """
@@ -256,7 +256,7 @@ class EODAGSearch(BaseModel):
         if not filter_:
             return values
 
-        errors: List[InitErrorDetails] = []
+        errors: list[InitErrorDetails] = []
         try:
             parsing_result = EodagEvaluator().evaluate(parse_json(filter_))  # type: ignore
         except (ValueError, NotImplementedError) as e:
@@ -271,7 +271,7 @@ class EODAGSearch(BaseModel):
                 title=cls.__name__, line_errors=errors
             )
 
-        cql_args: Dict[str, Any] = cast(Dict[str, Any], parsing_result)
+        cql_args: dict[str, Any] = cast(dict[str, Any], parsing_result)
 
         invalid_keys = {
             "collections": 'Use "collection" instead of "collections"',
@@ -298,7 +298,7 @@ class EODAGSearch(BaseModel):
 
     @field_validator("instrument", mode="before")
     @classmethod
-    def join_instruments(cls, v: Union[str, List[str]]) -> str:
+    def join_instruments(cls, v: Union[str, list[str]]) -> str:
         """convert instruments to instrument"""
         if isinstance(v, list):
             return ",".join(v)
@@ -308,8 +308,8 @@ class EODAGSearch(BaseModel):
     @classmethod
     def parse_sortby(
         cls,
-        sortby_post_params: List[Dict[str, str]],
-    ) -> List[Tuple[str, str]]:
+        sortby_post_params: list[dict[str, str]],
+    ) -> list[tuple[str, str]]:
         """
         Convert STAC POST sortby to EODAG sort_by
         """
@@ -363,10 +363,16 @@ class EODAGSearch(BaseModel):
     def to_stac(
         cls,
         field_name: str,
-        stac_item_properties: Optional[List[str]] = None,
+        stac_item_properties: Optional[list[str]] = None,
         provider: Optional[str] = None,
     ) -> str:
         """Get the alias of a field in a Pydantic model"""
+        # quick fix. TODO: refactor of EODAGSearch.
+        if field_name in ("productType", "id", "start_datetime", "end_datetime"):
+            return field_name
+        # another quick fix to handle different names of geometry
+        if field_name == "geometry":
+            field_name = "geom"
         field = cls.model_fields.get(field_name)
         if field is not None and field.alias is not None:
             return field.alias

eodag/rest/types/queryables.py

@@ -17,7 +17,7 @@
 # limitations under the License.
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Annotated, Any, ClassVar, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Annotated, Any, ClassVar, Optional, Union
 
 from pydantic import (
     BaseModel,
@@ -25,8 +25,9 @@ from pydantic import (
     Field,
     SerializationInfo,
     SerializerFunctionWrapHandler,
-    computed_field,
+    field_validator,
     model_serializer,
+    model_validator,
 )
 
 from eodag.rest.types.eodag_search import EODAGSearch
@@ -35,6 +36,7 @@ from eodag.types import python_field_definition_to_json
 
 if TYPE_CHECKING:
     from pydantic.fields import FieldInfo
+    from typing_extensions import Self
 
 
 class QueryablesGetParams(BaseModel):
@@ -42,29 +44,39 @@ class QueryablesGetParams(BaseModel):
 
     collection: Optional[str] = Field(default=None, serialization_alias="productType")
     datetime: Optional[str] = Field(default=None)
+    start_datetime: Optional[str] = Field(default=None)
+    end_datetime: Optional[str] = Field(default=None)
 
     model_config = ConfigDict(extra="allow", frozen=True)
 
     @model_serializer(mode="wrap")
-    def _serialize(self, handler: SerializerFunctionWrapHandler) -> Dict[str, Any]:
-        dumped: Dict[str, Any] = handler(self)
+    def _serialize(self, handler: SerializerFunctionWrapHandler) -> dict[str, Any]:
+        dumped: dict[str, Any] = handler(self)
         return {EODAGSearch.to_eodag(k): v for k, v in dumped.items()}
 
-    # use [prop-decorator] mypy error code when mypy==1.12 is released
-    @computed_field  # type: ignore[misc]
-    @property
-    def start_datetime(self) -> Optional[str]:
-        """Extract start_datetime property from datetime"""
-        start = str_to_interval(self.datetime)[0]
-        return start.strftime("%Y-%m-%dT%H:%M:%SZ") if start else None
+    @field_validator("datetime", "start_datetime", "end_datetime", mode="before")
+    def validate_datetime(cls, value: Any) -> Optional[str]:
+        """datetime, start_datetime and end_datetime must be a string"""
+        if isinstance(value, list):
+            return value[0]
 
-    # use [prop-decorator] mypy error code when mypy==1.12 is released
-    @computed_field  # type: ignore[misc]
-    @property
-    def end_datetime(self) -> Optional[str]:
-        """Extract end_datetime property from datetime"""
-        end = str_to_interval(self.datetime)[1]
-        return end.strftime("%Y-%m-%dT%H:%M:%SZ") if end else None
+        return value
+
+    @model_validator(mode="after")
+    def compute_datetimes(self: Self) -> Self:
+        """Start datetime must be a string"""
+        if not self.datetime:
+            return self
+
+        start, end = str_to_interval(self.datetime)
+
+        if not self.start_datetime and start:
+            self.start_datetime = start.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+        if not self.end_datetime and end:
+            self.end_datetime = end.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+        return self
 
 
 class StacQueryableProperty(BaseModel):
@@ -77,12 +89,12 @@ class StacQueryableProperty(BaseModel):
 
     description: str
     ref: Optional[str] = Field(default=None, serialization_alias="$ref")
-    type: Optional[Union[str, List[str]]] = None
-    enum: Optional[List[Any]] = None
+    type: Optional[Union[str, list[str]]] = None
+    enum: Optional[list[Any]] = None
     value: Optional[Any] = None
-    min: Optional[Union[int, List[Union[int, None]]]] = None
-    max: Optional[Union[int, List[Union[int, None]]]] = None
-    oneOf: Optional[List[Any]] = None
+    min: Optional[Union[int, list[Union[int, None]]]] = None
+    max: Optional[Union[int, list[Union[int, None]]]] = None
+    oneOf: Optional[list[Any]] = None
     items: Optional[Any] = None
 
     @classmethod
@@ -104,7 +116,7 @@ class StacQueryableProperty(BaseModel):
         _: SerializationInfo,
     ):
         """Remove none value property fields during serialization"""
-        props: Dict[str, Any] = handler(self)
+        props: dict[str, Any] = handler(self)
         return {k: v for k, v in props.items() if v is not None}
 
 
@@ -130,15 +142,13 @@ class StacQueryables(BaseModel):
     description: str = Field(
         default="Queryable names for the EODAG STAC API Item Search filter."
     )
-    default_properties: ClassVar[Dict[str, StacQueryableProperty]] = {
-        "id": StacQueryableProperty(
-            description="ID",
-            ref="https://schemas.stacspec.org/v1.0.0/item-spec/json-schema/item.json#/id",
-        ),
+    default_properties: ClassVar[dict[str, StacQueryableProperty]] = {
         "collection": StacQueryableProperty(
             description="Collection",
             ref="https://schemas.stacspec.org/v1.0.0/item-spec/json-schema/item.json#/collection",
-        ),
+        )
+    }
+    possible_properties: ClassVar[dict[str, StacQueryableProperty]] = {
         "geometry": StacQueryableProperty(
             description="Geometry",
             ref="https://schemas.stacspec.org/v1.0.0/item-spec/json-schema/item.json#/geometry",
@@ -154,7 +164,8 @@ class StacQueryables(BaseModel):
             items={"type": "number"},
         ),
     }
-    properties: Dict[str, StacQueryableProperty] = Field()
+    properties: dict[str, Any] = Field()
+    required: Optional[list[str]] = Field(None)
     additional_properties: bool = Field(
         default=True, serialization_alias="additionalProperties"
     )