hiddenlayer-sdk 1.2.2__py3-none-any.whl → 2.0.1__py3-none-any.whl

hiddenlayer/sdk/rest/api/sensor_api.py

@@ -16,13 +16,12 @@ 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, StrictInt, StrictStr, field_validator
-from typing import Any, Optional
+from pydantic import Field, StrictStr, field_validator
+from typing import Optional
 from typing_extensions import Annotated
 from hiddenlayer.sdk.rest.models.create_sensor_request import CreateSensorRequest
-from hiddenlayer.sdk.rest.models.get_multipart_upload_response import GetMultipartUploadResponse
-from hiddenlayer.sdk.rest.models.model import Model
-from hiddenlayer.sdk.rest.models.model_query_response import ModelQueryResponse
+from hiddenlayer.sdk.rest.models.sensor import Sensor
+from hiddenlayer.sdk.rest.models.sensor_query_response import SensorQueryResponse
 from hiddenlayer.sdk.rest.models.sensor_sor_model_card_query_response import SensorSORModelCardQueryResponse
 from hiddenlayer.sdk.rest.models.sensor_sor_query_request import SensorSORQueryRequest
 
@@ -45,10 +44,9 @@ class SensorApi:
 
 
     @validate_call
-    def begin_multipart_upload(
+    def create_sensor(
         self,
-        sensor_id: StrictStr,
-        x_content_length: Annotated[StrictInt, Field(description="The total size of multipart upload.")],
+        create_sensor_request: Annotated[CreateSensorRequest, Field(description="Request body for create")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -61,14 +59,12 @@ class SensorApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> GetMultipartUploadResponse:
-        """Begin Multipart Upload
+    ) -> Sensor:
+        """Create a Sensor
 
 
-        :param sensor_id: (required)
-        :type sensor_id: str
-        :param x_content_length: The total size of multipart upload. (required)
-        :type x_content_length: int
+        :param create_sensor_request: Request body for create (required)
+        :type create_sensor_request: CreateSensorRequest
         :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
@@ -91,9 +87,8 @@ class SensorApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._begin_multipart_upload_serialize(
-            sensor_id=sensor_id,
-            x_content_length=x_content_length,
+        _param = self._create_sensor_serialize(
+            create_sensor_request=create_sensor_request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -101,8 +96,9 @@ class SensorApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetMultipartUploadResponse",
+            '201': "Sensor",
             '400': None,
+            '422': "ValidationErrorModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -116,10 +112,9 @@ class SensorApi:
 
 
     @validate_call
-    def begin_multipart_upload_with_http_info(
+    def create_sensor_with_http_info(
         self,
-        sensor_id: StrictStr,
-        x_content_length: Annotated[StrictInt, Field(description="The total size of multipart upload.")],
+        create_sensor_request: Annotated[CreateSensorRequest, Field(description="Request body for create")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -132,14 +127,12 @@ class SensorApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[GetMultipartUploadResponse]:
-        """Begin Multipart Upload
+    ) -> ApiResponse[Sensor]:
+        """Create a Sensor
 
 
-        :param sensor_id: (required)
-        :type sensor_id: str
-        :param x_content_length: The total size of multipart upload. (required)
-        :type x_content_length: int
+        :param create_sensor_request: Request body for create (required)
+        :type create_sensor_request: CreateSensorRequest
         :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
@@ -162,9 +155,8 @@ class SensorApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._begin_multipart_upload_serialize(
-            sensor_id=sensor_id,
-            x_content_length=x_content_length,
+        _param = self._create_sensor_serialize(
+            create_sensor_request=create_sensor_request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -172,8 +164,9 @@ class SensorApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetMultipartUploadResponse",
+            '201': "Sensor",
             '400': None,
+            '422': "ValidationErrorModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -187,10 +180,9 @@ class SensorApi:
 
 
     @validate_call
-    def begin_multipart_upload_without_preload_content(
+    def create_sensor_without_preload_content(
         self,
-        sensor_id: StrictStr,
-        x_content_length: Annotated[StrictInt, Field(description="The total size of multipart upload.")],
+        create_sensor_request: Annotated[CreateSensorRequest, Field(description="Request body for create")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -204,13 +196,11 @@ class SensorApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Begin Multipart Upload
+        """Create a Sensor
 
 
-        :param sensor_id: (required)
-        :type sensor_id: str
-        :param x_content_length: The total size of multipart upload. (required)
-        :type x_content_length: int
+        :param create_sensor_request: Request body for create (required)
+        :type create_sensor_request: CreateSensorRequest
         :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
@@ -233,9 +223,8 @@ class SensorApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._begin_multipart_upload_serialize(
-            sensor_id=sensor_id,
-            x_content_length=x_content_length,
+        _param = self._create_sensor_serialize(
+            create_sensor_request=create_sensor_request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -243,8 +232,9 @@ class SensorApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetMultipartUploadResponse",
+            '201': "Sensor",
             '400': None,
+            '422': "ValidationErrorModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -253,10 +243,9 @@ class SensorApi:
         return response_data.response
 
 
-    def _begin_multipart_upload_serialize(
+    def _create_sensor_serialize(
         self,
-        sensor_id,
-        x_content_length,
+        create_sensor_request,
         _request_auth,
         _content_type,
         _headers,
@@ -276,14 +265,12 @@ class SensorApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
-        if sensor_id is not None:
-            _path_params['sensor_id'] = sensor_id
         # process the query parameters
         # process the header parameters
-        if x_content_length is not None:
-            _header_params['X-Content-Length'] = x_content_length
         # process the form parameters
         # process the body parameter
+        if create_sensor_request is not None:
+            _body_params = create_sensor_request
 
 
         # set the HTTP header `Accept`
@@ -293,6 +280,19 @@ class SensorApi:
             ]
         )
 
+        # 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'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
@@ -301,7 +301,7 @@ class SensorApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/api/v2/sensors/{sensor_id}/upload/begin',
+            resource_path='/api/v2/sensors/create',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -318,10 +318,9 @@ class SensorApi:
 
 
     @validate_call
-    def complete_multipart_upload(
+    def get_sensor(
         self,
         sensor_id: StrictStr,
-        upload_id: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -334,14 +333,12 @@ class SensorApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> None:
-        """Complete Multipart Upload
+    ) -> Sensor:
+        """Get Sensor
 
 
         :param sensor_id: (required)
         :type sensor_id: str
-        :param upload_id: (required)
-        :type upload_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
@@ -364,9 +361,8 @@ class SensorApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._complete_multipart_upload_serialize(
+        _param = self._get_sensor_serialize(
             sensor_id=sensor_id,
-            upload_id=upload_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -374,8 +370,9 @@ class SensorApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "Sensor",
             '400': None,
+            '404': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -389,10 +386,9 @@ class SensorApi:
 
 
     @validate_call
-    def complete_multipart_upload_with_http_info(
+    def get_sensor_with_http_info(
         self,
         sensor_id: StrictStr,
-        upload_id: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -405,14 +401,12 @@ class SensorApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[None]:
-        """Complete Multipart Upload
+    ) -> ApiResponse[Sensor]:
+        """Get Sensor
 
 
         :param sensor_id: (required)
         :type sensor_id: str
-        :param upload_id: (required)
-        :type upload_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
@@ -435,9 +429,8 @@ class SensorApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._complete_multipart_upload_serialize(
+        _param = self._get_sensor_serialize(
             sensor_id=sensor_id,
-            upload_id=upload_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -445,8 +438,9 @@ class SensorApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "Sensor",
             '400': None,
+            '404': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -460,10 +454,9 @@ class SensorApi:
 
 
     @validate_call
-    def complete_multipart_upload_without_preload_content(
+    def get_sensor_without_preload_content(
         self,
         sensor_id: StrictStr,
-        upload_id: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -477,13 +470,11 @@ class SensorApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Complete Multipart Upload
+        """Get Sensor
 
 
         :param sensor_id: (required)
         :type sensor_id: str
-        :param upload_id: (required)
-        :type upload_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
@@ -506,9 +497,8 @@ class SensorApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._complete_multipart_upload_serialize(
+        _param = self._get_sensor_serialize(
             sensor_id=sensor_id,
-            upload_id=upload_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -516,8 +506,9 @@ class SensorApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "Sensor",
             '400': None,
+            '404': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -526,10 +517,9 @@ class SensorApi:
         return response_data.response
 
 
-    def _complete_multipart_upload_serialize(
+    def _get_sensor_serialize(
         self,
         sensor_id,
-        upload_id,
         _request_auth,
         _content_type,
         _headers,
@@ -551,14 +541,18 @@ class SensorApi:
         # process the path parameters
         if sensor_id is not None:
             _path_params['sensor_id'] = sensor_id
-        if upload_id is not None:
-            _path_params['upload_id'] = upload_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(
+            [
+                'application/json'
+            ]
+        )
 
 
         # authentication setting
@@ -567,8 +561,8 @@ class SensorApi:
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/api/v2/sensors/{sensor_id}/upload/{upload_id}/complete',
+            method='GET',
+            resource_path='/api/v2/sensors/{sensor_id}',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -585,9 +579,9 @@ class SensorApi:
 
 
     @validate_call
-    def create_sensor(
+    def query_sensor(
         self,
-        create_sensor_request: Annotated[CreateSensorRequest, Field(description="Request body for create")],
+        sensor_sor_query_request: Annotated[Optional[SensorSORQueryRequest], Field(description="Request body for create")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -600,12 +594,12 @@ class SensorApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> Model:
-        """Create a Sensor
+    ) -> SensorQueryResponse:
+        """Query a Sensor
 
 
-        :param create_sensor_request: Request body for create (required)
-        :type create_sensor_request: CreateSensorRequest
+        :param sensor_sor_query_request: Request body for create
+        :type sensor_sor_query_request: SensorSORQueryRequest
         :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
@@ -628,8 +622,8 @@ class SensorApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._create_sensor_serialize(
-            create_sensor_request=create_sensor_request,
+        _param = self._query_sensor_serialize(
+            sensor_sor_query_request=sensor_sor_query_request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -637,9 +631,8 @@ class SensorApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '201': "Model",
+            '200': "SensorQueryResponse",
             '400': None,
-            '422': "ValidationErrorModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -653,9 +646,9 @@ class SensorApi:
 
 
     @validate_call
-    def create_sensor_with_http_info(
+    def query_sensor_with_http_info(
         self,
-        create_sensor_request: Annotated[CreateSensorRequest, Field(description="Request body for create")],
+        sensor_sor_query_request: Annotated[Optional[SensorSORQueryRequest], Field(description="Request body for create")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -668,12 +661,12 @@ class SensorApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[Model]:
-        """Create a Sensor
+    ) -> ApiResponse[SensorQueryResponse]:
+        """Query a Sensor
 
 
-        :param create_sensor_request: Request body for create (required)
-        :type create_sensor_request: CreateSensorRequest
+        :param sensor_sor_query_request: Request body for create
+        :type sensor_sor_query_request: SensorSORQueryRequest
         :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
@@ -696,8 +689,8 @@ class SensorApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._create_sensor_serialize(
-            create_sensor_request=create_sensor_request,
+        _param = self._query_sensor_serialize(
+            sensor_sor_query_request=sensor_sor_query_request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -705,9 +698,8 @@ class SensorApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '201': "Model",
+            '200': "SensorQueryResponse",
             '400': None,
-            '422': "ValidationErrorModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -721,9 +713,9 @@ class SensorApi:
 
 
     @validate_call
-    def create_sensor_without_preload_content(
+    def query_sensor_without_preload_content(
         self,
-        create_sensor_request: Annotated[CreateSensorRequest, Field(description="Request body for create")],
+        sensor_sor_query_request: Annotated[Optional[SensorSORQueryRequest], Field(description="Request body for create")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -737,11 +729,11 @@ class SensorApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Create a Sensor
+        """Query a Sensor
 
 
-        :param create_sensor_request: Request body for create (required)
-        :type create_sensor_request: CreateSensorRequest
+        :param sensor_sor_query_request: Request body for create
+        :type sensor_sor_query_request: SensorSORQueryRequest
         :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
@@ -764,8 +756,8 @@ class SensorApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._create_sensor_serialize(
-            create_sensor_request=create_sensor_request,
+        _param = self._query_sensor_serialize(
+            sensor_sor_query_request=sensor_sor_query_request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -773,9 +765,8 @@ class SensorApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '201': "Model",
+            '200': "SensorQueryResponse",
             '400': None,
-            '422': "ValidationErrorModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -784,9 +775,9 @@ class SensorApi:
         return response_data.response
 
 
-    def _create_sensor_serialize(
+    def _query_sensor_serialize(
         self,
-        create_sensor_request,
+        sensor_sor_query_request,
         _request_auth,
         _content_type,
         _headers,
@@ -810,8 +801,8 @@ class SensorApi:
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if create_sensor_request is not None:
-            _body_params = create_sensor_request
+        if sensor_sor_query_request is not None:
+            _body_params = sensor_sor_query_request
 
 
         # set the HTTP header `Accept`
@@ -842,7 +833,7 @@ class SensorApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/api/v2/sensors/create',
+            resource_path='/api/v2/sensors/query',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -859,9 +850,13 @@ class SensorApi:
 
 
     @validate_call
-    def delete_model(
+    def sensor_sor_api_v3_model_cards_query_get(
         self,
-        sensor_id: StrictStr,
+        model_name_eq: Annotated[Optional[StrictStr], Field(description="substring match on model name")] = None,
+        model_name_contains: Annotated[Optional[StrictStr], Field(description="substring match on model name")] = None,
+        limit: Optional[Annotated[int, Field(le=100, strict=True, ge=1)]] = None,
+        offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None,
+        sort: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="allow sorting by model name or created at timestamp, ascending (+) or the default descending (-)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -874,12 +869,20 @@ class SensorApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> None:
-        """Remove an Adhoc Sensor
+    ) -> SensorSORModelCardQueryResponse:
+        """List Model Cards
 
 
-        :param sensor_id: (required)
-        :type sensor_id: str
+        :param model_name_eq: substring match on model name
+        :type model_name_eq: str
+        :param model_name_contains: substring match on model name
+        :type model_name_contains: str
+        :param limit:
+        :type limit: int
+        :param offset:
+        :type offset: int
+        :param sort: allow sorting by model name or created at timestamp, ascending (+) or the default descending (-)
+        :type sort: 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
@@ -902,8 +905,12 @@ class SensorApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._delete_model_serialize(
-            sensor_id=sensor_id,
+        _param = self._sensor_sor_api_v3_model_cards_query_get_serialize(
+            model_name_eq=model_name_eq,
+            model_name_contains=model_name_contains,
+            limit=limit,
+            offset=offset,
+            sort=sort,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -911,9 +918,8 @@ class SensorApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '204': None,
+            '200': "SensorSORModelCardQueryResponse",
             '400': None,
-            '404': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -927,9 +933,13 @@ class SensorApi:
 
 
     @validate_call
-    def delete_model_with_http_info(
+    def sensor_sor_api_v3_model_cards_query_get_with_http_info(
         self,
-        sensor_id: StrictStr,
+        model_name_eq: Annotated[Optional[StrictStr], Field(description="substring match on model name")] = None,
+        model_name_contains: Annotated[Optional[StrictStr], Field(description="substring match on model name")] = None,
+        limit: Optional[Annotated[int, Field(le=100, strict=True, ge=1)]] = None,
+        offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None,
+        sort: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="allow sorting by model name or created at timestamp, ascending (+) or the default descending (-)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -942,12 +952,20 @@ class SensorApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[None]:
-        """Remove an Adhoc Sensor
+    ) -> ApiResponse[SensorSORModelCardQueryResponse]:
+        """List Model Cards
 
 
-        :param sensor_id: (required)
-        :type sensor_id: str
+        :param model_name_eq: substring match on model name
+        :type model_name_eq: str
+        :param model_name_contains: substring match on model name
+        :type model_name_contains: str
+        :param limit:
+        :type limit: int
+        :param offset:
+        :type offset: int
+        :param sort: allow sorting by model name or created at timestamp, ascending (+) or the default descending (-)
+        :type sort: 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
@@ -970,8 +988,12 @@ class SensorApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._delete_model_serialize(
-            sensor_id=sensor_id,
+        _param = self._sensor_sor_api_v3_model_cards_query_get_serialize(
+            model_name_eq=model_name_eq,
+            model_name_contains=model_name_contains,
+            limit=limit,
+            offset=offset,
+            sort=sort,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -979,9 +1001,8 @@ class SensorApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '204': None,
+            '200': "SensorSORModelCardQueryResponse",
             '400': None,
-            '404': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -995,9 +1016,13 @@ class SensorApi:
 
 
     @validate_call
-    def delete_model_without_preload_content(
+    def sensor_sor_api_v3_model_cards_query_get_without_preload_content(
         self,
-        sensor_id: StrictStr,
+        model_name_eq: Annotated[Optional[StrictStr], Field(description="substring match on model name")] = None,
+        model_name_contains: Annotated[Optional[StrictStr], Field(description="substring match on model name")] = None,
+        limit: Optional[Annotated[int, Field(le=100, strict=True, ge=1)]] = None,
+        offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None,
+        sort: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="allow sorting by model name or created at timestamp, ascending (+) or the default descending (-)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1011,11 +1036,19 @@ class SensorApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Remove an Adhoc Sensor
+        """List Model Cards
 
 
-        :param sensor_id: (required)
-        :type sensor_id: str
+        :param model_name_eq: substring match on model name
+        :type model_name_eq: str
+        :param model_name_contains: substring match on model name
+        :type model_name_contains: str
+        :param limit:
+        :type limit: int
+        :param offset:
+        :type offset: int
+        :param sort: allow sorting by model name or created at timestamp, ascending (+) or the default descending (-)
+        :type sort: 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
@@ -1038,8 +1071,12 @@ class SensorApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._delete_model_serialize(
-            sensor_id=sensor_id,
+        _param = self._sensor_sor_api_v3_model_cards_query_get_serialize(
+            model_name_eq=model_name_eq,
+            model_name_contains=model_name_contains,
+            limit=limit,
+            offset=offset,
+            sort=sort,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1047,9 +1084,8 @@ class SensorApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '204': None,
+            '200': "SensorSORModelCardQueryResponse",
             '400': None,
-            '404': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1058,9 +1094,13 @@ class SensorApi:
         return response_data.response
 
 
-    def _delete_model_serialize(
+    def _sensor_sor_api_v3_model_cards_query_get_serialize(
         self,
-        sensor_id,
+        model_name_eq,
+        model_name_contains,
+        limit,
+        offset,
+        sort,
         _request_auth,
         _content_type,
         _headers,
@@ -1080,874 +1120,38 @@ class SensorApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
-        if sensor_id is not None:
-            _path_params['sensor_id'] = sensor_id
         # process the query parameters
+        if model_name_eq is not None:
+            
+            _query_params.append(('model_name[eq]', model_name_eq))
+            
+        if model_name_contains is not None:
+            
+            _query_params.append(('model_name[contains]', model_name_contains))
+            
+        if limit is not None:
+            
+            _query_params.append(('limit', limit))
+            
+        if offset is not None:
+            
+            _query_params.append(('offset', offset))
+            
+        if sort is not None:
+            
+            _query_params.append(('sort', sort))
+            
         # process the header parameters
         # process the form parameters
         # process the body parameter
 
 
-
-
-        # authentication setting
-        _auth_settings: List[str] = [
-            'BearerAuth'
-        ]
-
-        return self.api_client.param_serialize(
-            method='DELETE',
-            resource_path='/api/v2/sensors/{sensor_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_model(
-        self,
-        sensor_id: StrictStr,
-        _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,
-    ) -> Model:
-        """Get Model
-
-
-        :param sensor_id: (required)
-        :type sensor_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_model_serialize(
-            sensor_id=sensor_id,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "Model",
-            '400': None,
-            '404': None,
-        }
-        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_model_with_http_info(
-        self,
-        sensor_id: StrictStr,
-        _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[Model]:
-        """Get Model
-
-
-        :param sensor_id: (required)
-        :type sensor_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_model_serialize(
-            sensor_id=sensor_id,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "Model",
-            '400': None,
-            '404': None,
-        }
-        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_model_without_preload_content(
-        self,
-        sensor_id: StrictStr,
-        _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 Model
-
-
-        :param sensor_id: (required)
-        :type sensor_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_model_serialize(
-            sensor_id=sensor_id,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "Model",
-            '400': None,
-            '404': None,
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _get_model_serialize(
-        self,
-        sensor_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 sensor_id is not None:
-            _path_params['sensor_id'] = sensor_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(
-            [
-                'application/json'
-            ]
-        )
-
-
-        # authentication setting
-        _auth_settings: List[str] = [
-            'BearerAuth'
-        ]
-
-        return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/api/v2/sensors/{sensor_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 query_sensor(
-        self,
-        sensor_sor_query_request: Annotated[Optional[SensorSORQueryRequest], Field(description="Request body for create")] = 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,
-    ) -> ModelQueryResponse:
-        """Query a Sensor
-
-
-        :param sensor_sor_query_request: Request body for create
-        :type sensor_sor_query_request: SensorSORQueryRequest
-        :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_sensor_serialize(
-            sensor_sor_query_request=sensor_sor_query_request,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ModelQueryResponse",
-            '400': None,
-        }
-        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_sensor_with_http_info(
-        self,
-        sensor_sor_query_request: Annotated[Optional[SensorSORQueryRequest], Field(description="Request body for create")] = 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[ModelQueryResponse]:
-        """Query a Sensor
-
-
-        :param sensor_sor_query_request: Request body for create
-        :type sensor_sor_query_request: SensorSORQueryRequest
-        :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_sensor_serialize(
-            sensor_sor_query_request=sensor_sor_query_request,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ModelQueryResponse",
-            '400': None,
-        }
-        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_sensor_without_preload_content(
-        self,
-        sensor_sor_query_request: Annotated[Optional[SensorSORQueryRequest], Field(description="Request body for create")] = 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:
-        """Query a Sensor
-
-
-        :param sensor_sor_query_request: Request body for create
-        :type sensor_sor_query_request: SensorSORQueryRequest
-        :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_sensor_serialize(
-            sensor_sor_query_request=sensor_sor_query_request,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ModelQueryResponse",
-            '400': None,
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _query_sensor_serialize(
-        self,
-        sensor_sor_query_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
-        # process the query parameters
-        # process the header parameters
-        # process the form parameters
-        # process the body parameter
-        if sensor_sor_query_request is not None:
-            _body_params = sensor_sor_query_request
-
-
-        # set the HTTP header `Accept`
-        _header_params['Accept'] = self.api_client.select_header_accept(
-            [
-                'application/json'
-            ]
-        )
-
-        # 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'
-                    ]
-                )
-            )
-            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='/api/v2/sensors/query',
-            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 sensor_sor_api_v3_model_cards_query_get(
-        self,
-        model_name_eq: Annotated[Optional[StrictStr], Field(description="substring match on model name")] = None,
-        model_name_contains: Annotated[Optional[StrictStr], Field(description="substring match on model name")] = None,
-        limit: Optional[Annotated[int, Field(le=100, strict=True, ge=1)]] = None,
-        offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None,
-        sort: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="allow sorting by model name or created at timestamp, ascending (+) or the default descending (-)")] = 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,
-    ) -> SensorSORModelCardQueryResponse:
-        """List Model Cards
-
-
-        :param model_name_eq: substring match on model name
-        :type model_name_eq: str
-        :param model_name_contains: substring match on model name
-        :type model_name_contains: str
-        :param limit:
-        :type limit: int
-        :param offset:
-        :type offset: int
-        :param sort: allow sorting by model name or created at timestamp, ascending (+) or the default descending (-)
-        :type sort: 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._sensor_sor_api_v3_model_cards_query_get_serialize(
-            model_name_eq=model_name_eq,
-            model_name_contains=model_name_contains,
-            limit=limit,
-            offset=offset,
-            sort=sort,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "SensorSORModelCardQueryResponse",
-            '400': None,
-        }
-        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 sensor_sor_api_v3_model_cards_query_get_with_http_info(
-        self,
-        model_name_eq: Annotated[Optional[StrictStr], Field(description="substring match on model name")] = None,
-        model_name_contains: Annotated[Optional[StrictStr], Field(description="substring match on model name")] = None,
-        limit: Optional[Annotated[int, Field(le=100, strict=True, ge=1)]] = None,
-        offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None,
-        sort: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="allow sorting by model name or created at timestamp, ascending (+) or the default descending (-)")] = 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[SensorSORModelCardQueryResponse]:
-        """List Model Cards
-
-
-        :param model_name_eq: substring match on model name
-        :type model_name_eq: str
-        :param model_name_contains: substring match on model name
-        :type model_name_contains: str
-        :param limit:
-        :type limit: int
-        :param offset:
-        :type offset: int
-        :param sort: allow sorting by model name or created at timestamp, ascending (+) or the default descending (-)
-        :type sort: 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._sensor_sor_api_v3_model_cards_query_get_serialize(
-            model_name_eq=model_name_eq,
-            model_name_contains=model_name_contains,
-            limit=limit,
-            offset=offset,
-            sort=sort,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "SensorSORModelCardQueryResponse",
-            '400': None,
-        }
-        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 sensor_sor_api_v3_model_cards_query_get_without_preload_content(
-        self,
-        model_name_eq: Annotated[Optional[StrictStr], Field(description="substring match on model name")] = None,
-        model_name_contains: Annotated[Optional[StrictStr], Field(description="substring match on model name")] = None,
-        limit: Optional[Annotated[int, Field(le=100, strict=True, ge=1)]] = None,
-        offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None,
-        sort: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="allow sorting by model name or created at timestamp, ascending (+) or the default descending (-)")] = 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:
-        """List Model Cards
-
-
-        :param model_name_eq: substring match on model name
-        :type model_name_eq: str
-        :param model_name_contains: substring match on model name
-        :type model_name_contains: str
-        :param limit:
-        :type limit: int
-        :param offset:
-        :type offset: int
-        :param sort: allow sorting by model name or created at timestamp, ascending (+) or the default descending (-)
-        :type sort: 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._sensor_sor_api_v3_model_cards_query_get_serialize(
-            model_name_eq=model_name_eq,
-            model_name_contains=model_name_contains,
-            limit=limit,
-            offset=offset,
-            sort=sort,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "SensorSORModelCardQueryResponse",
-            '400': None,
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _sensor_sor_api_v3_model_cards_query_get_serialize(
-        self,
-        model_name_eq,
-        model_name_contains,
-        limit,
-        offset,
-        sort,
-        _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
-        # process the query parameters
-        if model_name_eq is not None:
-            
-            _query_params.append(('model_name[eq]', model_name_eq))
-            
-        if model_name_contains is not None:
-            
-            _query_params.append(('model_name[contains]', model_name_contains))
-            
-        if limit is not None:
-            
-            _query_params.append(('limit', limit))
-            
-        if offset is not None:
-            
-            _query_params.append(('offset', offset))
-            
-        if sort is not None:
-            
-            _query_params.append(('sort', sort))
-            
-        # 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(
-            [
-                'application/json'
-            ]
-        )
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            [
+                'application/json'
+            ]
+        )
 
 
         # authentication setting
@@ -1971,313 +1175,3 @@ class SensorApi:
         )
 
 
-
-
-    @validate_call
-    def upload_model_part(
-        self,
-        sensor_id: StrictStr,
-        upload_id: StrictStr,
-        part: StrictInt,
-        body: Optional[Any],
-        _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:
-        """Upload part
-
-
-        :param sensor_id: (required)
-        :type sensor_id: str
-        :param upload_id: (required)
-        :type upload_id: str
-        :param part: (required)
-        :type part: int
-        :param body: (required)
-        :type body: object
-        :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_model_part_serialize(
-            sensor_id=sensor_id,
-            upload_id=upload_id,
-            part=part,
-            body=body,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
-            '400': None,
-        }
-        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_model_part_with_http_info(
-        self,
-        sensor_id: StrictStr,
-        upload_id: StrictStr,
-        part: StrictInt,
-        body: Optional[Any],
-        _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]:
-        """Upload part
-
-
-        :param sensor_id: (required)
-        :type sensor_id: str
-        :param upload_id: (required)
-        :type upload_id: str
-        :param part: (required)
-        :type part: int
-        :param body: (required)
-        :type body: object
-        :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_model_part_serialize(
-            sensor_id=sensor_id,
-            upload_id=upload_id,
-            part=part,
-            body=body,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
-            '400': None,
-        }
-        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_model_part_without_preload_content(
-        self,
-        sensor_id: StrictStr,
-        upload_id: StrictStr,
-        part: StrictInt,
-        body: Optional[Any],
-        _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:
-        """Upload part
-
-
-        :param sensor_id: (required)
-        :type sensor_id: str
-        :param upload_id: (required)
-        :type upload_id: str
-        :param part: (required)
-        :type part: int
-        :param body: (required)
-        :type body: object
-        :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_model_part_serialize(
-            sensor_id=sensor_id,
-            upload_id=upload_id,
-            part=part,
-            body=body,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
-            '400': None,
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _upload_model_part_serialize(
-        self,
-        sensor_id,
-        upload_id,
-        part,
-        body,
-        _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 sensor_id is not None:
-            _path_params['sensor_id'] = sensor_id
-        if upload_id is not None:
-            _path_params['upload_id'] = upload_id
-        if part is not None:
-            _path_params['part'] = part
-        # process the query parameters
-        # process the header parameters
-        # process the form parameters
-        # process the body parameter
-        if body is not None:
-            _body_params = body
-
-
-
-        # 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/octet-stream'
-                    ]
-                )
-            )
-            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='/api/v2/sensors/{sensor_id}/upload/{upload_id}/part/{part}',
-            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
-        )
-
-