crypticorn 2.4.7__py3-none-any.whl → 2.5.0__py3-none-any.whl

crypticorn/klines/client/api/udf_api.py

@@ -19,8 +19,8 @@ from typing_extensions import Annotated
 from pydantic import StrictInt, StrictStr
 from typing import Any, List, Optional
 from crypticorn.klines.client.models.resolution import Resolution
-from crypticorn.klines.client.models.response_get_history_udf_history_get import (
-    ResponseGetHistoryUdfHistoryGet,
+from crypticorn.klines.client.models.response_get_udf_history import (
+    ResponseGetUdfHistory,
 )
 from crypticorn.klines.client.models.search_symbol_response import SearchSymbolResponse
 from crypticorn.klines.client.models.symbol_group_response import SymbolGroupResponse
@@ -45,7 +45,7 @@ class UDFApi:
         self.api_client = api_client
 
     @validate_call
-    def get_config_udf_config_get(
+    async def get_server_time(
         self,
         _request_timeout: Union[
             None,
@@ -58,8 +58,8 @@ class UDFApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> UDFConfigResponse:
-        """Get Config
+    ) -> object:
+        """Get Server Time
 
 
         :param _request_timeout: timeout setting for this request. If one
@@ -84,7 +84,7 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._get_config_udf_config_get_serialize(
+        _param = self._get_server_time_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -92,19 +92,19 @@ class UDFApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "UDFConfigResponse",
+            "200": "object",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        response_data.read()
+        await response_data.read()
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
         ).data
 
     @validate_call
-    def get_config_udf_config_get_with_http_info(
+    async def get_server_time_with_http_info(
         self,
         _request_timeout: Union[
             None,
@@ -117,8 +117,8 @@ class UDFApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[UDFConfigResponse]:
-        """Get Config
+    ) -> ApiResponse[object]:
+        """Get Server Time
 
 
         :param _request_timeout: timeout setting for this request. If one
@@ -143,7 +143,7 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._get_config_udf_config_get_serialize(
+        _param = self._get_server_time_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -151,19 +151,19 @@ class UDFApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "UDFConfigResponse",
+            "200": "object",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        response_data.read()
+        await response_data.read()
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
         )
 
     @validate_call
-    def get_config_udf_config_get_without_preload_content(
+    async def get_server_time_without_preload_content(
         self,
         _request_timeout: Union[
             None,
@@ -177,7 +177,7 @@ class UDFApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Get Config
+        """Get Server Time
 
 
         :param _request_timeout: timeout setting for this request. If one
@@ -202,7 +202,7 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._get_config_udf_config_get_serialize(
+        _param = self._get_server_time_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -210,14 +210,14 @@ class UDFApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "UDFConfigResponse",
+            "200": "object",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
         return response_data.response
 
-    def _get_config_udf_config_get_serialize(
+    def _get_server_time_serialize(
         self,
         _request_auth,
         _content_type,
@@ -251,11 +251,11 @@ class UDFApi:
             )
 
         # authentication setting
-        _auth_settings: List[str] = []
+        _auth_settings: List[str] = ["APIKeyHeader", "HTTPBearer"]
 
         return self.api_client.param_serialize(
             method="GET",
-            resource_path="/udf/config",
+            resource_path="/udf/time",
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -269,13 +269,9 @@ class UDFApi:
         )
 
     @validate_call
-    def get_history_udf_history_get(
+    async def get_symbol(
         self,
         symbol: StrictStr,
-        resolution: Resolution,
-        var_from: StrictInt,
-        to: StrictInt,
-        countback: Optional[StrictInt] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -287,20 +283,12 @@ class UDFApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ResponseGetHistoryUdfHistoryGet:
-        """Get History
+    ) -> SymbolInfoResponse:
+        """Get Symbol
 
 
         :param symbol: (required)
         :type symbol: str
-        :param resolution: (required)
-        :type resolution: Resolution
-        :param var_from: (required)
-        :type var_from: int
-        :param to: (required)
-        :type to: int
-        :param countback:
-        :type countback: int
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -323,12 +311,8 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._get_history_udf_history_get_serialize(
+        _param = self._get_symbol_serialize(
             symbol=symbol,
-            resolution=resolution,
-            var_from=var_from,
-            to=to,
-            countback=countback,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -336,26 +320,22 @@ class UDFApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "ResponseGetHistoryUdfHistoryGet",
+            "200": "SymbolInfoResponse",
             "422": "HTTPValidationError",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        response_data.read()
+        await response_data.read()
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
         ).data
 
     @validate_call
-    def get_history_udf_history_get_with_http_info(
+    async def get_symbol_with_http_info(
         self,
         symbol: StrictStr,
-        resolution: Resolution,
-        var_from: StrictInt,
-        to: StrictInt,
-        countback: Optional[StrictInt] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -367,20 +347,12 @@ class UDFApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[ResponseGetHistoryUdfHistoryGet]:
-        """Get History
+    ) -> ApiResponse[SymbolInfoResponse]:
+        """Get Symbol
 
 
         :param symbol: (required)
         :type symbol: str
-        :param resolution: (required)
-        :type resolution: Resolution
-        :param var_from: (required)
-        :type var_from: int
-        :param to: (required)
-        :type to: int
-        :param countback:
-        :type countback: int
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -403,12 +375,8 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._get_history_udf_history_get_serialize(
+        _param = self._get_symbol_serialize(
             symbol=symbol,
-            resolution=resolution,
-            var_from=var_from,
-            to=to,
-            countback=countback,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -416,26 +384,22 @@ class UDFApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "ResponseGetHistoryUdfHistoryGet",
+            "200": "SymbolInfoResponse",
             "422": "HTTPValidationError",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        response_data.read()
+        await response_data.read()
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
         )
 
     @validate_call
-    def get_history_udf_history_get_without_preload_content(
+    async def get_symbol_without_preload_content(
         self,
         symbol: StrictStr,
-        resolution: Resolution,
-        var_from: StrictInt,
-        to: StrictInt,
-        countback: Optional[StrictInt] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -448,19 +412,11 @@ class UDFApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Get History
+        """Get Symbol
 
 
         :param symbol: (required)
         :type symbol: str
-        :param resolution: (required)
-        :type resolution: Resolution
-        :param var_from: (required)
-        :type var_from: int
-        :param to: (required)
-        :type to: int
-        :param countback:
-        :type countback: int
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -483,12 +439,8 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._get_history_udf_history_get_serialize(
+        _param = self._get_symbol_serialize(
             symbol=symbol,
-            resolution=resolution,
-            var_from=var_from,
-            to=to,
-            countback=countback,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -496,21 +448,17 @@ class UDFApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "ResponseGetHistoryUdfHistoryGet",
+            "200": "SymbolInfoResponse",
             "422": "HTTPValidationError",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
         return response_data.response
 
-    def _get_history_udf_history_get_serialize(
+    def _get_symbol_serialize(
         self,
         symbol,
-        resolution,
-        var_from,
-        to,
-        countback,
         _request_auth,
         _content_type,
         _headers,
@@ -536,22 +484,6 @@ class UDFApi:
 
             _query_params.append(("symbol", symbol))
 
-        if resolution is not None:
-
-            _query_params.append(("resolution", resolution.value))
-
-        if var_from is not None:
-
-            _query_params.append(("from", var_from))
-
-        if to is not None:
-
-            _query_params.append(("to", to))
-
-        if countback is not None:
-
-            _query_params.append(("countback", countback))
-
         # process the header parameters
         # process the form parameters
         # process the body parameter
@@ -563,11 +495,11 @@ class UDFApi:
             )
 
         # authentication setting
-        _auth_settings: List[str] = []
+        _auth_settings: List[str] = ["APIKeyHeader", "HTTPBearer"]
 
         return self.api_client.param_serialize(
             method="GET",
-            resource_path="/udf/history",
+            resource_path="/udf/symbols",
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -581,8 +513,9 @@ class UDFApi:
         )
 
     @validate_call
-    def get_server_time_udf_time_get(
+    async def get_symbol_info(
         self,
+        group: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -594,10 +527,13 @@ class UDFApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> object:
-        """Get Server Time
+    ) -> SymbolGroupResponse:
+        """Get Symbol Info
 
+        Handle symbol info requests for different groups
 
+        :param group: (required)
+        :type group: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -620,7 +556,8 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._get_server_time_udf_time_get_serialize(
+        _param = self._get_symbol_info_serialize(
+            group=group,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -628,20 +565,22 @@ class UDFApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "object",
+            "200": "SymbolGroupResponse",
+            "422": "HTTPValidationError",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        response_data.read()
+        await response_data.read()
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
         ).data
 
     @validate_call
-    def get_server_time_udf_time_get_with_http_info(
+    async def get_symbol_info_with_http_info(
         self,
+        group: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -653,10 +592,13 @@ class UDFApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[object]:
-        """Get Server Time
+    ) -> ApiResponse[SymbolGroupResponse]:
+        """Get Symbol Info
 
+        Handle symbol info requests for different groups
 
+        :param group: (required)
+        :type group: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -679,7 +621,8 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._get_server_time_udf_time_get_serialize(
+        _param = self._get_symbol_info_serialize(
+            group=group,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -687,20 +630,22 @@ class UDFApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "object",
+            "200": "SymbolGroupResponse",
+            "422": "HTTPValidationError",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        response_data.read()
+        await response_data.read()
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
         )
 
     @validate_call
-    def get_server_time_udf_time_get_without_preload_content(
+    async def get_symbol_info_without_preload_content(
         self,
+        group: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -713,9 +658,12 @@ class UDFApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Get Server Time
+        """Get Symbol Info
 
+        Handle symbol info requests for different groups
 
+        :param group: (required)
+        :type group: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -738,7 +686,8 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._get_server_time_udf_time_get_serialize(
+        _param = self._get_symbol_info_serialize(
+            group=group,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -746,15 +695,17 @@ class UDFApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "object",
+            "200": "SymbolGroupResponse",
+            "422": "HTTPValidationError",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
         return response_data.response
 
-    def _get_server_time_udf_time_get_serialize(
+    def _get_symbol_info_serialize(
         self,
+        group,
         _request_auth,
         _content_type,
         _headers,
@@ -776,6 +727,10 @@ class UDFApi:
 
         # process the path parameters
         # process the query parameters
+        if group is not None:
+
+            _query_params.append(("group", group))
+
         # process the header parameters
         # process the form parameters
         # process the body parameter
@@ -787,11 +742,11 @@ class UDFApi:
             )
 
         # authentication setting
-        _auth_settings: List[str] = []
+        _auth_settings: List[str] = ["APIKeyHeader", "HTTPBearer"]
 
         return self.api_client.param_serialize(
             method="GET",
-            resource_path="/udf/time",
+            resource_path="/udf/symbol_info",
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -805,9 +760,8 @@ class UDFApi:
         )
 
     @validate_call
-    def get_symbol_info_udf_symbol_info_get(
+    async def get_udf_config(
         self,
-        group: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -819,13 +773,10 @@ class UDFApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> SymbolGroupResponse:
-        """Get Symbol Info
+    ) -> UDFConfigResponse:
+        """Get Config
 
-        Handle symbol info requests for different groups
 
-        :param group: (required)
-        :type group: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -848,8 +799,7 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._get_symbol_info_udf_symbol_info_get_serialize(
-            group=group,
+        _param = self._get_udf_config_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -857,22 +807,20 @@ class UDFApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "SymbolGroupResponse",
-            "422": "HTTPValidationError",
+            "200": "UDFConfigResponse",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        response_data.read()
+        await response_data.read()
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
         ).data
 
     @validate_call
-    def get_symbol_info_udf_symbol_info_get_with_http_info(
+    async def get_udf_config_with_http_info(
         self,
-        group: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -884,13 +832,10 @@ class UDFApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[SymbolGroupResponse]:
-        """Get Symbol Info
+    ) -> ApiResponse[UDFConfigResponse]:
+        """Get Config
 
-        Handle symbol info requests for different groups
 
-        :param group: (required)
-        :type group: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -913,8 +858,7 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._get_symbol_info_udf_symbol_info_get_serialize(
-            group=group,
+        _param = self._get_udf_config_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -922,22 +866,20 @@ class UDFApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "SymbolGroupResponse",
-            "422": "HTTPValidationError",
+            "200": "UDFConfigResponse",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        response_data.read()
+        await response_data.read()
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
         )
 
     @validate_call
-    def get_symbol_info_udf_symbol_info_get_without_preload_content(
+    async def get_udf_config_without_preload_content(
         self,
-        group: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -950,12 +892,9 @@ class UDFApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Get Symbol Info
+        """Get Config
 
-        Handle symbol info requests for different groups
 
-        :param group: (required)
-        :type group: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -978,8 +917,7 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._get_symbol_info_udf_symbol_info_get_serialize(
-            group=group,
+        _param = self._get_udf_config_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -987,17 +925,15 @@ class UDFApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "SymbolGroupResponse",
-            "422": "HTTPValidationError",
+            "200": "UDFConfigResponse",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
         return response_data.response
 
-    def _get_symbol_info_udf_symbol_info_get_serialize(
+    def _get_udf_config_serialize(
         self,
-        group,
         _request_auth,
         _content_type,
         _headers,
@@ -1019,10 +955,6 @@ class UDFApi:
 
         # process the path parameters
         # process the query parameters
-        if group is not None:
-
-            _query_params.append(("group", group))
-
         # process the header parameters
         # process the form parameters
         # process the body parameter
@@ -1034,11 +966,11 @@ class UDFApi:
             )
 
         # authentication setting
-        _auth_settings: List[str] = []
+        _auth_settings: List[str] = ["APIKeyHeader", "HTTPBearer"]
 
         return self.api_client.param_serialize(
             method="GET",
-            resource_path="/udf/symbol_info",
+            resource_path="/udf/config",
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1052,9 +984,13 @@ class UDFApi:
         )
 
     @validate_call
-    def get_symbol_udf_symbols_get(
+    async def get_udf_history(
         self,
         symbol: StrictStr,
+        resolution: Resolution,
+        var_from: StrictInt,
+        to: StrictInt,
+        countback: Optional[StrictInt] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1066,12 +1002,20 @@ class UDFApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> SymbolInfoResponse:
-        """Get Symbol
+    ) -> ResponseGetUdfHistory:
+        """Get History
 
 
         :param symbol: (required)
         :type symbol: str
+        :param resolution: (required)
+        :type resolution: Resolution
+        :param var_from: (required)
+        :type var_from: int
+        :param to: (required)
+        :type to: int
+        :param countback:
+        :type countback: int
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1094,8 +1038,12 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._get_symbol_udf_symbols_get_serialize(
+        _param = self._get_udf_history_serialize(
             symbol=symbol,
+            resolution=resolution,
+            var_from=var_from,
+            to=to,
+            countback=countback,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1103,22 +1051,26 @@ class UDFApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "SymbolInfoResponse",
+            "200": "ResponseGetUdfHistory",
             "422": "HTTPValidationError",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        response_data.read()
+        await response_data.read()
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
         ).data
 
     @validate_call
-    def get_symbol_udf_symbols_get_with_http_info(
+    async def get_udf_history_with_http_info(
         self,
         symbol: StrictStr,
+        resolution: Resolution,
+        var_from: StrictInt,
+        to: StrictInt,
+        countback: Optional[StrictInt] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1130,12 +1082,20 @@ class UDFApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[SymbolInfoResponse]:
-        """Get Symbol
+    ) -> ApiResponse[ResponseGetUdfHistory]:
+        """Get History
 
 
         :param symbol: (required)
         :type symbol: str
+        :param resolution: (required)
+        :type resolution: Resolution
+        :param var_from: (required)
+        :type var_from: int
+        :param to: (required)
+        :type to: int
+        :param countback:
+        :type countback: int
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1158,8 +1118,12 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._get_symbol_udf_symbols_get_serialize(
+        _param = self._get_udf_history_serialize(
             symbol=symbol,
+            resolution=resolution,
+            var_from=var_from,
+            to=to,
+            countback=countback,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1167,22 +1131,26 @@ class UDFApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "SymbolInfoResponse",
+            "200": "ResponseGetUdfHistory",
             "422": "HTTPValidationError",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        response_data.read()
+        await response_data.read()
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
         )
 
     @validate_call
-    def get_symbol_udf_symbols_get_without_preload_content(
+    async def get_udf_history_without_preload_content(
         self,
         symbol: StrictStr,
+        resolution: Resolution,
+        var_from: StrictInt,
+        to: StrictInt,
+        countback: Optional[StrictInt] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1195,11 +1163,19 @@ class UDFApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Get Symbol
+        """Get History
 
 
         :param symbol: (required)
         :type symbol: str
+        :param resolution: (required)
+        :type resolution: Resolution
+        :param var_from: (required)
+        :type var_from: int
+        :param to: (required)
+        :type to: int
+        :param countback:
+        :type countback: int
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1222,8 +1198,12 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._get_symbol_udf_symbols_get_serialize(
+        _param = self._get_udf_history_serialize(
             symbol=symbol,
+            resolution=resolution,
+            var_from=var_from,
+            to=to,
+            countback=countback,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1231,17 +1211,21 @@ class UDFApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            "200": "SymbolInfoResponse",
+            "200": "ResponseGetUdfHistory",
             "422": "HTTPValidationError",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
         return response_data.response
 
-    def _get_symbol_udf_symbols_get_serialize(
+    def _get_udf_history_serialize(
         self,
         symbol,
+        resolution,
+        var_from,
+        to,
+        countback,
         _request_auth,
         _content_type,
         _headers,
@@ -1267,6 +1251,22 @@ class UDFApi:
 
             _query_params.append(("symbol", symbol))
 
+        if resolution is not None:
+
+            _query_params.append(("resolution", resolution.value))
+
+        if var_from is not None:
+
+            _query_params.append(("from", var_from))
+
+        if to is not None:
+
+            _query_params.append(("to", to))
+
+        if countback is not None:
+
+            _query_params.append(("countback", countback))
+
         # process the header parameters
         # process the form parameters
         # process the body parameter
@@ -1278,11 +1278,11 @@ class UDFApi:
             )
 
         # authentication setting
-        _auth_settings: List[str] = []
+        _auth_settings: List[str] = ["APIKeyHeader", "HTTPBearer"]
 
         return self.api_client.param_serialize(
             method="GET",
-            resource_path="/udf/symbols",
+            resource_path="/udf/history",
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1296,7 +1296,7 @@ class UDFApi:
         )
 
     @validate_call
-    def options_handler_udf_path_options(
+    async def options_handler(
         self,
         path: StrictStr,
         _request_timeout: Union[
@@ -1339,7 +1339,7 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._options_handler_udf_path_options_serialize(
+        _param = self._options_handler_serialize(
             path=path,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -1351,17 +1351,17 @@ class UDFApi:
             "200": "object",
             "422": "HTTPValidationError",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        response_data.read()
+        await response_data.read()
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
         ).data
 
     @validate_call
-    def options_handler_udf_path_options_with_http_info(
+    async def options_handler_with_http_info(
         self,
         path: StrictStr,
         _request_timeout: Union[
@@ -1404,7 +1404,7 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._options_handler_udf_path_options_serialize(
+        _param = self._options_handler_serialize(
             path=path,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -1416,17 +1416,17 @@ class UDFApi:
             "200": "object",
             "422": "HTTPValidationError",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        response_data.read()
+        await response_data.read()
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
         )
 
     @validate_call
-    def options_handler_udf_path_options_without_preload_content(
+    async def options_handler_without_preload_content(
         self,
         path: StrictStr,
         _request_timeout: Union[
@@ -1469,7 +1469,7 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._options_handler_udf_path_options_serialize(
+        _param = self._options_handler_serialize(
             path=path,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -1481,12 +1481,12 @@ class UDFApi:
             "200": "object",
             "422": "HTTPValidationError",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
         return response_data.response
 
-    def _options_handler_udf_path_options_serialize(
+    def _options_handler_serialize(
         self,
         path,
         _request_auth,
@@ -1523,7 +1523,7 @@ class UDFApi:
             )
 
         # authentication setting
-        _auth_settings: List[str] = []
+        _auth_settings: List[str] = ["APIKeyHeader", "HTTPBearer"]
 
         return self.api_client.param_serialize(
             method="OPTIONS",
@@ -1541,7 +1541,7 @@ class UDFApi:
         )
 
     @validate_call
-    def search_symbols_udf_search_get(
+    async def search_symbols(
         self,
         query: StrictStr,
         limit: Optional[StrictInt] = None,
@@ -1587,7 +1587,7 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._search_symbols_udf_search_get_serialize(
+        _param = self._search_symbols_serialize(
             query=query,
             limit=limit,
             _request_auth=_request_auth,
@@ -1600,17 +1600,17 @@ class UDFApi:
             "200": "List[SearchSymbolResponse]",
             "422": "HTTPValidationError",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        response_data.read()
+        await response_data.read()
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
         ).data
 
     @validate_call
-    def search_symbols_udf_search_get_with_http_info(
+    async def search_symbols_with_http_info(
         self,
         query: StrictStr,
         limit: Optional[StrictInt] = None,
@@ -1656,7 +1656,7 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._search_symbols_udf_search_get_serialize(
+        _param = self._search_symbols_serialize(
             query=query,
             limit=limit,
             _request_auth=_request_auth,
@@ -1669,17 +1669,17 @@ class UDFApi:
             "200": "List[SearchSymbolResponse]",
             "422": "HTTPValidationError",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        response_data.read()
+        await response_data.read()
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
         )
 
     @validate_call
-    def search_symbols_udf_search_get_without_preload_content(
+    async def search_symbols_without_preload_content(
         self,
         query: StrictStr,
         limit: Optional[StrictInt] = None,
@@ -1725,7 +1725,7 @@ class UDFApi:
         :return: Returns the result object.
         """  # noqa: E501
 
-        _param = self._search_symbols_udf_search_get_serialize(
+        _param = self._search_symbols_serialize(
             query=query,
             limit=limit,
             _request_auth=_request_auth,
@@ -1738,12 +1738,12 @@ class UDFApi:
             "200": "List[SearchSymbolResponse]",
             "422": "HTTPValidationError",
         }
-        response_data = self.api_client.call_api(
+        response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
         return response_data.response
 
-    def _search_symbols_udf_search_get_serialize(
+    def _search_symbols_serialize(
         self,
         query,
         limit,
@@ -1787,7 +1787,7 @@ class UDFApi:
             )
 
         # authentication setting
-        _auth_settings: List[str] = []
+        _auth_settings: List[str] = ["APIKeyHeader", "HTTPBearer"]
 
         return self.api_client.param_serialize(
             method="GET",