crypticorn 2.17.0rc1__py3-none-any.whl → 2.17.0rc2__py3-none-any.whl

crypticorn/metrics/client/api/marketcap_api.py

@@ -30,6 +30,24 @@ from crypticorn.metrics.client.api_client import ApiClient, RequestSerialized
 from crypticorn.metrics.client.api_response import ApiResponse
 from crypticorn.metrics.client.rest import RESTResponseType
 
+# Import async_to_sync for sync methods
+try:
+    from asgiref.sync import async_to_sync
+
+    _HAS_ASGIREF = True
+except ImportError:
+    _HAS_ASGIREF = False
+
+    def async_to_sync(async_func):
+        """Fallback decorator that raises an error if asgiref is not available."""
+
+        def wrapper(*args, **kwargs):
+            raise ImportError(
+                "asgiref is required for sync methods. Install with: pip install asgiref"
+            )
+
+        return wrapper
+
 
 class MarketcapApi:
     """NOTE: This class is auto generated by OpenAPI Generator
@@ -38,13 +56,144 @@ class MarketcapApi:
     Do not edit the class manually.
     """
 
-    def __init__(self, api_client=None) -> None:
+    def __init__(self, api_client=None, is_sync: bool = False) -> None:
         if api_client is None:
             api_client = ApiClient.get_default()
         self.api_client = api_client
+        self.is_sync = is_sync
+
+    @validate_call
+    def get_current_marketcap(
+        self,
+        limit: Annotated[
+            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
+            Field(description="Number of top symbols to fetch (1-100)"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> List[Dict[str, object]]:
+        """Get Current Marketcap
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_current_marketcap_sync(
+                limit=limit,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_current_marketcap_async(
+                limit=limit,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_current_marketcap_with_http_info(
+        self,
+        limit: Annotated[
+            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
+            Field(description="Number of top symbols to fetch (1-100)"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[List[Dict[str, object]]]:
+        """Get Current Marketcap with HTTP info
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_current_marketcap_sync_with_http_info(
+                limit=limit,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_current_marketcap_async_with_http_info(
+                limit=limit,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_current_marketcap_without_preload_content(
+        self,
+        limit: Annotated[
+            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
+            Field(description="Number of top symbols to fetch (1-100)"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Get Current Marketcap without preloading content
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_current_marketcap_sync_without_preload_content(
+                limit=limit,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
 
+        else:
+            return self._get_current_marketcap_async_without_preload_content(
+                limit=limit,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    # Private async implementation methods
     @validate_call
-    async def get_current_marketcap(
+    async def _get_current_marketcap_async(
         self,
         limit: Annotated[
             Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
@@ -111,7 +260,7 @@ class MarketcapApi:
         ).data
 
     @validate_call
-    async def get_current_marketcap_with_http_info(
+    async def _get_current_marketcap_async_with_http_info(
         self,
         limit: Annotated[
             Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
@@ -173,12 +322,11 @@ class MarketcapApi:
         )
         await response_data.read()
         return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
+            response_data=response_data, response_types_map=_response_types_map
         )
 
     @validate_call
-    async def get_current_marketcap_without_preload_content(
+    async def _get_current_marketcap_async_without_preload_content(
         self,
         limit: Annotated[
             Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
@@ -238,7 +386,95 @@ class MarketcapApi:
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        return response_data.response
+        return response_data
+
+    # Private sync implementation methods
+    @validate_call
+    def _get_current_marketcap_sync(
+        self,
+        limit: Annotated[
+            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
+            Field(description="Number of top symbols to fetch (1-100)"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> List[Dict[str, object]]:
+        """Synchronous version of get_current_marketcap"""
+        return async_to_sync(self._get_current_marketcap_async)(
+            limit=limit,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_current_marketcap_sync_with_http_info(
+        self,
+        limit: Annotated[
+            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
+            Field(description="Number of top symbols to fetch (1-100)"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[List[Dict[str, object]]]:
+        """Synchronous version of get_current_marketcap_with_http_info"""
+        return async_to_sync(self._get_current_marketcap_async_with_http_info)(
+            limit=limit,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_current_marketcap_sync_without_preload_content(
+        self,
+        limit: Annotated[
+            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
+            Field(description="Number of top symbols to fetch (1-100)"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Synchronous version of get_current_marketcap_without_preload_content"""
+        return async_to_sync(self._get_current_marketcap_async_without_preload_content)(
+            limit=limit,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
 
     def _get_current_marketcap_serialize(
         self,
@@ -297,7 +533,149 @@ class MarketcapApi:
         )
 
     @validate_call
-    async def get_marketcap_between_timestamps(
+    def get_marketcap_between_timestamps(
+        self,
+        start_timestamp: Annotated[
+            Optional[StrictInt], Field(description="Start timestamp")
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt], Field(description="End timestamp")
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> List[MarketcapRanking]:
+        """Get Marketcap Between Timestamps
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_marketcap_between_timestamps_sync(
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_marketcap_between_timestamps_async(
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_marketcap_between_timestamps_with_http_info(
+        self,
+        start_timestamp: Annotated[
+            Optional[StrictInt], Field(description="Start timestamp")
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt], Field(description="End timestamp")
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[List[MarketcapRanking]]:
+        """Get Marketcap Between Timestamps with HTTP info
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_marketcap_between_timestamps_sync_with_http_info(
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_marketcap_between_timestamps_async_with_http_info(
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_marketcap_between_timestamps_without_preload_content(
+        self,
+        start_timestamp: Annotated[
+            Optional[StrictInt], Field(description="Start timestamp")
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt], Field(description="End timestamp")
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Get Marketcap Between Timestamps without preloading content
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_marketcap_between_timestamps_sync_without_preload_content(
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_marketcap_between_timestamps_async_without_preload_content(
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    # Private async implementation methods
+    @validate_call
+    async def _get_marketcap_between_timestamps_async(
         self,
         start_timestamp: Annotated[
             Optional[StrictInt], Field(description="Start timestamp")
@@ -369,7 +747,7 @@ class MarketcapApi:
         ).data
 
     @validate_call
-    async def get_marketcap_between_timestamps_with_http_info(
+    async def _get_marketcap_between_timestamps_async_with_http_info(
         self,
         start_timestamp: Annotated[
             Optional[StrictInt], Field(description="Start timestamp")
@@ -436,12 +814,11 @@ class MarketcapApi:
         )
         await response_data.read()
         return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
+            response_data=response_data, response_types_map=_response_types_map
         )
 
     @validate_call
-    async def get_marketcap_between_timestamps_without_preload_content(
+    async def _get_marketcap_between_timestamps_async_without_preload_content(
         self,
         start_timestamp: Annotated[
             Optional[StrictInt], Field(description="Start timestamp")
@@ -506,37 +883,138 @@ class MarketcapApi:
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        return response_data.response
+        return response_data
 
-    def _get_marketcap_between_timestamps_serialize(
+    # Private sync implementation methods
+    @validate_call
+    def _get_marketcap_between_timestamps_sync(
         self,
-        start_timestamp,
-        end_timestamp,
-        _request_auth,
-        _content_type,
-        _headers,
-        _host_index,
-    ) -> RequestSerialized:
-
-        _host = None
-
-        _collection_formats: Dict[str, str] = {}
-
-        _path_params: Dict[str, str] = {}
-        _query_params: List[Tuple[str, str]] = []
-        _header_params: Dict[str, Optional[str]] = _headers or {}
-        _form_params: List[Tuple[str, str]] = []
-        _files: Dict[
-            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
-        ] = {}
-        _body_params: Optional[bytes] = None
-
-        # process the path parameters
-        # process the query parameters
-        if start_timestamp is not None:
-
-            _query_params.append(("start_timestamp", start_timestamp))
-
+        start_timestamp: Annotated[
+            Optional[StrictInt], Field(description="Start timestamp")
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt], Field(description="End timestamp")
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> List[MarketcapRanking]:
+        """Synchronous version of get_marketcap_between_timestamps"""
+        return async_to_sync(self._get_marketcap_between_timestamps_async)(
+            start_timestamp=start_timestamp,
+            end_timestamp=end_timestamp,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_marketcap_between_timestamps_sync_with_http_info(
+        self,
+        start_timestamp: Annotated[
+            Optional[StrictInt], Field(description="Start timestamp")
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt], Field(description="End timestamp")
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[List[MarketcapRanking]]:
+        """Synchronous version of get_marketcap_between_timestamps_with_http_info"""
+        return async_to_sync(
+            self._get_marketcap_between_timestamps_async_with_http_info
+        )(
+            start_timestamp=start_timestamp,
+            end_timestamp=end_timestamp,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_marketcap_between_timestamps_sync_without_preload_content(
+        self,
+        start_timestamp: Annotated[
+            Optional[StrictInt], Field(description="Start timestamp")
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt], Field(description="End timestamp")
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Synchronous version of get_marketcap_between_timestamps_without_preload_content"""
+        return async_to_sync(
+            self._get_marketcap_between_timestamps_async_without_preload_content
+        )(
+            start_timestamp=start_timestamp,
+            end_timestamp=end_timestamp,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    def _get_marketcap_between_timestamps_serialize(
+        self,
+        start_timestamp,
+        end_timestamp,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {}
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        # process the query parameters
+        if start_timestamp is not None:
+
+            _query_params.append(("start_timestamp", start_timestamp))
+
         if end_timestamp is not None:
 
             _query_params.append(("end_timestamp", end_timestamp))
@@ -570,7 +1048,215 @@ class MarketcapApi:
         )
 
     @validate_call
-    async def get_marketcap_symbols(
+    def get_marketcap_symbols(
+        self,
+        start_timestamp: Annotated[
+            Optional[StrictInt], Field(description="Start timestamp")
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt], Field(description="End timestamp")
+        ] = None,
+        interval: Annotated[
+            Optional[StrictStr],
+            Field(description="Interval for which to fetch symbols and marketcap data"),
+        ] = None,
+        market: Annotated[
+            Optional[MarketType],
+            Field(
+                description="Market for which to fetch symbols and marketcap data. Defaults to futures."
+            ),
+        ] = None,
+        exchange: Annotated[
+            Optional[StrictStr],
+            Field(
+                description="Exchange for which to fetch symbols and marketcap data. If not provided, all exchanges will be returned."
+            ),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> List[MarketcapSymbolRanking]:
+        """Get Symbols Marketcap Between Timestamps
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_marketcap_symbols_sync(
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                interval=interval,
+                market=market,
+                exchange=exchange,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_marketcap_symbols_async(
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                interval=interval,
+                market=market,
+                exchange=exchange,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_marketcap_symbols_with_http_info(
+        self,
+        start_timestamp: Annotated[
+            Optional[StrictInt], Field(description="Start timestamp")
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt], Field(description="End timestamp")
+        ] = None,
+        interval: Annotated[
+            Optional[StrictStr],
+            Field(description="Interval for which to fetch symbols and marketcap data"),
+        ] = None,
+        market: Annotated[
+            Optional[MarketType],
+            Field(
+                description="Market for which to fetch symbols and marketcap data. Defaults to futures."
+            ),
+        ] = None,
+        exchange: Annotated[
+            Optional[StrictStr],
+            Field(
+                description="Exchange for which to fetch symbols and marketcap data. If not provided, all exchanges will be returned."
+            ),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[List[MarketcapSymbolRanking]]:
+        """Get Symbols Marketcap Between Timestamps with HTTP info
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_marketcap_symbols_sync_with_http_info(
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                interval=interval,
+                market=market,
+                exchange=exchange,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_marketcap_symbols_async_with_http_info(
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                interval=interval,
+                market=market,
+                exchange=exchange,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_marketcap_symbols_without_preload_content(
+        self,
+        start_timestamp: Annotated[
+            Optional[StrictInt], Field(description="Start timestamp")
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt], Field(description="End timestamp")
+        ] = None,
+        interval: Annotated[
+            Optional[StrictStr],
+            Field(description="Interval for which to fetch symbols and marketcap data"),
+        ] = None,
+        market: Annotated[
+            Optional[MarketType],
+            Field(
+                description="Market for which to fetch symbols and marketcap data. Defaults to futures."
+            ),
+        ] = None,
+        exchange: Annotated[
+            Optional[StrictStr],
+            Field(
+                description="Exchange for which to fetch symbols and marketcap data. If not provided, all exchanges will be returned."
+            ),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Get Symbols Marketcap Between Timestamps without preloading content
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_marketcap_symbols_sync_without_preload_content(
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                interval=interval,
+                market=market,
+                exchange=exchange,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_marketcap_symbols_async_without_preload_content(
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                interval=interval,
+                market=market,
+                exchange=exchange,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    # Private async implementation methods
+    @validate_call
+    async def _get_marketcap_symbols_async(
         self,
         start_timestamp: Annotated[
             Optional[StrictInt], Field(description="Start timestamp")
@@ -667,7 +1353,7 @@ class MarketcapApi:
         ).data
 
     @validate_call
-    async def get_marketcap_symbols_with_http_info(
+    async def _get_marketcap_symbols_async_with_http_info(
         self,
         start_timestamp: Annotated[
             Optional[StrictInt], Field(description="Start timestamp")
@@ -759,12 +1445,11 @@ class MarketcapApi:
         )
         await response_data.read()
         return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
+            response_data=response_data, response_types_map=_response_types_map
         )
 
     @validate_call
-    async def get_marketcap_symbols_without_preload_content(
+    async def _get_marketcap_symbols_async_without_preload_content(
         self,
         start_timestamp: Annotated[
             Optional[StrictInt], Field(description="Start timestamp")
@@ -848,14 +1533,168 @@ class MarketcapApi:
             _host_index=_host_index,
         )
 
-        _response_types_map: Dict[str, Optional[str]] = {
-            "200": "List[MarketcapSymbolRanking]",
-        }
-        response_data = await self.api_client.call_api(
-            *_param, _request_timeout=_request_timeout
-        )
-        return response_data.response
-
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "List[MarketcapSymbolRanking]",
+        }
+        response_data = await self.api_client.call_api(
+            *_param, _request_timeout=_request_timeout
+        )
+        return response_data
+
+    # Private sync implementation methods
+    @validate_call
+    def _get_marketcap_symbols_sync(
+        self,
+        start_timestamp: Annotated[
+            Optional[StrictInt], Field(description="Start timestamp")
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt], Field(description="End timestamp")
+        ] = None,
+        interval: Annotated[
+            Optional[StrictStr],
+            Field(description="Interval for which to fetch symbols and marketcap data"),
+        ] = None,
+        market: Annotated[
+            Optional[MarketType],
+            Field(
+                description="Market for which to fetch symbols and marketcap data. Defaults to futures."
+            ),
+        ] = None,
+        exchange: Annotated[
+            Optional[StrictStr],
+            Field(
+                description="Exchange for which to fetch symbols and marketcap data. If not provided, all exchanges will be returned."
+            ),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> List[MarketcapSymbolRanking]:
+        """Synchronous version of get_marketcap_symbols"""
+        return async_to_sync(self._get_marketcap_symbols_async)(
+            start_timestamp=start_timestamp,
+            end_timestamp=end_timestamp,
+            interval=interval,
+            market=market,
+            exchange=exchange,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_marketcap_symbols_sync_with_http_info(
+        self,
+        start_timestamp: Annotated[
+            Optional[StrictInt], Field(description="Start timestamp")
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt], Field(description="End timestamp")
+        ] = None,
+        interval: Annotated[
+            Optional[StrictStr],
+            Field(description="Interval for which to fetch symbols and marketcap data"),
+        ] = None,
+        market: Annotated[
+            Optional[MarketType],
+            Field(
+                description="Market for which to fetch symbols and marketcap data. Defaults to futures."
+            ),
+        ] = None,
+        exchange: Annotated[
+            Optional[StrictStr],
+            Field(
+                description="Exchange for which to fetch symbols and marketcap data. If not provided, all exchanges will be returned."
+            ),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[List[MarketcapSymbolRanking]]:
+        """Synchronous version of get_marketcap_symbols_with_http_info"""
+        return async_to_sync(self._get_marketcap_symbols_async_with_http_info)(
+            start_timestamp=start_timestamp,
+            end_timestamp=end_timestamp,
+            interval=interval,
+            market=market,
+            exchange=exchange,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_marketcap_symbols_sync_without_preload_content(
+        self,
+        start_timestamp: Annotated[
+            Optional[StrictInt], Field(description="Start timestamp")
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt], Field(description="End timestamp")
+        ] = None,
+        interval: Annotated[
+            Optional[StrictStr],
+            Field(description="Interval for which to fetch symbols and marketcap data"),
+        ] = None,
+        market: Annotated[
+            Optional[MarketType],
+            Field(
+                description="Market for which to fetch symbols and marketcap data. Defaults to futures."
+            ),
+        ] = None,
+        exchange: Annotated[
+            Optional[StrictStr],
+            Field(
+                description="Exchange for which to fetch symbols and marketcap data. If not provided, all exchanges will be returned."
+            ),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Synchronous version of get_marketcap_symbols_without_preload_content"""
+        return async_to_sync(self._get_marketcap_symbols_async_without_preload_content)(
+            start_timestamp=start_timestamp,
+            end_timestamp=end_timestamp,
+            interval=interval,
+            market=market,
+            exchange=exchange,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
     def _get_marketcap_symbols_serialize(
         self,
         start_timestamp,
@@ -933,7 +1772,203 @@ class MarketcapApi:
         )
 
     @validate_call
-    async def get_marketcap_symbols_with_ohlcv(
+    def get_marketcap_symbols_with_ohlcv(
+        self,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="Timestamp for which to fetch symbols and OHLCV data"),
+        ] = None,
+        timeframe: Annotated[
+            Optional[StrictStr], Field(description="Timeframe for OHLCV data")
+        ] = None,
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="Market for OHLCV data. Defaults to futures."),
+        ] = None,
+        top_n: Annotated[
+            Optional[StrictInt], Field(description="Number of symbols to fetch")
+        ] = None,
+        ohlcv_limit: Annotated[
+            Optional[StrictInt],
+            Field(description="Number of OHLCV data points to fetch"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> Dict[str, List[OHLCV]]:
+        """Get Symbols Marketcap With Ohlcv
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_marketcap_symbols_with_ohlcv_sync(
+                timestamp=timestamp,
+                timeframe=timeframe,
+                market=market,
+                top_n=top_n,
+                ohlcv_limit=ohlcv_limit,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_marketcap_symbols_with_ohlcv_async(
+                timestamp=timestamp,
+                timeframe=timeframe,
+                market=market,
+                top_n=top_n,
+                ohlcv_limit=ohlcv_limit,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_marketcap_symbols_with_ohlcv_with_http_info(
+        self,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="Timestamp for which to fetch symbols and OHLCV data"),
+        ] = None,
+        timeframe: Annotated[
+            Optional[StrictStr], Field(description="Timeframe for OHLCV data")
+        ] = None,
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="Market for OHLCV data. Defaults to futures."),
+        ] = None,
+        top_n: Annotated[
+            Optional[StrictInt], Field(description="Number of symbols to fetch")
+        ] = None,
+        ohlcv_limit: Annotated[
+            Optional[StrictInt],
+            Field(description="Number of OHLCV data points to fetch"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[Dict[str, List[OHLCV]]]:
+        """Get Symbols Marketcap With Ohlcv with HTTP info
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_marketcap_symbols_with_ohlcv_sync_with_http_info(
+                timestamp=timestamp,
+                timeframe=timeframe,
+                market=market,
+                top_n=top_n,
+                ohlcv_limit=ohlcv_limit,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_marketcap_symbols_with_ohlcv_async_with_http_info(
+                timestamp=timestamp,
+                timeframe=timeframe,
+                market=market,
+                top_n=top_n,
+                ohlcv_limit=ohlcv_limit,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_marketcap_symbols_with_ohlcv_without_preload_content(
+        self,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="Timestamp for which to fetch symbols and OHLCV data"),
+        ] = None,
+        timeframe: Annotated[
+            Optional[StrictStr], Field(description="Timeframe for OHLCV data")
+        ] = None,
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="Market for OHLCV data. Defaults to futures."),
+        ] = None,
+        top_n: Annotated[
+            Optional[StrictInt], Field(description="Number of symbols to fetch")
+        ] = None,
+        ohlcv_limit: Annotated[
+            Optional[StrictInt],
+            Field(description="Number of OHLCV data points to fetch"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Get Symbols Marketcap With Ohlcv without preloading content
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_marketcap_symbols_with_ohlcv_sync_without_preload_content(
+                timestamp=timestamp,
+                timeframe=timeframe,
+                market=market,
+                top_n=top_n,
+                ohlcv_limit=ohlcv_limit,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_marketcap_symbols_with_ohlcv_async_without_preload_content(
+                timestamp=timestamp,
+                timeframe=timeframe,
+                market=market,
+                top_n=top_n,
+                ohlcv_limit=ohlcv_limit,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    # Private async implementation methods
+    @validate_call
+    async def _get_marketcap_symbols_with_ohlcv_async(
         self,
         timestamp: Annotated[
             Optional[StrictInt],
@@ -1026,7 +2061,7 @@ class MarketcapApi:
         ).data
 
     @validate_call
-    async def get_marketcap_symbols_with_ohlcv_with_http_info(
+    async def _get_marketcap_symbols_with_ohlcv_async_with_http_info(
         self,
         timestamp: Annotated[
             Optional[StrictInt],
@@ -1114,12 +2149,11 @@ class MarketcapApi:
         )
         await response_data.read()
         return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
+            response_data=response_data, response_types_map=_response_types_map
         )
 
     @validate_call
-    async def get_marketcap_symbols_with_ohlcv_without_preload_content(
+    async def _get_marketcap_symbols_with_ohlcv_async_without_preload_content(
         self,
         timestamp: Annotated[
             Optional[StrictInt],
@@ -1205,7 +2239,153 @@ class MarketcapApi:
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        return response_data.response
+        return response_data
+
+    # Private sync implementation methods
+    @validate_call
+    def _get_marketcap_symbols_with_ohlcv_sync(
+        self,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="Timestamp for which to fetch symbols and OHLCV data"),
+        ] = None,
+        timeframe: Annotated[
+            Optional[StrictStr], Field(description="Timeframe for OHLCV data")
+        ] = None,
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="Market for OHLCV data. Defaults to futures."),
+        ] = None,
+        top_n: Annotated[
+            Optional[StrictInt], Field(description="Number of symbols to fetch")
+        ] = None,
+        ohlcv_limit: Annotated[
+            Optional[StrictInt],
+            Field(description="Number of OHLCV data points to fetch"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> Dict[str, List[OHLCV]]:
+        """Synchronous version of get_marketcap_symbols_with_ohlcv"""
+        return async_to_sync(self._get_marketcap_symbols_with_ohlcv_async)(
+            timestamp=timestamp,
+            timeframe=timeframe,
+            market=market,
+            top_n=top_n,
+            ohlcv_limit=ohlcv_limit,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_marketcap_symbols_with_ohlcv_sync_with_http_info(
+        self,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="Timestamp for which to fetch symbols and OHLCV data"),
+        ] = None,
+        timeframe: Annotated[
+            Optional[StrictStr], Field(description="Timeframe for OHLCV data")
+        ] = None,
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="Market for OHLCV data. Defaults to futures."),
+        ] = None,
+        top_n: Annotated[
+            Optional[StrictInt], Field(description="Number of symbols to fetch")
+        ] = None,
+        ohlcv_limit: Annotated[
+            Optional[StrictInt],
+            Field(description="Number of OHLCV data points to fetch"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[Dict[str, List[OHLCV]]]:
+        """Synchronous version of get_marketcap_symbols_with_ohlcv_with_http_info"""
+        return async_to_sync(
+            self._get_marketcap_symbols_with_ohlcv_async_with_http_info
+        )(
+            timestamp=timestamp,
+            timeframe=timeframe,
+            market=market,
+            top_n=top_n,
+            ohlcv_limit=ohlcv_limit,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_marketcap_symbols_with_ohlcv_sync_without_preload_content(
+        self,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="Timestamp for which to fetch symbols and OHLCV data"),
+        ] = None,
+        timeframe: Annotated[
+            Optional[StrictStr], Field(description="Timeframe for OHLCV data")
+        ] = None,
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="Market for OHLCV data. Defaults to futures."),
+        ] = None,
+        top_n: Annotated[
+            Optional[StrictInt], Field(description="Number of symbols to fetch")
+        ] = None,
+        ohlcv_limit: Annotated[
+            Optional[StrictInt],
+            Field(description="Number of OHLCV data points to fetch"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Synchronous version of get_marketcap_symbols_with_ohlcv_without_preload_content"""
+        return async_to_sync(
+            self._get_marketcap_symbols_with_ohlcv_async_without_preload_content
+        )(
+            timestamp=timestamp,
+            timeframe=timeframe,
+            market=market,
+            top_n=top_n,
+            ohlcv_limit=ohlcv_limit,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
 
     def _get_marketcap_symbols_with_ohlcv_serialize(
         self,