wds-client 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

wds_client/api/records_api.py

@@ -3,1207 +3,2630 @@
 """
     Workspace Data Service
 
-    This page lists current APIs. As of v0.2, all APIs are subject to change without notice.   # noqa: E501
+    This page lists current APIs.  All v0.2 APIs are subject to change without notice.  Changelog at [https://github.com/DataBiosphere/terra-workspace-data-service/releases](https://github.com/DataBiosphere/terra-workspace-data-service/releases) 
 
     The version of the OpenAPI document: v0.2
-    Generated by: https://openapi-generator.tech
-"""
-
-
-from __future__ import absolute_import
-
-import re  # noqa: F401
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
 
-# python 2 and python 3 compatibility library
-import six
-
-from wds_client.api_client import ApiClient
-from wds_client.exceptions import (  # noqa: F401
-    ApiTypeError,
-    ApiValueError
-)
-
-
-class RecordsApi(object):
+    Do not edit the class manually.
+"""  # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictBytes, StrictStr
+from typing import List, Optional, Union
+from typing_extensions import Annotated
+from wds_client.models.batch_operation import BatchOperation
+from wds_client.models.batch_response import BatchResponse
+from wds_client.models.record_query_response import RecordQueryResponse
+from wds_client.models.record_request import RecordRequest
+from wds_client.models.record_response import RecordResponse
+from wds_client.models.search_request import SearchRequest
+from wds_client.models.tsv_upload_response import TsvUploadResponse
+
+from wds_client.api_client import ApiClient, RequestSerialized
+from wds_client.api_response import ApiResponse
+from wds_client.rest import RESTResponseType
+
+
+class RecordsApi:
     """NOTE: This class is auto generated by OpenAPI Generator
     Ref: https://openapi-generator.tech
 
     Do not edit the class manually.
     """
 
-    def __init__(self, api_client=None):
+    def __init__(self, api_client=None) -> None:
         if api_client is None:
-            api_client = ApiClient()
+            api_client = ApiClient.get_default()
         self.api_client = api_client
 
-    def batch_write_records(self, instanceid, v, type, batch_operation, **kwargs):  # noqa: E501
-        """Batch write records  # noqa: E501
-
-        Perform a batch of upsert / delete operations on multiple records  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.batch_write_records(instanceid, v, type, batch_operation, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str instanceid: WDS instance id; by convention equal to workspace id (required)
-        :param str v: API version (required)
-        :param str type: Record type (required)
-        :param list[BatchOperation] batch_operation: A list of batch operations to perform on records (required)
-        :param str primary_key: the column to uniquely identify a record
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+
+    @validate_call
+    def batch_write_records(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        batch_operation: Annotated[List[BatchOperation], Field(description="A list of batch operations to perform on records")],
+        primary_key: Annotated[Optional[StrictStr], Field(description="the column to uniquely identify a record")] = 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,
+    ) -> BatchResponse:
+        """Batch write records
+
+        Perform a batch of upsert / delete operations on multiple records
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param batch_operation: A list of batch operations to perform on records (required)
+        :type batch_operation: List[BatchOperation]
+        :param primary_key: the column to uniquely identify a record
+        :type primary_key: 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
                                  (connection, read) timeouts.
-        :return: BatchResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.batch_write_records_with_http_info(instanceid, v, type, batch_operation, **kwargs)  # noqa: E501
-
-    def batch_write_records_with_http_info(self, instanceid, v, type, batch_operation, **kwargs):  # noqa: E501
-        """Batch write records  # noqa: E501
-
-        Perform a batch of upsert / delete operations on multiple records  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.batch_write_records_with_http_info(instanceid, v, type, batch_operation, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str instanceid: WDS instance id; by convention equal to workspace id (required)
-        :param str v: API version (required)
-        :param str type: Record type (required)
-        :param list[BatchOperation] batch_operation: A list of batch operations to perform on records (required)
-        :param str primary_key: the column to uniquely identify a record
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._batch_write_records_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            batch_operation=batch_operation,
+            primary_key=primary_key,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "BatchResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def batch_write_records_with_http_info(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        batch_operation: Annotated[List[BatchOperation], Field(description="A list of batch operations to perform on records")],
+        primary_key: Annotated[Optional[StrictStr], Field(description="the column to uniquely identify a record")] = 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[BatchResponse]:
+        """Batch write records
+
+        Perform a batch of upsert / delete operations on multiple records
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param batch_operation: A list of batch operations to perform on records (required)
+        :type batch_operation: List[BatchOperation]
+        :param primary_key: the column to uniquely identify a record
+        :type primary_key: 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
                                  (connection, read) timeouts.
-        :return: tuple(BatchResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'instanceid',
-            'v',
-            'type',
-            'batch_operation',
-            'primary_key'
-        ]
-        all_params.extend(
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._batch_write_records_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            batch_operation=batch_operation,
+            primary_key=primary_key,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "BatchResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def batch_write_records_without_preload_content(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        batch_operation: Annotated[List[BatchOperation], Field(description="A list of batch operations to perform on records")],
+        primary_key: Annotated[Optional[StrictStr], Field(description="the column to uniquely identify a record")] = 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:
+        """Batch write records
+
+        Perform a batch of upsert / delete operations on multiple records
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param batch_operation: A list of batch operations to perform on records (required)
+        :type batch_operation: List[BatchOperation]
+        :param primary_key: the column to uniquely identify a record
+        :type primary_key: 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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._batch_write_records_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            batch_operation=batch_operation,
+            primary_key=primary_key,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "BatchResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _batch_write_records_serialize(
+        self,
+        instanceid,
+        v,
+        type,
+        batch_operation,
+        primary_key,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+            'BatchOperation': '',
+        }
+
+        _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]] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if instanceid is not None:
+            _path_params['instanceid'] = instanceid
+        if v is not None:
+            _path_params['v'] = v
+        if type is not None:
+            _path_params['type'] = type
+        # process the query parameters
+        if primary_key is not None:
+            
+            _query_params.append(('primaryKey', primary_key))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+        if batch_operation is not None:
+            _body_params = batch_operation
+
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
             [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
+                'application/json'
             ]
         )
 
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method batch_write_records" % key
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json'
+                    ]
                 )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'instanceid' is set
-        if self.api_client.client_side_validation and ('instanceid' not in local_var_params or  # noqa: E501
-                                                        local_var_params['instanceid'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `instanceid` when calling `batch_write_records`")  # noqa: E501
-        # verify the required parameter 'v' is set
-        if self.api_client.client_side_validation and ('v' not in local_var_params or  # noqa: E501
-                                                        local_var_params['v'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `v` when calling `batch_write_records`")  # noqa: E501
-        # verify the required parameter 'type' is set
-        if self.api_client.client_side_validation and ('type' not in local_var_params or  # noqa: E501
-                                                        local_var_params['type'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `type` when calling `batch_write_records`")  # noqa: E501
-        # verify the required parameter 'batch_operation' is set
-        if self.api_client.client_side_validation and ('batch_operation' not in local_var_params or  # noqa: E501
-                                                        local_var_params['batch_operation'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `batch_operation` when calling `batch_write_records`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'instanceid' in local_var_params:
-            path_params['instanceid'] = local_var_params['instanceid']  # noqa: E501
-        if 'v' in local_var_params:
-            path_params['v'] = local_var_params['v']  # noqa: E501
-        if 'type' in local_var_params:
-            path_params['type'] = local_var_params['type']  # noqa: E501
-
-        query_params = []
-        if 'primary_key' in local_var_params and local_var_params['primary_key'] is not None:  # noqa: E501
-            query_params.append(('primaryKey', local_var_params['primary_key']))  # noqa: E501
-
-        header_params = {}
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        if 'batch_operation' in local_var_params:
-            body_params = local_var_params['batch_operation']
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
-            ['application/json'])  # noqa: E501
-
-        # HTTP header `Content-Type`
-        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
-            ['application/json'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = ['bearerAuth']  # noqa: E501
-
-        return self.api_client.call_api(
-            '/{instanceid}/batch/{v}/{type}', 'POST',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='BatchResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
-    def create_or_replace_record(self, instanceid, v, type, id, record_request, **kwargs):  # noqa: E501
-        """Create or replace record  # noqa: E501
-
-        Creates or replaces the record using the specified type and id. If the record already exists, its entire set of attributes will be overwritten by the attributes in the request body. TODO: add a query parameter to allow/disallow overwriting existing records?   # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.create_or_replace_record(instanceid, v, type, id, record_request, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str instanceid: WDS instance id; by convention equal to workspace id (required)
-        :param str v: API version (required)
-        :param str type: Record type (required)
-        :param str id: Record id (required)
-        :param RecordRequest record_request: A record's attributes to upload (required)
-        :param str primary_key: the column to uniquely identify a record
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearerAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/{instanceid}/batch/{v}/{type}',
+            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 create_or_replace_record(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        id: Annotated[StrictStr, Field(description="Record id")],
+        record_request: Annotated[RecordRequest, Field(description="A record's attributes to upload")],
+        primary_key: Annotated[Optional[StrictStr], Field(description="the column to uniquely identify a record")] = 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,
+    ) -> RecordResponse:
+        """Create or replace record
+
+        Creates or replaces the record using the specified type and id. If the record already exists, its entire set of attributes will be overwritten by the attributes in the request body. TODO: add a query parameter to allow/disallow overwriting existing records? 
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param id: Record id (required)
+        :type id: str
+        :param record_request: A record's attributes to upload (required)
+        :type record_request: RecordRequest
+        :param primary_key: the column to uniquely identify a record
+        :type primary_key: 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
                                  (connection, read) timeouts.
-        :return: RecordResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.create_or_replace_record_with_http_info(instanceid, v, type, id, record_request, **kwargs)  # noqa: E501
-
-    def create_or_replace_record_with_http_info(self, instanceid, v, type, id, record_request, **kwargs):  # noqa: E501
-        """Create or replace record  # noqa: E501
-
-        Creates or replaces the record using the specified type and id. If the record already exists, its entire set of attributes will be overwritten by the attributes in the request body. TODO: add a query parameter to allow/disallow overwriting existing records?   # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.create_or_replace_record_with_http_info(instanceid, v, type, id, record_request, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str instanceid: WDS instance id; by convention equal to workspace id (required)
-        :param str v: API version (required)
-        :param str type: Record type (required)
-        :param str id: Record id (required)
-        :param RecordRequest record_request: A record's attributes to upload (required)
-        :param str primary_key: the column to uniquely identify a record
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._create_or_replace_record_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            id=id,
+            record_request=record_request,
+            primary_key=primary_key,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "RecordResponse",
+            '201': "RecordResponse",
+            '400': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def create_or_replace_record_with_http_info(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        id: Annotated[StrictStr, Field(description="Record id")],
+        record_request: Annotated[RecordRequest, Field(description="A record's attributes to upload")],
+        primary_key: Annotated[Optional[StrictStr], Field(description="the column to uniquely identify a record")] = 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[RecordResponse]:
+        """Create or replace record
+
+        Creates or replaces the record using the specified type and id. If the record already exists, its entire set of attributes will be overwritten by the attributes in the request body. TODO: add a query parameter to allow/disallow overwriting existing records? 
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param id: Record id (required)
+        :type id: str
+        :param record_request: A record's attributes to upload (required)
+        :type record_request: RecordRequest
+        :param primary_key: the column to uniquely identify a record
+        :type primary_key: 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
                                  (connection, read) timeouts.
-        :return: tuple(RecordResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'instanceid',
-            'v',
-            'type',
-            'id',
-            'record_request',
-            'primary_key'
-        ]
-        all_params.extend(
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._create_or_replace_record_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            id=id,
+            record_request=record_request,
+            primary_key=primary_key,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "RecordResponse",
+            '201': "RecordResponse",
+            '400': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def create_or_replace_record_without_preload_content(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        id: Annotated[StrictStr, Field(description="Record id")],
+        record_request: Annotated[RecordRequest, Field(description="A record's attributes to upload")],
+        primary_key: Annotated[Optional[StrictStr], Field(description="the column to uniquely identify a record")] = 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:
+        """Create or replace record
+
+        Creates or replaces the record using the specified type and id. If the record already exists, its entire set of attributes will be overwritten by the attributes in the request body. TODO: add a query parameter to allow/disallow overwriting existing records? 
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param id: Record id (required)
+        :type id: str
+        :param record_request: A record's attributes to upload (required)
+        :type record_request: RecordRequest
+        :param primary_key: the column to uniquely identify a record
+        :type primary_key: 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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._create_or_replace_record_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            id=id,
+            record_request=record_request,
+            primary_key=primary_key,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "RecordResponse",
+            '201': "RecordResponse",
+            '400': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _create_or_replace_record_serialize(
+        self,
+        instanceid,
+        v,
+        type,
+        id,
+        record_request,
+        primary_key,
+        _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]] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if instanceid is not None:
+            _path_params['instanceid'] = instanceid
+        if v is not None:
+            _path_params['v'] = v
+        if type is not None:
+            _path_params['type'] = type
+        if id is not None:
+            _path_params['id'] = id
+        # process the query parameters
+        if primary_key is not None:
+            
+            _query_params.append(('primaryKey', primary_key))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+        if record_request is not None:
+            _body_params = record_request
+
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
             [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
+                'application/json'
             ]
         )
 
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method create_or_replace_record" % key
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json'
+                    ]
                 )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'instanceid' is set
-        if self.api_client.client_side_validation and ('instanceid' not in local_var_params or  # noqa: E501
-                                                        local_var_params['instanceid'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `instanceid` when calling `create_or_replace_record`")  # noqa: E501
-        # verify the required parameter 'v' is set
-        if self.api_client.client_side_validation and ('v' not in local_var_params or  # noqa: E501
-                                                        local_var_params['v'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `v` when calling `create_or_replace_record`")  # noqa: E501
-        # verify the required parameter 'type' is set
-        if self.api_client.client_side_validation and ('type' not in local_var_params or  # noqa: E501
-                                                        local_var_params['type'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `type` when calling `create_or_replace_record`")  # noqa: E501
-        # verify the required parameter 'id' is set
-        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `id` when calling `create_or_replace_record`")  # noqa: E501
-        # verify the required parameter 'record_request' is set
-        if self.api_client.client_side_validation and ('record_request' not in local_var_params or  # noqa: E501
-                                                        local_var_params['record_request'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `record_request` when calling `create_or_replace_record`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'instanceid' in local_var_params:
-            path_params['instanceid'] = local_var_params['instanceid']  # noqa: E501
-        if 'v' in local_var_params:
-            path_params['v'] = local_var_params['v']  # noqa: E501
-        if 'type' in local_var_params:
-            path_params['type'] = local_var_params['type']  # noqa: E501
-        if 'id' in local_var_params:
-            path_params['id'] = local_var_params['id']  # noqa: E501
-
-        query_params = []
-        if 'primary_key' in local_var_params and local_var_params['primary_key'] is not None:  # noqa: E501
-            query_params.append(('primaryKey', local_var_params['primary_key']))  # noqa: E501
-
-        header_params = {}
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        if 'record_request' in local_var_params:
-            body_params = local_var_params['record_request']
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
-            ['application/json'])  # noqa: E501
-
-        # HTTP header `Content-Type`
-        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
-            ['application/json'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = ['bearerAuth']  # noqa: E501
-
-        return self.api_client.call_api(
-            '/{instanceid}/records/{v}/{type}/{id}', 'PUT',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='RecordResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
-    def delete_record(self, instanceid, v, type, id, **kwargs):  # noqa: E501
-        """Delete record  # noqa: E501
-
-        Deletes the record at the specified type and id.  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_record(instanceid, v, type, id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str instanceid: WDS instance id; by convention equal to workspace id (required)
-        :param str v: API version (required)
-        :param str type: Record type (required)
-        :param str id: Record id (required)
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearerAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='PUT',
+            resource_path='/{instanceid}/records/{v}/{type}/{id}',
+            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 delete_record(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        id: Annotated[StrictStr, Field(description="Record id")],
+        _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,
+    ) -> None:
+        """Delete record
+
+        Deletes the record at the specified type and id.
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param id: Record id (required)
+        :type id: 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
                                  (connection, read) timeouts.
-        :return: None
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.delete_record_with_http_info(instanceid, v, type, id, **kwargs)  # noqa: E501
-
-    def delete_record_with_http_info(self, instanceid, v, type, id, **kwargs):  # noqa: E501
-        """Delete record  # noqa: E501
-
-        Deletes the record at the specified type and id.  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_record_with_http_info(instanceid, v, type, id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str instanceid: WDS instance id; by convention equal to workspace id (required)
-        :param str v: API version (required)
-        :param str type: Record type (required)
-        :param str id: Record id (required)
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._delete_record_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            id=id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '204': None,
+            '404': "ErrorResponse",
+            '400': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def delete_record_with_http_info(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        id: Annotated[StrictStr, Field(description="Record id")],
+        _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[None]:
+        """Delete record
+
+        Deletes the record at the specified type and id.
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param id: Record id (required)
+        :type id: 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
                                  (connection, read) timeouts.
-        :return: None
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'instanceid',
-            'v',
-            'type',
-            'id'
-        ]
-        all_params.extend(
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._delete_record_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            id=id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '204': None,
+            '404': "ErrorResponse",
+            '400': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def delete_record_without_preload_content(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        id: Annotated[StrictStr, Field(description="Record id")],
+        _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:
+        """Delete record
+
+        Deletes the record at the specified type and id.
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param id: Record id (required)
+        :type id: 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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._delete_record_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            id=id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '204': None,
+            '404': "ErrorResponse",
+            '400': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _delete_record_serialize(
+        self,
+        instanceid,
+        v,
+        type,
+        id,
+        _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]] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if instanceid is not None:
+            _path_params['instanceid'] = instanceid
+        if v is not None:
+            _path_params['v'] = v
+        if type is not None:
+            _path_params['type'] = type
+        if id is not None:
+            _path_params['id'] = id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
             [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
+                'application/json'
             ]
         )
 
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method delete_record" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'instanceid' is set
-        if self.api_client.client_side_validation and ('instanceid' not in local_var_params or  # noqa: E501
-                                                        local_var_params['instanceid'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `instanceid` when calling `delete_record`")  # noqa: E501
-        # verify the required parameter 'v' is set
-        if self.api_client.client_side_validation and ('v' not in local_var_params or  # noqa: E501
-                                                        local_var_params['v'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `v` when calling `delete_record`")  # noqa: E501
-        # verify the required parameter 'type' is set
-        if self.api_client.client_side_validation and ('type' not in local_var_params or  # noqa: E501
-                                                        local_var_params['type'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `type` when calling `delete_record`")  # noqa: E501
-        # verify the required parameter 'id' is set
-        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `id` when calling `delete_record`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'instanceid' in local_var_params:
-            path_params['instanceid'] = local_var_params['instanceid']  # noqa: E501
-        if 'v' in local_var_params:
-            path_params['v'] = local_var_params['v']  # noqa: E501
-        if 'type' in local_var_params:
-            path_params['type'] = local_var_params['type']  # noqa: E501
-        if 'id' in local_var_params:
-            path_params['id'] = local_var_params['id']  # noqa: E501
-
-        query_params = []
-
-        header_params = {}
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
-            ['application/json'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = ['bearerAuth']  # noqa: E501
-
-        return self.api_client.call_api(
-            '/{instanceid}/records/{v}/{type}/{id}', 'DELETE',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type=None,  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
-    def get_record(self, instanceid, v, type, id, **kwargs):  # noqa: E501
-        """Get record  # noqa: E501
-
-        Retrieves a single record by its type and id  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_record(instanceid, v, type, id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str instanceid: WDS instance id; by convention equal to workspace id (required)
-        :param str v: API version (required)
-        :param str type: Record type (required)
-        :param str id: Record id (required)
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearerAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='DELETE',
+            resource_path='/{instanceid}/records/{v}/{type}/{id}',
+            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_record(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        id: Annotated[StrictStr, Field(description="Record id")],
+        _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,
+    ) -> RecordResponse:
+        """Get record
+
+        Retrieves a single record by its type and id
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param id: Record id (required)
+        :type id: 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
                                  (connection, read) timeouts.
-        :return: RecordResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.get_record_with_http_info(instanceid, v, type, id, **kwargs)  # noqa: E501
-
-    def get_record_with_http_info(self, instanceid, v, type, id, **kwargs):  # noqa: E501
-        """Get record  # noqa: E501
-
-        Retrieves a single record by its type and id  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_record_with_http_info(instanceid, v, type, id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str instanceid: WDS instance id; by convention equal to workspace id (required)
-        :param str v: API version (required)
-        :param str type: Record type (required)
-        :param str id: Record id (required)
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_record_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            id=id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "RecordResponse",
+            '404': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_record_with_http_info(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        id: Annotated[StrictStr, Field(description="Record id")],
+        _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[RecordResponse]:
+        """Get record
+
+        Retrieves a single record by its type and id
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param id: Record id (required)
+        :type id: 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
                                  (connection, read) timeouts.
-        :return: tuple(RecordResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'instanceid',
-            'v',
-            'type',
-            'id'
-        ]
-        all_params.extend(
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_record_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            id=id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "RecordResponse",
+            '404': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def get_record_without_preload_content(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        id: Annotated[StrictStr, Field(description="Record id")],
+        _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 record
+
+        Retrieves a single record by its type and id
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param id: Record id (required)
+        :type id: 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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_record_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            id=id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "RecordResponse",
+            '404': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_record_serialize(
+        self,
+        instanceid,
+        v,
+        type,
+        id,
+        _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]] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if instanceid is not None:
+            _path_params['instanceid'] = instanceid
+        if v is not None:
+            _path_params['v'] = v
+        if type is not None:
+            _path_params['type'] = type
+        if id is not None:
+            _path_params['id'] = id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
             [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
+                'application/json'
             ]
         )
 
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method get_record" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'instanceid' is set
-        if self.api_client.client_side_validation and ('instanceid' not in local_var_params or  # noqa: E501
-                                                        local_var_params['instanceid'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `instanceid` when calling `get_record`")  # noqa: E501
-        # verify the required parameter 'v' is set
-        if self.api_client.client_side_validation and ('v' not in local_var_params or  # noqa: E501
-                                                        local_var_params['v'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `v` when calling `get_record`")  # noqa: E501
-        # verify the required parameter 'type' is set
-        if self.api_client.client_side_validation and ('type' not in local_var_params or  # noqa: E501
-                                                        local_var_params['type'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `type` when calling `get_record`")  # noqa: E501
-        # verify the required parameter 'id' is set
-        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `id` when calling `get_record`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'instanceid' in local_var_params:
-            path_params['instanceid'] = local_var_params['instanceid']  # noqa: E501
-        if 'v' in local_var_params:
-            path_params['v'] = local_var_params['v']  # noqa: E501
-        if 'type' in local_var_params:
-            path_params['type'] = local_var_params['type']  # noqa: E501
-        if 'id' in local_var_params:
-            path_params['id'] = local_var_params['id']  # noqa: E501
-
-        query_params = []
-
-        header_params = {}
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
-            ['application/json'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/{instanceid}/records/{v}/{type}/{id}', 'GET',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='RecordResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
-    def get_records_as_tsv(self, instanceid, v, type, **kwargs):  # noqa: E501
-        """Retrieve all records in record type as tsv.  # noqa: E501
-
-        Streams all records in a record type to a tsv format.  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_records_as_tsv(instanceid, v, type, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str instanceid: WDS instance id; by convention equal to workspace id (required)
-        :param str v: API version (required)
-        :param str type: Record type (required)
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+
+        # authentication setting
+        _auth_settings: List[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/{instanceid}/records/{v}/{type}/{id}',
+            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_records_as_tsv(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        _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,
+    ) -> bytearray:
+        """Retrieve all records in record type as tsv.
+
+        Streams all records in a record type to a tsv format.
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: 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
                                  (connection, read) timeouts.
-        :return: file
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.get_records_as_tsv_with_http_info(instanceid, v, type, **kwargs)  # noqa: E501
-
-    def get_records_as_tsv_with_http_info(self, instanceid, v, type, **kwargs):  # noqa: E501
-        """Retrieve all records in record type as tsv.  # noqa: E501
-
-        Streams all records in a record type to a tsv format.  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_records_as_tsv_with_http_info(instanceid, v, type, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str instanceid: WDS instance id; by convention equal to workspace id (required)
-        :param str v: API version (required)
-        :param str type: Record type (required)
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_records_as_tsv_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "bytearray",
+            '404': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_records_as_tsv_with_http_info(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        _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[bytearray]:
+        """Retrieve all records in record type as tsv.
+
+        Streams all records in a record type to a tsv format.
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: 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
                                  (connection, read) timeouts.
-        :return: tuple(file, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_records_as_tsv_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
 
-        local_var_params = locals()
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "bytearray",
+            '404': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
 
-        all_params = [
-            'instanceid',
-            'v',
-            'type'
-        ]
-        all_params.extend(
+
+    @validate_call
+    def get_records_as_tsv_without_preload_content(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        _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:
+        """Retrieve all records in record type as tsv.
+
+        Streams all records in a record type to a tsv format.
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: 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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_records_as_tsv_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "bytearray",
+            '404': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_records_as_tsv_serialize(
+        self,
+        instanceid,
+        v,
+        type,
+        _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]] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if instanceid is not None:
+            _path_params['instanceid'] = instanceid
+        if v is not None:
+            _path_params['v'] = v
+        if type is not None:
+            _path_params['type'] = type
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
             [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
+                'text/tab-separated-values', 
+                'application/json'
             ]
         )
 
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method get_records_as_tsv" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'instanceid' is set
-        if self.api_client.client_side_validation and ('instanceid' not in local_var_params or  # noqa: E501
-                                                        local_var_params['instanceid'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `instanceid` when calling `get_records_as_tsv`")  # noqa: E501
-        # verify the required parameter 'v' is set
-        if self.api_client.client_side_validation and ('v' not in local_var_params or  # noqa: E501
-                                                        local_var_params['v'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `v` when calling `get_records_as_tsv`")  # noqa: E501
-        # verify the required parameter 'type' is set
-        if self.api_client.client_side_validation and ('type' not in local_var_params or  # noqa: E501
-                                                        local_var_params['type'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `type` when calling `get_records_as_tsv`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'instanceid' in local_var_params:
-            path_params['instanceid'] = local_var_params['instanceid']  # noqa: E501
-        if 'v' in local_var_params:
-            path_params['v'] = local_var_params['v']  # noqa: E501
-        if 'type' in local_var_params:
-            path_params['type'] = local_var_params['type']  # noqa: E501
-
-        query_params = []
-
-        header_params = {}
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
-            ['text/tab-separated-values', 'application/json'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/{instanceid}/tsv/{v}/{type}', 'GET',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='file',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
-    def query_records(self, instanceid, v, type, search_request, **kwargs):  # noqa: E501
-        """Query records  # noqa: E501
-
-        Paginated list of records matching the criteria supplied in the request body  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.query_records(instanceid, v, type, search_request, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str instanceid: WDS instance id; by convention equal to workspace id (required)
-        :param str v: API version (required)
-        :param str type: Record type (required)
-        :param SearchRequest search_request: A paginated search request (required)
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+
+        # authentication setting
+        _auth_settings: List[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/{instanceid}/tsv/{v}/{type}',
+            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 query_records(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        search_request: Annotated[SearchRequest, Field(description="A paginated search request")],
+        _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,
+    ) -> RecordQueryResponse:
+        """Query records
+
+        Paginated list of records matching the criteria supplied in the request body
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param search_request: A paginated search request (required)
+        :type search_request: SearchRequest
         :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
                                  (connection, read) timeouts.
-        :return: RecordQueryResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.query_records_with_http_info(instanceid, v, type, search_request, **kwargs)  # noqa: E501
-
-    def query_records_with_http_info(self, instanceid, v, type, search_request, **kwargs):  # noqa: E501
-        """Query records  # noqa: E501
-
-        Paginated list of records matching the criteria supplied in the request body  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.query_records_with_http_info(instanceid, v, type, search_request, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str instanceid: WDS instance id; by convention equal to workspace id (required)
-        :param str v: API version (required)
-        :param str type: Record type (required)
-        :param SearchRequest search_request: A paginated search request (required)
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._query_records_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            search_request=search_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "RecordQueryResponse",
+            '404': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def query_records_with_http_info(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        search_request: Annotated[SearchRequest, Field(description="A paginated search request")],
+        _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[RecordQueryResponse]:
+        """Query records
+
+        Paginated list of records matching the criteria supplied in the request body
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param search_request: A paginated search request (required)
+        :type search_request: SearchRequest
         :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
                                  (connection, read) timeouts.
-        :return: tuple(RecordQueryResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'instanceid',
-            'v',
-            'type',
-            'search_request'
-        ]
-        all_params.extend(
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._query_records_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            search_request=search_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "RecordQueryResponse",
+            '404': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def query_records_without_preload_content(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        search_request: Annotated[SearchRequest, Field(description="A paginated search request")],
+        _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:
+        """Query records
+
+        Paginated list of records matching the criteria supplied in the request body
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param search_request: A paginated search request (required)
+        :type search_request: SearchRequest
+        :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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._query_records_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            search_request=search_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "RecordQueryResponse",
+            '404': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _query_records_serialize(
+        self,
+        instanceid,
+        v,
+        type,
+        search_request,
+        _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]] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if instanceid is not None:
+            _path_params['instanceid'] = instanceid
+        if v is not None:
+            _path_params['v'] = v
+        if type is not None:
+            _path_params['type'] = type
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+        if search_request is not None:
+            _body_params = search_request
+
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
             [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
+                'application/json'
             ]
         )
 
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method query_records" % key
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json'
+                    ]
                 )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'instanceid' is set
-        if self.api_client.client_side_validation and ('instanceid' not in local_var_params or  # noqa: E501
-                                                        local_var_params['instanceid'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `instanceid` when calling `query_records`")  # noqa: E501
-        # verify the required parameter 'v' is set
-        if self.api_client.client_side_validation and ('v' not in local_var_params or  # noqa: E501
-                                                        local_var_params['v'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `v` when calling `query_records`")  # noqa: E501
-        # verify the required parameter 'type' is set
-        if self.api_client.client_side_validation and ('type' not in local_var_params or  # noqa: E501
-                                                        local_var_params['type'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `type` when calling `query_records`")  # noqa: E501
-        # verify the required parameter 'search_request' is set
-        if self.api_client.client_side_validation and ('search_request' not in local_var_params or  # noqa: E501
-                                                        local_var_params['search_request'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `search_request` when calling `query_records`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'instanceid' in local_var_params:
-            path_params['instanceid'] = local_var_params['instanceid']  # noqa: E501
-        if 'v' in local_var_params:
-            path_params['v'] = local_var_params['v']  # noqa: E501
-        if 'type' in local_var_params:
-            path_params['type'] = local_var_params['type']  # noqa: E501
-
-        query_params = []
-
-        header_params = {}
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        if 'search_request' in local_var_params:
-            body_params = local_var_params['search_request']
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
-            ['application/json'])  # noqa: E501
-
-        # HTTP header `Content-Type`
-        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
-            ['application/json'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/{instanceid}/search/{v}/{type}', 'POST',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='RecordQueryResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
-    def update_record(self, instanceid, v, type, id, record_request, **kwargs):  # noqa: E501
-        """Update record  # noqa: E501
-
-        Updates the record of the specified type and id. Any attributes included in the request body will be created or overwritten. Attributes not included in the request body will be untouched in the database. No attributes will be deleted. To delete attributes, use the PUT api instead.   # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.update_record(instanceid, v, type, id, record_request, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str instanceid: WDS instance id; by convention equal to workspace id (required)
-        :param str v: API version (required)
-        :param str type: Record type (required)
-        :param str id: Record id (required)
-        :param RecordRequest record_request: A record's attributes to upload (required)
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: List[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/{instanceid}/search/{v}/{type}',
+            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 update_record(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        id: Annotated[StrictStr, Field(description="Record id")],
+        record_request: Annotated[RecordRequest, Field(description="A record's attributes to upload")],
+        _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,
+    ) -> RecordResponse:
+        """Update record
+
+        Updates the record of the specified type and id. Any attributes included in the request body will be created or overwritten. Attributes not included in the request body will be untouched in the database. No attributes will be deleted. To delete attributes, use the PUT api instead. 
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param id: Record id (required)
+        :type id: str
+        :param record_request: A record's attributes to upload (required)
+        :type record_request: RecordRequest
         :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
                                  (connection, read) timeouts.
-        :return: RecordResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.update_record_with_http_info(instanceid, v, type, id, record_request, **kwargs)  # noqa: E501
-
-    def update_record_with_http_info(self, instanceid, v, type, id, record_request, **kwargs):  # noqa: E501
-        """Update record  # noqa: E501
-
-        Updates the record of the specified type and id. Any attributes included in the request body will be created or overwritten. Attributes not included in the request body will be untouched in the database. No attributes will be deleted. To delete attributes, use the PUT api instead.   # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.update_record_with_http_info(instanceid, v, type, id, record_request, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str instanceid: WDS instance id; by convention equal to workspace id (required)
-        :param str v: API version (required)
-        :param str type: Record type (required)
-        :param str id: Record id (required)
-        :param RecordRequest record_request: A record's attributes to upload (required)
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._update_record_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            id=id,
+            record_request=record_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "RecordResponse",
+            '404': "ErrorResponse",
+            '400': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def update_record_with_http_info(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        id: Annotated[StrictStr, Field(description="Record id")],
+        record_request: Annotated[RecordRequest, Field(description="A record's attributes to upload")],
+        _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[RecordResponse]:
+        """Update record
+
+        Updates the record of the specified type and id. Any attributes included in the request body will be created or overwritten. Attributes not included in the request body will be untouched in the database. No attributes will be deleted. To delete attributes, use the PUT api instead. 
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param id: Record id (required)
+        :type id: str
+        :param record_request: A record's attributes to upload (required)
+        :type record_request: RecordRequest
         :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
                                  (connection, read) timeouts.
-        :return: tuple(RecordResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'instanceid',
-            'v',
-            'type',
-            'id',
-            'record_request'
-        ]
-        all_params.extend(
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._update_record_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            id=id,
+            record_request=record_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "RecordResponse",
+            '404': "ErrorResponse",
+            '400': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def update_record_without_preload_content(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        id: Annotated[StrictStr, Field(description="Record id")],
+        record_request: Annotated[RecordRequest, Field(description="A record's attributes to upload")],
+        _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:
+        """Update record
+
+        Updates the record of the specified type and id. Any attributes included in the request body will be created or overwritten. Attributes not included in the request body will be untouched in the database. No attributes will be deleted. To delete attributes, use the PUT api instead. 
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param id: Record id (required)
+        :type id: str
+        :param record_request: A record's attributes to upload (required)
+        :type record_request: RecordRequest
+        :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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._update_record_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            id=id,
+            record_request=record_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "RecordResponse",
+            '404': "ErrorResponse",
+            '400': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _update_record_serialize(
+        self,
+        instanceid,
+        v,
+        type,
+        id,
+        record_request,
+        _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]] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if instanceid is not None:
+            _path_params['instanceid'] = instanceid
+        if v is not None:
+            _path_params['v'] = v
+        if type is not None:
+            _path_params['type'] = type
+        if id is not None:
+            _path_params['id'] = id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+        if record_request is not None:
+            _body_params = record_request
+
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
             [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
+                'application/json'
             ]
         )
 
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method update_record" % key
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json'
+                    ]
                 )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'instanceid' is set
-        if self.api_client.client_side_validation and ('instanceid' not in local_var_params or  # noqa: E501
-                                                        local_var_params['instanceid'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `instanceid` when calling `update_record`")  # noqa: E501
-        # verify the required parameter 'v' is set
-        if self.api_client.client_side_validation and ('v' not in local_var_params or  # noqa: E501
-                                                        local_var_params['v'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `v` when calling `update_record`")  # noqa: E501
-        # verify the required parameter 'type' is set
-        if self.api_client.client_side_validation and ('type' not in local_var_params or  # noqa: E501
-                                                        local_var_params['type'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `type` when calling `update_record`")  # noqa: E501
-        # verify the required parameter 'id' is set
-        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `id` when calling `update_record`")  # noqa: E501
-        # verify the required parameter 'record_request' is set
-        if self.api_client.client_side_validation and ('record_request' not in local_var_params or  # noqa: E501
-                                                        local_var_params['record_request'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `record_request` when calling `update_record`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'instanceid' in local_var_params:
-            path_params['instanceid'] = local_var_params['instanceid']  # noqa: E501
-        if 'v' in local_var_params:
-            path_params['v'] = local_var_params['v']  # noqa: E501
-        if 'type' in local_var_params:
-            path_params['type'] = local_var_params['type']  # noqa: E501
-        if 'id' in local_var_params:
-            path_params['id'] = local_var_params['id']  # noqa: E501
-
-        query_params = []
-
-        header_params = {}
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        if 'record_request' in local_var_params:
-            body_params = local_var_params['record_request']
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
-            ['application/json'])  # noqa: E501
-
-        # HTTP header `Content-Type`
-        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
-            ['application/json'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = ['bearerAuth']  # noqa: E501
-
-        return self.api_client.call_api(
-            '/{instanceid}/records/{v}/{type}/{id}', 'PATCH',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='RecordResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
-    def upload_tsv(self, instanceid, v, type, records, **kwargs):  # noqa: E501
-        """Import records to a record type from a tsv file  # noqa: E501
-
-        Upload a tsv to modify or create records in a record type.  This operation will insert or update records.  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.upload_tsv(instanceid, v, type, records, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str instanceid: WDS instance id; by convention equal to workspace id (required)
-        :param str v: API version (required)
-        :param str type: Record type (required)
-        :param file records: A valid TSV import file (required)
-        :param str primary_key: the column to uniquely identify a record
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearerAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='PATCH',
+            resource_path='/{instanceid}/records/{v}/{type}/{id}',
+            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 upload_tsv(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        records: Annotated[Union[StrictBytes, StrictStr], Field(description="A valid TSV import file")],
+        primary_key: Annotated[Optional[StrictStr], Field(description="the column to uniquely identify a record")] = 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,
+    ) -> TsvUploadResponse:
+        """Import records to a record type from a tsv file
+
+        Upload a tsv to modify or create records in a record type.  This operation will insert or update records.
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param records: A valid TSV import file (required)
+        :type records: bytearray
+        :param primary_key: the column to uniquely identify a record
+        :type primary_key: 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
                                  (connection, read) timeouts.
-        :return: TsvUploadResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.upload_tsv_with_http_info(instanceid, v, type, records, **kwargs)  # noqa: E501
-
-    def upload_tsv_with_http_info(self, instanceid, v, type, records, **kwargs):  # noqa: E501
-        """Import records to a record type from a tsv file  # noqa: E501
-
-        Upload a tsv to modify or create records in a record type.  This operation will insert or update records.  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.upload_tsv_with_http_info(instanceid, v, type, records, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str instanceid: WDS instance id; by convention equal to workspace id (required)
-        :param str v: API version (required)
-        :param str type: Record type (required)
-        :param file records: A valid TSV import file (required)
-        :param str primary_key: the column to uniquely identify a record
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._upload_tsv_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            records=records,
+            primary_key=primary_key,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "TsvUploadResponse",
+            '400': "ErrorResponse",
+            '404': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def upload_tsv_with_http_info(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        records: Annotated[Union[StrictBytes, StrictStr], Field(description="A valid TSV import file")],
+        primary_key: Annotated[Optional[StrictStr], Field(description="the column to uniquely identify a record")] = 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[TsvUploadResponse]:
+        """Import records to a record type from a tsv file
+
+        Upload a tsv to modify or create records in a record type.  This operation will insert or update records.
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param records: A valid TSV import file (required)
+        :type records: bytearray
+        :param primary_key: the column to uniquely identify a record
+        :type primary_key: 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
                                  (connection, read) timeouts.
-        :return: tuple(TsvUploadResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'instanceid',
-            'v',
-            'type',
-            'records',
-            'primary_key'
-        ]
-        all_params.extend(
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._upload_tsv_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            records=records,
+            primary_key=primary_key,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "TsvUploadResponse",
+            '400': "ErrorResponse",
+            '404': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def upload_tsv_without_preload_content(
+        self,
+        instanceid: Annotated[StrictStr, Field(description="WDS instance id; by convention equal to workspace id")],
+        v: Annotated[StrictStr, Field(description="API version")],
+        type: Annotated[StrictStr, Field(description="Record type")],
+        records: Annotated[Union[StrictBytes, StrictStr], Field(description="A valid TSV import file")],
+        primary_key: Annotated[Optional[StrictStr], Field(description="the column to uniquely identify a record")] = 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:
+        """Import records to a record type from a tsv file
+
+        Upload a tsv to modify or create records in a record type.  This operation will insert or update records.
+
+        :param instanceid: WDS instance id; by convention equal to workspace id (required)
+        :type instanceid: str
+        :param v: API version (required)
+        :type v: str
+        :param type: Record type (required)
+        :type type: str
+        :param records: A valid TSV import file (required)
+        :type records: bytearray
+        :param primary_key: the column to uniquely identify a record
+        :type primary_key: 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
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._upload_tsv_serialize(
+            instanceid=instanceid,
+            v=v,
+            type=type,
+            records=records,
+            primary_key=primary_key,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "TsvUploadResponse",
+            '400': "ErrorResponse",
+            '404': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _upload_tsv_serialize(
+        self,
+        instanceid,
+        v,
+        type,
+        records,
+        primary_key,
+        _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]] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if instanceid is not None:
+            _path_params['instanceid'] = instanceid
+        if v is not None:
+            _path_params['v'] = v
+        if type is not None:
+            _path_params['type'] = type
+        # process the query parameters
+        if primary_key is not None:
+            
+            _query_params.append(('primaryKey', primary_key))
+            
+        # process the header parameters
+        # process the form parameters
+        if records is not None:
+            _files['records'] = records
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
             [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
+                'application/json'
             ]
         )
 
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method upload_tsv" % key
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'multipart/form-data'
+                    ]
                 )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'instanceid' is set
-        if self.api_client.client_side_validation and ('instanceid' not in local_var_params or  # noqa: E501
-                                                        local_var_params['instanceid'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `instanceid` when calling `upload_tsv`")  # noqa: E501
-        # verify the required parameter 'v' is set
-        if self.api_client.client_side_validation and ('v' not in local_var_params or  # noqa: E501
-                                                        local_var_params['v'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `v` when calling `upload_tsv`")  # noqa: E501
-        # verify the required parameter 'type' is set
-        if self.api_client.client_side_validation and ('type' not in local_var_params or  # noqa: E501
-                                                        local_var_params['type'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `type` when calling `upload_tsv`")  # noqa: E501
-        # verify the required parameter 'records' is set
-        if self.api_client.client_side_validation and ('records' not in local_var_params or  # noqa: E501
-                                                        local_var_params['records'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `records` when calling `upload_tsv`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'instanceid' in local_var_params:
-            path_params['instanceid'] = local_var_params['instanceid']  # noqa: E501
-        if 'v' in local_var_params:
-            path_params['v'] = local_var_params['v']  # noqa: E501
-        if 'type' in local_var_params:
-            path_params['type'] = local_var_params['type']  # noqa: E501
-
-        query_params = []
-        if 'primary_key' in local_var_params and local_var_params['primary_key'] is not None:  # noqa: E501
-            query_params.append(('primaryKey', local_var_params['primary_key']))  # noqa: E501
-
-        header_params = {}
-
-        form_params = []
-        local_var_files = {}
-        if 'records' in local_var_params:
-            local_var_files['records'] = local_var_params['records']  # noqa: E501
-
-        body_params = None
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
-            ['application/json'])  # noqa: E501
-
-        # HTTP header `Content-Type`
-        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
-            ['multipart/form-data'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = ['bearerAuth']  # noqa: E501
-
-        return self.api_client.call_api(
-            '/{instanceid}/tsv/{v}/{type}', 'POST',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='TsvUploadResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearerAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/{instanceid}/tsv/{v}/{type}',
+            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
+        )
+
+