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

crypticorn/metrics/client/api/exchanges_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 ExchangesApi:
     """NOTE: This class is auto generated by OpenAPI Generator
@@ -38,13 +56,264 @@ class ExchangesApi:
     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_available_exchanges(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch available exchanges for")
+        ],
+        interval: Annotated[
+            Optional[TimeInterval],
+            Field(description="Interval for which to fetch available exchanges"),
+        ] = None,
+        start_timestamp: Annotated[
+            Optional[StrictInt],
+            Field(
+                description="Start timestamp for which to fetch available exchanges (defaults to previous 7 day's closing)"
+            ),
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="End timestamp for which to fetch available exchanges"),
+        ] = None,
+        quote_currency: Annotated[
+            Optional[StrictStr],
+            Field(
+                description="Quote currency for which to fetch available exchanges (Use quote currencies endpoint to get available quote currencies)"
+            ),
+        ] = None,
+        status: Annotated[
+            Optional[TradingStatus],
+            Field(
+                description="Trading pair status for which to fetch available exchanges"
+            ),
+        ] = 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[ExchangeAvailability]:
+        """Get Available Exchanges
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_available_exchanges_sync(
+                market=market,
+                symbol=symbol,
+                interval=interval,
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                quote_currency=quote_currency,
+                status=status,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_available_exchanges_async(
+                market=market,
+                symbol=symbol,
+                interval=interval,
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                quote_currency=quote_currency,
+                status=status,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_available_exchanges_with_http_info(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch available exchanges for")
+        ],
+        interval: Annotated[
+            Optional[TimeInterval],
+            Field(description="Interval for which to fetch available exchanges"),
+        ] = None,
+        start_timestamp: Annotated[
+            Optional[StrictInt],
+            Field(
+                description="Start timestamp for which to fetch available exchanges (defaults to previous 7 day's closing)"
+            ),
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="End timestamp for which to fetch available exchanges"),
+        ] = None,
+        quote_currency: Annotated[
+            Optional[StrictStr],
+            Field(
+                description="Quote currency for which to fetch available exchanges (Use quote currencies endpoint to get available quote currencies)"
+            ),
+        ] = None,
+        status: Annotated[
+            Optional[TradingStatus],
+            Field(
+                description="Trading pair status for which to fetch available exchanges"
+            ),
+        ] = 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[ExchangeAvailability]]:
+        """Get Available Exchanges 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_available_exchanges_sync_with_http_info(
+                market=market,
+                symbol=symbol,
+                interval=interval,
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                quote_currency=quote_currency,
+                status=status,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_available_exchanges_async_with_http_info(
+                market=market,
+                symbol=symbol,
+                interval=interval,
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                quote_currency=quote_currency,
+                status=status,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_available_exchanges_without_preload_content(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch available exchanges for")
+        ],
+        interval: Annotated[
+            Optional[TimeInterval],
+            Field(description="Interval for which to fetch available exchanges"),
+        ] = None,
+        start_timestamp: Annotated[
+            Optional[StrictInt],
+            Field(
+                description="Start timestamp for which to fetch available exchanges (defaults to previous 7 day's closing)"
+            ),
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="End timestamp for which to fetch available exchanges"),
+        ] = None,
+        quote_currency: Annotated[
+            Optional[StrictStr],
+            Field(
+                description="Quote currency for which to fetch available exchanges (Use quote currencies endpoint to get available quote currencies)"
+            ),
+        ] = None,
+        status: Annotated[
+            Optional[TradingStatus],
+            Field(
+                description="Trading pair status for which to fetch available exchanges"
+            ),
+        ] = 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 Available Exchanges 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_available_exchanges_sync_without_preload_content(
+                market=market,
+                symbol=symbol,
+                interval=interval,
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                quote_currency=quote_currency,
+                status=status,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
 
+        else:
+            return self._get_available_exchanges_async_without_preload_content(
+                market=market,
+                symbol=symbol,
+                interval=interval,
+                start_timestamp=start_timestamp,
+                end_timestamp=end_timestamp,
+                quote_currency=quote_currency,
+                status=status,
+                _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_available_exchanges(
+    async def _get_available_exchanges_async(
         self,
         market: Annotated[
             MarketType, Field(description="Market type (spot or futures)")
@@ -157,7 +426,7 @@ class ExchangesApi:
         ).data
 
     @validate_call
-    async def get_available_exchanges_with_http_info(
+    async def _get_available_exchanges_async_with_http_info(
         self,
         market: Annotated[
             MarketType, Field(description="Market type (spot or futures)")
@@ -265,12 +534,11 @@ class ExchangesApi:
         )
         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_available_exchanges_without_preload_content(
+    async def _get_available_exchanges_async_without_preload_content(
         self,
         market: Annotated[
             MarketType, Field(description="Market type (spot or futures)")
@@ -376,110 +644,433 @@ class ExchangesApi:
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        return response_data.response
-
-    def _get_available_exchanges_serialize(
-        self,
-        market,
-        symbol,
-        interval,
-        start_timestamp,
-        end_timestamp,
-        quote_currency,
-        status,
-        _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 market is not None:
-
-            _query_params.append(("market", market.value))
-
-        if symbol is not None:
-
-            _query_params.append(("symbol", symbol))
-
-        if interval is not None:
-
-            _query_params.append(("interval", interval.value))
-
-        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))
-
-        if quote_currency is not None:
-
-            _query_params.append(("quote_currency", quote_currency))
-
-        if status is not None:
-
-            _query_params.append(("status", status.value))
-
-        # process the header parameters
-        # process the form parameters
-        # process the body parameter
-
-        # set the HTTP header `Accept`
-        if "Accept" not in _header_params:
-            _header_params["Accept"] = self.api_client.select_header_accept(
-                ["application/json"]
-            )
-
-        # authentication setting
-        _auth_settings: List[str] = ["APIKeyHeader", "HTTPBearer"]
-
-        return self.api_client.param_serialize(
-            method="GET",
-            resource_path="/exchanges/available",
-            path_params=_path_params,
-            query_params=_query_params,
-            header_params=_header_params,
-            body=_body_params,
-            post_params=_form_params,
-            files=_files,
-            auth_settings=_auth_settings,
-            collection_formats=_collection_formats,
-            _host=_host,
-            _request_auth=_request_auth,
-        )
+        return response_data
 
+    # Private sync implementation methods
     @validate_call
-    async def get_available_exchanges_for_market(
+    def _get_available_exchanges_sync(
         self,
         market: Annotated[
             MarketType, Field(description="Market type (spot or futures)")
         ],
-        _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,
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch available exchanges for")
+        ],
+        interval: Annotated[
+            Optional[TimeInterval],
+            Field(description="Interval for which to fetch available exchanges"),
+        ] = None,
+        start_timestamp: Annotated[
+            Optional[StrictInt],
+            Field(
+                description="Start timestamp for which to fetch available exchanges (defaults to previous 7 day's closing)"
+            ),
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="End timestamp for which to fetch available exchanges"),
+        ] = None,
+        quote_currency: Annotated[
+            Optional[StrictStr],
+            Field(
+                description="Quote currency for which to fetch available exchanges (Use quote currencies endpoint to get available quote currencies)"
+            ),
+        ] = None,
+        status: Annotated[
+            Optional[TradingStatus],
+            Field(
+                description="Trading pair status for which to fetch available exchanges"
+            ),
+        ] = 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[ExchangeAvailability]:
+        """Synchronous version of get_available_exchanges"""
+        return async_to_sync(self._get_available_exchanges_async)(
+            market=market,
+            symbol=symbol,
+            interval=interval,
+            start_timestamp=start_timestamp,
+            end_timestamp=end_timestamp,
+            quote_currency=quote_currency,
+            status=status,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_available_exchanges_sync_with_http_info(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch available exchanges for")
+        ],
+        interval: Annotated[
+            Optional[TimeInterval],
+            Field(description="Interval for which to fetch available exchanges"),
+        ] = None,
+        start_timestamp: Annotated[
+            Optional[StrictInt],
+            Field(
+                description="Start timestamp for which to fetch available exchanges (defaults to previous 7 day's closing)"
+            ),
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="End timestamp for which to fetch available exchanges"),
+        ] = None,
+        quote_currency: Annotated[
+            Optional[StrictStr],
+            Field(
+                description="Quote currency for which to fetch available exchanges (Use quote currencies endpoint to get available quote currencies)"
+            ),
+        ] = None,
+        status: Annotated[
+            Optional[TradingStatus],
+            Field(
+                description="Trading pair status for which to fetch available exchanges"
+            ),
+        ] = 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[ExchangeAvailability]]:
+        """Synchronous version of get_available_exchanges_with_http_info"""
+        return async_to_sync(self._get_available_exchanges_async_with_http_info)(
+            market=market,
+            symbol=symbol,
+            interval=interval,
+            start_timestamp=start_timestamp,
+            end_timestamp=end_timestamp,
+            quote_currency=quote_currency,
+            status=status,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_available_exchanges_sync_without_preload_content(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch available exchanges for")
+        ],
+        interval: Annotated[
+            Optional[TimeInterval],
+            Field(description="Interval for which to fetch available exchanges"),
+        ] = None,
+        start_timestamp: Annotated[
+            Optional[StrictInt],
+            Field(
+                description="Start timestamp for which to fetch available exchanges (defaults to previous 7 day's closing)"
+            ),
+        ] = None,
+        end_timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="End timestamp for which to fetch available exchanges"),
+        ] = None,
+        quote_currency: Annotated[
+            Optional[StrictStr],
+            Field(
+                description="Quote currency for which to fetch available exchanges (Use quote currencies endpoint to get available quote currencies)"
+            ),
+        ] = None,
+        status: Annotated[
+            Optional[TradingStatus],
+            Field(
+                description="Trading pair status for which to fetch available exchanges"
+            ),
+        ] = 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_available_exchanges_without_preload_content"""
+        return async_to_sync(
+            self._get_available_exchanges_async_without_preload_content
+        )(
+            market=market,
+            symbol=symbol,
+            interval=interval,
+            start_timestamp=start_timestamp,
+            end_timestamp=end_timestamp,
+            quote_currency=quote_currency,
+            status=status,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    def _get_available_exchanges_serialize(
+        self,
+        market,
+        symbol,
+        interval,
+        start_timestamp,
+        end_timestamp,
+        quote_currency,
+        status,
+        _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 market is not None:
+
+            _query_params.append(("market", market.value))
+
+        if symbol is not None:
+
+            _query_params.append(("symbol", symbol))
+
+        if interval is not None:
+
+            _query_params.append(("interval", interval.value))
+
+        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))
+
+        if quote_currency is not None:
+
+            _query_params.append(("quote_currency", quote_currency))
+
+        if status is not None:
+
+            _query_params.append(("status", status.value))
+
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+        # set the HTTP header `Accept`
+        if "Accept" not in _header_params:
+            _header_params["Accept"] = self.api_client.select_header_accept(
+                ["application/json"]
+            )
+
+        # authentication setting
+        _auth_settings: List[str] = ["APIKeyHeader", "HTTPBearer"]
+
+        return self.api_client.param_serialize(
+            method="GET",
+            resource_path="/exchanges/available",
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth,
+        )
+
+    @validate_call
+    def get_available_exchanges_for_market(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        _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[str]:
+        """Get Exchange List
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_available_exchanges_for_market_sync(
+                market=market,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_available_exchanges_for_market_async(
+                market=market,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_available_exchanges_for_market_with_http_info(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        _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[str]]:
+        """Get Exchange List 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_available_exchanges_for_market_sync_with_http_info(
+                market=market,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_available_exchanges_for_market_async_with_http_info(
+                market=market,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_available_exchanges_for_market_without_preload_content(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        _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 Exchange List 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_available_exchanges_for_market_sync_without_preload_content(
+                    market=market,
+                    _request_timeout=_request_timeout,
+                    _request_auth=_request_auth,
+                    _content_type=_content_type,
+                    _headers=_headers,
+                    _host_index=_host_index,
+                )
+            )
+
+        else:
+            return (
+                self._get_available_exchanges_for_market_async_without_preload_content(
+                    market=market,
+                    _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_available_exchanges_for_market_async(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        _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[str]:
         """Get Exchange List
@@ -531,7 +1122,7 @@ class ExchangesApi:
         ).data
 
     @validate_call
-    async def get_available_exchanges_for_market_with_http_info(
+    async def _get_available_exchanges_for_market_async_with_http_info(
         self,
         market: Annotated[
             MarketType, Field(description="Market type (spot or futures)")
@@ -592,12 +1183,11 @@ class ExchangesApi:
         )
         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_available_exchanges_for_market_without_preload_content(
+    async def _get_available_exchanges_for_market_async_without_preload_content(
         self,
         market: Annotated[
             MarketType, Field(description="Market type (spot or futures)")
@@ -656,7 +1246,96 @@ class ExchangesApi:
         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_available_exchanges_for_market_sync(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        _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[str]:
+        """Synchronous version of get_available_exchanges_for_market"""
+        return async_to_sync(self._get_available_exchanges_for_market_async)(
+            market=market,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_available_exchanges_for_market_sync_with_http_info(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        _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[str]]:
+        """Synchronous version of get_available_exchanges_for_market_with_http_info"""
+        return async_to_sync(
+            self._get_available_exchanges_for_market_async_with_http_info
+        )(
+            market=market,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_available_exchanges_for_market_sync_without_preload_content(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        _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_available_exchanges_for_market_without_preload_content"""
+        return async_to_sync(
+            self._get_available_exchanges_for_market_async_without_preload_content
+        )(
+            market=market,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
 
     def _get_available_exchanges_for_market_serialize(
         self,
@@ -715,7 +1394,152 @@ class ExchangesApi:
         )
 
     @validate_call
-    async def get_exchange_mappings(
+    def get_exchange_mappings(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        exchange: Annotated[
+            Optional[InternalExchange],
+            Field(description="Exchange name for which to fetch exchange mappings"),
+        ] = 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[ExchangeMapping]:
+        """Get Exchange Mappings
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_exchange_mappings_sync(
+                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_exchange_mappings_async(
+                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_exchange_mappings_with_http_info(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        exchange: Annotated[
+            Optional[InternalExchange],
+            Field(description="Exchange name for which to fetch exchange mappings"),
+        ] = 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[ExchangeMapping]]:
+        """Get Exchange Mappings 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_exchange_mappings_sync_with_http_info(
+                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_exchange_mappings_async_with_http_info(
+                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_exchange_mappings_without_preload_content(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        exchange: Annotated[
+            Optional[InternalExchange],
+            Field(description="Exchange name for which to fetch exchange mappings"),
+        ] = 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 Exchange Mappings 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_exchange_mappings_sync_without_preload_content(
+                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_exchange_mappings_async_without_preload_content(
+                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_exchange_mappings_async(
         self,
         market: Annotated[
             MarketType, Field(description="Market type (spot or futures)")
@@ -788,7 +1612,7 @@ class ExchangesApi:
         ).data
 
     @validate_call
-    async def get_exchange_mappings_with_http_info(
+    async def _get_exchange_mappings_async_with_http_info(
         self,
         market: Annotated[
             MarketType, Field(description="Market type (spot or futures)")
@@ -856,12 +1680,11 @@ class ExchangesApi:
         )
         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_exchange_mappings_without_preload_content(
+    async def _get_exchange_mappings_async_without_preload_content(
         self,
         market: Annotated[
             MarketType, Field(description="Market type (spot or futures)")
@@ -921,14 +1744,114 @@ class ExchangesApi:
             _host_index=_host_index,
         )
 
-        _response_types_map: Dict[str, Optional[str]] = {
-            "200": "List[ExchangeMapping]",
-        }
-        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[ExchangeMapping]",
+        }
+        response_data = await self.api_client.call_api(
+            *_param, _request_timeout=_request_timeout
+        )
+        return response_data
+
+    # Private sync implementation methods
+    @validate_call
+    def _get_exchange_mappings_sync(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        exchange: Annotated[
+            Optional[InternalExchange],
+            Field(description="Exchange name for which to fetch exchange mappings"),
+        ] = 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[ExchangeMapping]:
+        """Synchronous version of get_exchange_mappings"""
+        return async_to_sync(self._get_exchange_mappings_async)(
+            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_exchange_mappings_sync_with_http_info(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        exchange: Annotated[
+            Optional[InternalExchange],
+            Field(description="Exchange name for which to fetch exchange mappings"),
+        ] = 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[ExchangeMapping]]:
+        """Synchronous version of get_exchange_mappings_with_http_info"""
+        return async_to_sync(self._get_exchange_mappings_async_with_http_info)(
+            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_exchange_mappings_sync_without_preload_content(
+        self,
+        market: Annotated[
+            MarketType, Field(description="Market type (spot or futures)")
+        ],
+        exchange: Annotated[
+            Optional[InternalExchange],
+            Field(description="Exchange name for which to fetch exchange mappings"),
+        ] = 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_exchange_mappings_without_preload_content"""
+        return async_to_sync(self._get_exchange_mappings_async_without_preload_content)(
+            market=market,
+            exchange=exchange,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
     def _get_exchange_mappings_serialize(
         self,
         market,
@@ -991,12 +1914,208 @@ class ExchangesApi:
         )
 
     @validate_call
-    async def get_exchange_mappings_for_pair(
+    def get_exchange_mappings_for_pair(
+        self,
+        pair: Annotated[
+            StrictStr,
+            Field(
+                description="Trading pair to find mappings for. Can be exchange specific (e.g., 'BTCUSDT', '1000SHIBUSDT') or a common format Symbol/QuoteCurrency (e.g., 'BTC/USDT')"
+            ),
+        ],
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="Market type (spot or futures). Defaults to futures."),
+        ] = None,
+        exchange: Annotated[
+            Optional[InternalExchange],
+            Field(
+                description="Optional exchange name to filter by. If not provided, returns all exchanges a match was found for."
+            ),
+        ] = None,
+        quote_currency: Annotated[
+            Optional[StrictStr],
+            Field(description="Quote currency to filter by. Defaults to USDT."),
+        ] = 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[ExchangeMapping]:
+        """Get Exchange Mappings For Pair
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_exchange_mappings_for_pair_sync(
+                pair=pair,
+                market=market,
+                exchange=exchange,
+                quote_currency=quote_currency,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_exchange_mappings_for_pair_async(
+                pair=pair,
+                market=market,
+                exchange=exchange,
+                quote_currency=quote_currency,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_exchange_mappings_for_pair_with_http_info(
+        self,
+        pair: Annotated[
+            StrictStr,
+            Field(
+                description="Trading pair to find mappings for. Can be exchange specific (e.g., 'BTCUSDT', '1000SHIBUSDT') or a common format Symbol/QuoteCurrency (e.g., 'BTC/USDT')"
+            ),
+        ],
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="Market type (spot or futures). Defaults to futures."),
+        ] = None,
+        exchange: Annotated[
+            Optional[InternalExchange],
+            Field(
+                description="Optional exchange name to filter by. If not provided, returns all exchanges a match was found for."
+            ),
+        ] = None,
+        quote_currency: Annotated[
+            Optional[StrictStr],
+            Field(description="Quote currency to filter by. Defaults to USDT."),
+        ] = 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[ExchangeMapping]]:
+        """Get Exchange Mappings For Pair 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_exchange_mappings_for_pair_sync_with_http_info(
+                pair=pair,
+                market=market,
+                exchange=exchange,
+                quote_currency=quote_currency,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_exchange_mappings_for_pair_async_with_http_info(
+                pair=pair,
+                market=market,
+                exchange=exchange,
+                quote_currency=quote_currency,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_exchange_mappings_for_pair_without_preload_content(
+        self,
+        pair: Annotated[
+            StrictStr,
+            Field(
+                description="Trading pair to find mappings for. Can be exchange specific (e.g., 'BTCUSDT', '1000SHIBUSDT') or a common format Symbol/QuoteCurrency (e.g., 'BTC/USDT')"
+            ),
+        ],
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="Market type (spot or futures). Defaults to futures."),
+        ] = None,
+        exchange: Annotated[
+            Optional[InternalExchange],
+            Field(
+                description="Optional exchange name to filter by. If not provided, returns all exchanges a match was found for."
+            ),
+        ] = None,
+        quote_currency: Annotated[
+            Optional[StrictStr],
+            Field(description="Quote currency to filter by. Defaults to USDT."),
+        ] = 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 Exchange Mappings For Pair 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_exchange_mappings_for_pair_sync_without_preload_content(
+                pair=pair,
+                market=market,
+                exchange=exchange,
+                quote_currency=quote_currency,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_exchange_mappings_for_pair_async_without_preload_content(
+                pair=pair,
+                market=market,
+                exchange=exchange,
+                quote_currency=quote_currency,
+                _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_exchange_mappings_for_pair_async(
         self,
         pair: Annotated[
             StrictStr,
             Field(
-                description="Trading pair to find mappings for (e.g., 'BTCUSDT', '1000SHIBUSDT')"
+                description="Trading pair to find mappings for. Can be exchange specific (e.g., 'BTCUSDT', '1000SHIBUSDT') or a common format Symbol/QuoteCurrency (e.g., 'BTC/USDT')"
             ),
         ],
         market: Annotated[
@@ -1006,7 +2125,7 @@ class ExchangesApi:
         exchange: Annotated[
             Optional[InternalExchange],
             Field(
-                description="Optional exchange name to filter by. If not provided, returns all exchanges."
+                description="Optional exchange name to filter by. If not provided, returns all exchanges a match was found for."
             ),
         ] = None,
         quote_currency: Annotated[
@@ -1029,11 +2148,11 @@ class ExchangesApi:
 
         Get exchange mappings for a specific trading pair across all exchanges or a specific exchange. This endpoint finds the underlying symbol for a given pair and returns all perpetual contracts (excluding quarterly/dated contracts) with the specified quote currency.
 
-        :param pair: Trading pair to find mappings for (e.g., 'BTCUSDT', '1000SHIBUSDT') (required)
+        :param pair: Trading pair to find mappings for. Can be exchange specific (e.g., 'BTCUSDT', '1000SHIBUSDT') or a common format Symbol/QuoteCurrency (e.g., 'BTC/USDT') (required)
         :type pair: str
         :param market: Market type (spot or futures). Defaults to futures.
         :type market: MarketType
-        :param exchange: Optional exchange name to filter by. If not provided, returns all exchanges.
+        :param exchange: Optional exchange name to filter by. If not provided, returns all exchanges a match was found for.
         :type exchange: InternalExchange
         :param quote_currency: Quote currency to filter by. Defaults to USDT.
         :type quote_currency: str
@@ -1083,12 +2202,12 @@ class ExchangesApi:
         ).data
 
     @validate_call
-    async def get_exchange_mappings_for_pair_with_http_info(
+    async def _get_exchange_mappings_for_pair_async_with_http_info(
         self,
         pair: Annotated[
             StrictStr,
             Field(
-                description="Trading pair to find mappings for (e.g., 'BTCUSDT', '1000SHIBUSDT')"
+                description="Trading pair to find mappings for. Can be exchange specific (e.g., 'BTCUSDT', '1000SHIBUSDT') or a common format Symbol/QuoteCurrency (e.g., 'BTC/USDT')"
             ),
         ],
         market: Annotated[
@@ -1098,7 +2217,7 @@ class ExchangesApi:
         exchange: Annotated[
             Optional[InternalExchange],
             Field(
-                description="Optional exchange name to filter by. If not provided, returns all exchanges."
+                description="Optional exchange name to filter by. If not provided, returns all exchanges a match was found for."
             ),
         ] = None,
         quote_currency: Annotated[
@@ -1121,11 +2240,11 @@ class ExchangesApi:
 
         Get exchange mappings for a specific trading pair across all exchanges or a specific exchange. This endpoint finds the underlying symbol for a given pair and returns all perpetual contracts (excluding quarterly/dated contracts) with the specified quote currency.
 
-        :param pair: Trading pair to find mappings for (e.g., 'BTCUSDT', '1000SHIBUSDT') (required)
+        :param pair: Trading pair to find mappings for. Can be exchange specific (e.g., 'BTCUSDT', '1000SHIBUSDT') or a common format Symbol/QuoteCurrency (e.g., 'BTC/USDT') (required)
         :type pair: str
         :param market: Market type (spot or futures). Defaults to futures.
         :type market: MarketType
-        :param exchange: Optional exchange name to filter by. If not provided, returns all exchanges.
+        :param exchange: Optional exchange name to filter by. If not provided, returns all exchanges a match was found for.
         :type exchange: InternalExchange
         :param quote_currency: Quote currency to filter by. Defaults to USDT.
         :type quote_currency: str
@@ -1170,17 +2289,16 @@ class ExchangesApi:
         )
         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_exchange_mappings_for_pair_without_preload_content(
+    async def _get_exchange_mappings_for_pair_async_without_preload_content(
         self,
         pair: Annotated[
             StrictStr,
             Field(
-                description="Trading pair to find mappings for (e.g., 'BTCUSDT', '1000SHIBUSDT')"
+                description="Trading pair to find mappings for. Can be exchange specific (e.g., 'BTCUSDT', '1000SHIBUSDT') or a common format Symbol/QuoteCurrency (e.g., 'BTC/USDT')"
             ),
         ],
         market: Annotated[
@@ -1190,7 +2308,7 @@ class ExchangesApi:
         exchange: Annotated[
             Optional[InternalExchange],
             Field(
-                description="Optional exchange name to filter by. If not provided, returns all exchanges."
+                description="Optional exchange name to filter by. If not provided, returns all exchanges a match was found for."
             ),
         ] = None,
         quote_currency: Annotated[
@@ -1213,11 +2331,11 @@ class ExchangesApi:
 
         Get exchange mappings for a specific trading pair across all exchanges or a specific exchange. This endpoint finds the underlying symbol for a given pair and returns all perpetual contracts (excluding quarterly/dated contracts) with the specified quote currency.
 
-        :param pair: Trading pair to find mappings for (e.g., 'BTCUSDT', '1000SHIBUSDT') (required)
+        :param pair: Trading pair to find mappings for. Can be exchange specific (e.g., 'BTCUSDT', '1000SHIBUSDT') or a common format Symbol/QuoteCurrency (e.g., 'BTC/USDT') (required)
         :type pair: str
         :param market: Market type (spot or futures). Defaults to futures.
         :type market: MarketType
-        :param exchange: Optional exchange name to filter by. If not provided, returns all exchanges.
+        :param exchange: Optional exchange name to filter by. If not provided, returns all exchanges a match was found for.
         :type exchange: InternalExchange
         :param quote_currency: Quote currency to filter by. Defaults to USDT.
         :type quote_currency: str
@@ -1260,7 +2378,154 @@ class ExchangesApi:
         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_exchange_mappings_for_pair_sync(
+        self,
+        pair: Annotated[
+            StrictStr,
+            Field(
+                description="Trading pair to find mappings for. Can be exchange specific (e.g., 'BTCUSDT', '1000SHIBUSDT') or a common format Symbol/QuoteCurrency (e.g., 'BTC/USDT')"
+            ),
+        ],
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="Market type (spot or futures). Defaults to futures."),
+        ] = None,
+        exchange: Annotated[
+            Optional[InternalExchange],
+            Field(
+                description="Optional exchange name to filter by. If not provided, returns all exchanges a match was found for."
+            ),
+        ] = None,
+        quote_currency: Annotated[
+            Optional[StrictStr],
+            Field(description="Quote currency to filter by. Defaults to USDT."),
+        ] = 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[ExchangeMapping]:
+        """Synchronous version of get_exchange_mappings_for_pair"""
+        return async_to_sync(self._get_exchange_mappings_for_pair_async)(
+            pair=pair,
+            market=market,
+            exchange=exchange,
+            quote_currency=quote_currency,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_exchange_mappings_for_pair_sync_with_http_info(
+        self,
+        pair: Annotated[
+            StrictStr,
+            Field(
+                description="Trading pair to find mappings for. Can be exchange specific (e.g., 'BTCUSDT', '1000SHIBUSDT') or a common format Symbol/QuoteCurrency (e.g., 'BTC/USDT')"
+            ),
+        ],
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="Market type (spot or futures). Defaults to futures."),
+        ] = None,
+        exchange: Annotated[
+            Optional[InternalExchange],
+            Field(
+                description="Optional exchange name to filter by. If not provided, returns all exchanges a match was found for."
+            ),
+        ] = None,
+        quote_currency: Annotated[
+            Optional[StrictStr],
+            Field(description="Quote currency to filter by. Defaults to USDT."),
+        ] = 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[ExchangeMapping]]:
+        """Synchronous version of get_exchange_mappings_for_pair_with_http_info"""
+        return async_to_sync(self._get_exchange_mappings_for_pair_async_with_http_info)(
+            pair=pair,
+            market=market,
+            exchange=exchange,
+            quote_currency=quote_currency,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_exchange_mappings_for_pair_sync_without_preload_content(
+        self,
+        pair: Annotated[
+            StrictStr,
+            Field(
+                description="Trading pair to find mappings for. Can be exchange specific (e.g., 'BTCUSDT', '1000SHIBUSDT') or a common format Symbol/QuoteCurrency (e.g., 'BTC/USDT')"
+            ),
+        ],
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="Market type (spot or futures). Defaults to futures."),
+        ] = None,
+        exchange: Annotated[
+            Optional[InternalExchange],
+            Field(
+                description="Optional exchange name to filter by. If not provided, returns all exchanges a match was found for."
+            ),
+        ] = None,
+        quote_currency: Annotated[
+            Optional[StrictStr],
+            Field(description="Quote currency to filter by. Defaults to USDT."),
+        ] = 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_exchange_mappings_for_pair_without_preload_content"""
+        return async_to_sync(
+            self._get_exchange_mappings_for_pair_async_without_preload_content
+        )(
+            pair=pair,
+            market=market,
+            exchange=exchange,
+            quote_currency=quote_currency,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
 
     def _get_exchange_mappings_for_pair_serialize(
         self,