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

hiddenlayer/sdk/rest/api/model_supply_chain_api.py

@@ -17,15 +17,18 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 from typing_extensions import Annotated
 
 from datetime import datetime
-from pydantic import Field, StrictBool, StrictStr, field_validator
+from pydantic import Field, StrictBool, StrictInt, StrictStr, field_validator
 from typing import List, Optional
 from typing_extensions import Annotated
-from hiddenlayer.sdk.rest.models.model_scan_api_v3_scan_model_version_id_patch200_response import ModelScanApiV3ScanModelVersionIdPatch200Response
-from hiddenlayer.sdk.rest.models.model_scan_api_v3_scan_query200_response import ModelScanApiV3ScanQuery200Response
+from hiddenlayer.sdk.rest.models.begin_multi_file_upload200_response import BeginMultiFileUpload200Response
+from hiddenlayer.sdk.rest.models.begin_multipart_file_upload200_response import BeginMultipartFileUpload200Response
+from hiddenlayer.sdk.rest.models.get_condensed_model_scan_reports200_response import GetCondensedModelScanReports200Response
+from hiddenlayer.sdk.rest.models.multi_file_upload_request_v3 import MultiFileUploadRequestV3
+from hiddenlayer.sdk.rest.models.notify_model_scan_completed200_response import NotifyModelScanCompleted200Response
 from hiddenlayer.sdk.rest.models.scan_create_request import ScanCreateRequest
 from hiddenlayer.sdk.rest.models.scan_job import ScanJob
 from hiddenlayer.sdk.rest.models.scan_report_v3 import ScanReportV3
-from hiddenlayer.sdk.rest.models.scan_results_v2 import ScanResultsV2
+from hiddenlayer.sdk.rest.models.scan_results_map_v3 import ScanResultsMapV3
 
 from hiddenlayer.sdk.rest.api_client import ApiClient, RequestSerialized
 from hiddenlayer.sdk.rest.api_response import ApiResponse
@@ -46,10 +49,9 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def model_scan_api_v3_scan_model_version_id_get(
+    def begin_multi_file_upload(
         self,
-        scan_id: StrictStr,
-        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = None,
+        multi_file_upload_request_v3: Annotated[MultiFileUploadRequestV3, Field(description="Request body for create")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -62,14 +64,12 @@ class ModelSupplyChainApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ScanReportV3:
-        """Get Result of a Model Scan
+    ) -> BeginMultiFileUpload200Response:
+        """Start V3 Upload
 
 
-        :param scan_id: (required)
-        :type scan_id: str
-        :param has_detections: Filter file_results to only those that have detections (and parents)
-        :type has_detections: bool
+        :param multi_file_upload_request_v3: Request body for create (required)
+        :type multi_file_upload_request_v3: MultiFileUploadRequestV3
         :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
@@ -92,9 +92,8 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._model_scan_api_v3_scan_model_version_id_get_serialize(
-            scan_id=scan_id,
-            has_detections=has_detections,
+        _param = self._begin_multi_file_upload_serialize(
+            multi_file_upload_request_v3=multi_file_upload_request_v3,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -102,9 +101,9 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ScanReportV3",
+            '200': "BeginMultiFileUpload200Response",
             '400': None,
-            '404': None,
+            '422': "ValidationErrorModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -118,10 +117,9 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def model_scan_api_v3_scan_model_version_id_get_with_http_info(
+    def begin_multi_file_upload_with_http_info(
         self,
-        scan_id: StrictStr,
-        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = None,
+        multi_file_upload_request_v3: Annotated[MultiFileUploadRequestV3, Field(description="Request body for create")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -134,14 +132,12 @@ class ModelSupplyChainApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[ScanReportV3]:
-        """Get Result of a Model Scan
+    ) -> ApiResponse[BeginMultiFileUpload200Response]:
+        """Start V3 Upload
 
 
-        :param scan_id: (required)
-        :type scan_id: str
-        :param has_detections: Filter file_results to only those that have detections (and parents)
-        :type has_detections: bool
+        :param multi_file_upload_request_v3: Request body for create (required)
+        :type multi_file_upload_request_v3: MultiFileUploadRequestV3
         :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
@@ -164,9 +160,8 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._model_scan_api_v3_scan_model_version_id_get_serialize(
-            scan_id=scan_id,
-            has_detections=has_detections,
+        _param = self._begin_multi_file_upload_serialize(
+            multi_file_upload_request_v3=multi_file_upload_request_v3,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -174,9 +169,9 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ScanReportV3",
+            '200': "BeginMultiFileUpload200Response",
             '400': None,
-            '404': None,
+            '422': "ValidationErrorModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -190,10 +185,9 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def model_scan_api_v3_scan_model_version_id_get_without_preload_content(
+    def begin_multi_file_upload_without_preload_content(
         self,
-        scan_id: StrictStr,
-        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = None,
+        multi_file_upload_request_v3: Annotated[MultiFileUploadRequestV3, Field(description="Request body for create")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -207,13 +201,11 @@ class ModelSupplyChainApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Get Result of a Model Scan
+        """Start V3 Upload
 
 
-        :param scan_id: (required)
-        :type scan_id: str
-        :param has_detections: Filter file_results to only those that have detections (and parents)
-        :type has_detections: bool
+        :param multi_file_upload_request_v3: Request body for create (required)
+        :type multi_file_upload_request_v3: MultiFileUploadRequestV3
         :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
@@ -236,9 +228,8 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._model_scan_api_v3_scan_model_version_id_get_serialize(
-            scan_id=scan_id,
-            has_detections=has_detections,
+        _param = self._begin_multi_file_upload_serialize(
+            multi_file_upload_request_v3=multi_file_upload_request_v3,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -246,9 +237,9 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ScanReportV3",
+            '200': "BeginMultiFileUpload200Response",
             '400': None,
-            '404': None,
+            '422': "ValidationErrorModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -257,10 +248,9 @@ class ModelSupplyChainApi:
         return response_data.response
 
 
-    def _model_scan_api_v3_scan_model_version_id_get_serialize(
+    def _begin_multi_file_upload_serialize(
         self,
-        scan_id,
-        has_detections,
+        multi_file_upload_request_v3,
         _request_auth,
         _content_type,
         _headers,
@@ -280,26 +270,34 @@ class ModelSupplyChainApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
-        if scan_id is not None:
-            _path_params['scan_id'] = scan_id
         # process the query parameters
-        if has_detections is not None:
-            
-            _query_params.append(('has_detections', has_detections))
-            
         # process the header parameters
         # process the form parameters
         # process the body parameter
+        if multi_file_upload_request_v3 is not None:
+            _body_params = multi_file_upload_request_v3
 
 
         # set the HTTP header `Accept`
         _header_params['Accept'] = self.api_client.select_header_accept(
             [
-                'application/json; charset=utf-8', 
-                'application/sarif+json'
+                '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] = [
@@ -307,8 +305,8 @@ class ModelSupplyChainApi:
         ]
 
         return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/scan/v3/results/{scan_id}',
+            method='POST',
+            resource_path='/scan/v3/upload',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -325,11 +323,11 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def model_scan_api_v3_scan_model_version_id_patch(
+    def begin_multipart_file_upload(
         self,
+        file_content_length: Annotated[StrictInt, Field(description="Added file size in bytes")],
+        file_name: Annotated[StrictStr, Field(description="Added file name")],
         scan_id: StrictStr,
-        scan_report_v3: Annotated[ScanReportV3, Field(description="Request body for partial update")],
-        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -342,16 +340,16 @@ class ModelSupplyChainApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ModelScanApiV3ScanModelVersionIdPatch200Response:
-        """Indicate part (file or files) of a model scan has completed
+    ) -> BeginMultipartFileUpload200Response:
+        """Add file to V3 Upload
 
 
+        :param file_content_length: Added file size in bytes (required)
+        :type file_content_length: int
+        :param file_name: Added file name (required)
+        :type file_name: str
         :param scan_id: (required)
         :type scan_id: str
-        :param scan_report_v3: Request body for partial update (required)
-        :type scan_report_v3: ScanReportV3
-        :param has_detections: Filter file_results to only those that have detections (and parents)
-        :type has_detections: bool
         :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
@@ -374,10 +372,10 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._model_scan_api_v3_scan_model_version_id_patch_serialize(
+        _param = self._begin_multipart_file_upload_serialize(
+            file_content_length=file_content_length,
+            file_name=file_name,
             scan_id=scan_id,
-            scan_report_v3=scan_report_v3,
-            has_detections=has_detections,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -385,7 +383,7 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ModelScanApiV3ScanModelVersionIdPatch200Response",
+            '200': "BeginMultipartFileUpload200Response",
             '400': None,
             '422': "ValidationErrorModel",
         }
@@ -401,11 +399,11 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def model_scan_api_v3_scan_model_version_id_patch_with_http_info(
+    def begin_multipart_file_upload_with_http_info(
         self,
+        file_content_length: Annotated[StrictInt, Field(description="Added file size in bytes")],
+        file_name: Annotated[StrictStr, Field(description="Added file name")],
         scan_id: StrictStr,
-        scan_report_v3: Annotated[ScanReportV3, Field(description="Request body for partial update")],
-        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -418,16 +416,16 @@ class ModelSupplyChainApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[ModelScanApiV3ScanModelVersionIdPatch200Response]:
-        """Indicate part (file or files) of a model scan has completed
+    ) -> ApiResponse[BeginMultipartFileUpload200Response]:
+        """Add file to V3 Upload
 
 
+        :param file_content_length: Added file size in bytes (required)
+        :type file_content_length: int
+        :param file_name: Added file name (required)
+        :type file_name: str
         :param scan_id: (required)
         :type scan_id: str
-        :param scan_report_v3: Request body for partial update (required)
-        :type scan_report_v3: ScanReportV3
-        :param has_detections: Filter file_results to only those that have detections (and parents)
-        :type has_detections: bool
         :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
@@ -450,10 +448,10 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._model_scan_api_v3_scan_model_version_id_patch_serialize(
+        _param = self._begin_multipart_file_upload_serialize(
+            file_content_length=file_content_length,
+            file_name=file_name,
             scan_id=scan_id,
-            scan_report_v3=scan_report_v3,
-            has_detections=has_detections,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -461,7 +459,7 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ModelScanApiV3ScanModelVersionIdPatch200Response",
+            '200': "BeginMultipartFileUpload200Response",
             '400': None,
             '422': "ValidationErrorModel",
         }
@@ -477,11 +475,11 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def model_scan_api_v3_scan_model_version_id_patch_without_preload_content(
+    def begin_multipart_file_upload_without_preload_content(
         self,
+        file_content_length: Annotated[StrictInt, Field(description="Added file size in bytes")],
+        file_name: Annotated[StrictStr, Field(description="Added file name")],
         scan_id: StrictStr,
-        scan_report_v3: Annotated[ScanReportV3, Field(description="Request body for partial update")],
-        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -495,15 +493,15 @@ class ModelSupplyChainApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Indicate part (file or files) of a model scan has completed
+        """Add file to V3 Upload
 
 
+        :param file_content_length: Added file size in bytes (required)
+        :type file_content_length: int
+        :param file_name: Added file name (required)
+        :type file_name: str
         :param scan_id: (required)
         :type scan_id: str
-        :param scan_report_v3: Request body for partial update (required)
-        :type scan_report_v3: ScanReportV3
-        :param has_detections: Filter file_results to only those that have detections (and parents)
-        :type has_detections: bool
         :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
@@ -526,10 +524,10 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._model_scan_api_v3_scan_model_version_id_patch_serialize(
+        _param = self._begin_multipart_file_upload_serialize(
+            file_content_length=file_content_length,
+            file_name=file_name,
             scan_id=scan_id,
-            scan_report_v3=scan_report_v3,
-            has_detections=has_detections,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -537,7 +535,7 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ModelScanApiV3ScanModelVersionIdPatch200Response",
+            '200': "BeginMultipartFileUpload200Response",
             '400': None,
             '422': "ValidationErrorModel",
         }
@@ -548,11 +546,11 @@ class ModelSupplyChainApi:
         return response_data.response
 
 
-    def _model_scan_api_v3_scan_model_version_id_patch_serialize(
+    def _begin_multipart_file_upload_serialize(
         self,
+        file_content_length,
+        file_name,
         scan_id,
-        scan_report_v3,
-        has_detections,
         _request_auth,
         _content_type,
         _headers,
@@ -575,15 +573,13 @@ class ModelSupplyChainApi:
         if scan_id is not None:
             _path_params['scan_id'] = scan_id
         # process the query parameters
-        if has_detections is not None:
-            
-            _query_params.append(('has_detections', has_detections))
-            
         # process the header parameters
+        if file_content_length is not None:
+            _header_params['file-content-length'] = file_content_length
+        if file_name is not None:
+            _header_params['file-name'] = file_name
         # process the form parameters
         # process the body parameter
-        if scan_report_v3 is not None:
-            _body_params = scan_report_v3
 
 
         # set the HTTP header `Accept`
@@ -593,19 +589,6 @@ class ModelSupplyChainApi:
             ]
         )
 
-        # 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] = [
@@ -613,8 +596,8 @@ class ModelSupplyChainApi:
         ]
 
         return self.api_client.param_serialize(
-            method='PATCH',
-            resource_path='/scan/v3/results/{scan_id}',
+            method='POST',
+            resource_path='/scan/v3/upload/{scan_id}/file',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -631,11 +614,9 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def model_scan_api_v3_scan_model_version_id_post(
+    def complete_multi_file_upload(
         self,
         scan_id: StrictStr,
-        scan_report_v3: Annotated[ScanReportV3, Field(description="Request body for create")],
-        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -648,16 +629,12 @@ class ModelSupplyChainApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> None:
-        """Indicate model scan has started
+    ) -> BeginMultiFileUpload200Response:
+        """Indicate All files are uploaded and start the scan
 
 
         :param scan_id: (required)
         :type scan_id: str
-        :param scan_report_v3: Request body for create (required)
-        :type scan_report_v3: ScanReportV3
-        :param has_detections: Filter file_results to only those that have detections (and parents)
-        :type has_detections: bool
         :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
@@ -680,10 +657,8 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._model_scan_api_v3_scan_model_version_id_post_serialize(
+        _param = self._complete_multi_file_upload_serialize(
             scan_id=scan_id,
-            scan_report_v3=scan_report_v3,
-            has_detections=has_detections,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -691,7 +666,7 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '201': None,
+            '200': "BeginMultiFileUpload200Response",
             '400': None,
             '422': "ValidationErrorModel",
         }
@@ -707,11 +682,9 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def model_scan_api_v3_scan_model_version_id_post_with_http_info(
+    def complete_multi_file_upload_with_http_info(
         self,
         scan_id: StrictStr,
-        scan_report_v3: Annotated[ScanReportV3, Field(description="Request body for create")],
-        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -724,16 +697,12 @@ class ModelSupplyChainApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[None]:
-        """Indicate model scan has started
+    ) -> ApiResponse[BeginMultiFileUpload200Response]:
+        """Indicate All files are uploaded and start the scan
 
 
         :param scan_id: (required)
         :type scan_id: str
-        :param scan_report_v3: Request body for create (required)
-        :type scan_report_v3: ScanReportV3
-        :param has_detections: Filter file_results to only those that have detections (and parents)
-        :type has_detections: bool
         :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
@@ -756,10 +725,8 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._model_scan_api_v3_scan_model_version_id_post_serialize(
+        _param = self._complete_multi_file_upload_serialize(
             scan_id=scan_id,
-            scan_report_v3=scan_report_v3,
-            has_detections=has_detections,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -767,7 +734,7 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '201': None,
+            '200': "BeginMultiFileUpload200Response",
             '400': None,
             '422': "ValidationErrorModel",
         }
@@ -783,11 +750,9 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def model_scan_api_v3_scan_model_version_id_post_without_preload_content(
+    def complete_multi_file_upload_without_preload_content(
         self,
         scan_id: StrictStr,
-        scan_report_v3: Annotated[ScanReportV3, Field(description="Request body for create")],
-        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -801,15 +766,11 @@ class ModelSupplyChainApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Indicate model scan has started
+        """Indicate All files are uploaded and start the scan
 
 
         :param scan_id: (required)
         :type scan_id: str
-        :param scan_report_v3: Request body for create (required)
-        :type scan_report_v3: ScanReportV3
-        :param has_detections: Filter file_results to only those that have detections (and parents)
-        :type has_detections: bool
         :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
@@ -832,10 +793,8 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._model_scan_api_v3_scan_model_version_id_post_serialize(
+        _param = self._complete_multi_file_upload_serialize(
             scan_id=scan_id,
-            scan_report_v3=scan_report_v3,
-            has_detections=has_detections,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -843,7 +802,7 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '201': None,
+            '200': "BeginMultiFileUpload200Response",
             '400': None,
             '422': "ValidationErrorModel",
         }
@@ -854,11 +813,9 @@ class ModelSupplyChainApi:
         return response_data.response
 
 
-    def _model_scan_api_v3_scan_model_version_id_post_serialize(
+    def _complete_multi_file_upload_serialize(
         self,
         scan_id,
-        scan_report_v3,
-        has_detections,
         _request_auth,
         _content_type,
         _headers,
@@ -881,15 +838,9 @@ class ModelSupplyChainApi:
         if scan_id is not None:
             _path_params['scan_id'] = scan_id
         # process the query parameters
-        if has_detections is not None:
-            
-            _query_params.append(('has_detections', has_detections))
-            
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if scan_report_v3 is not None:
-            _body_params = scan_report_v3
 
 
         # set the HTTP header `Accept`
@@ -899,19 +850,6 @@ class ModelSupplyChainApi:
             ]
         )
 
-        # 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] = [
@@ -919,8 +857,8 @@ class ModelSupplyChainApi:
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/scan/v3/results/{scan_id}',
+            method='PATCH',
+            resource_path='/scan/v3/upload/{scan_id}',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -937,18 +875,10 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def model_scan_api_v3_scan_query(
+    def complete_multipart_file_upload(
         self,
-        model_version_ids: Annotated[Optional[List[StrictStr]], Field(description="Model Version ID")] = None,
-        model_ids: Annotated[Optional[List[StrictStr]], Field(description="Model ID")] = None,
-        start_time: Annotated[Optional[datetime], Field(description="Start Time")] = None,
-        end_time: Annotated[Optional[datetime], Field(description="End Time")] = None,
-        severity: Annotated[Optional[List[StrictStr]], Field(description="Severities")] = None,
-        status: Annotated[Optional[List[StrictStr]], Field(description="Statuses")] = 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 status, severity or created at, ascending (+) or the default descending (-)")] = None,
-        latest_per_model_version_only: Annotated[Optional[StrictBool], Field(description="only return latest result per model version")] = None,
+        scan_id: StrictStr,
+        file_id: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -961,30 +891,14 @@ class ModelSupplyChainApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ModelScanApiV3ScanQuery200Response:
-        """Get condensed reports for a Model Scan
+    ) -> BeginMultiFileUpload200Response:
+        """Indicate that upload is completed for {file_id}
 
 
-        :param model_version_ids: Model Version ID
-        :type model_version_ids: List[str]
-        :param model_ids: Model ID
-        :type model_ids: List[str]
-        :param start_time: Start Time
-        :type start_time: datetime
-        :param end_time: End Time
-        :type end_time: datetime
-        :param severity: Severities
-        :type severity: List[str]
-        :param status: Statuses
-        :type status: List[str]
-        :param limit:
-        :type limit: int
-        :param offset:
-        :type offset: int
-        :param sort: allow sorting by status, severity or created at, ascending (+) or the default descending (-)
-        :type sort: str
-        :param latest_per_model_version_only: only return latest result per model version
-        :type latest_per_model_version_only: bool
+        :param scan_id: (required)
+        :type scan_id: str
+        :param file_id: (required)
+        :type file_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
@@ -1007,17 +921,9 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._model_scan_api_v3_scan_query_serialize(
-            model_version_ids=model_version_ids,
-            model_ids=model_ids,
-            start_time=start_time,
-            end_time=end_time,
-            severity=severity,
-            status=status,
-            limit=limit,
-            offset=offset,
-            sort=sort,
-            latest_per_model_version_only=latest_per_model_version_only,
+        _param = self._complete_multipart_file_upload_serialize(
+            scan_id=scan_id,
+            file_id=file_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1025,9 +931,9 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ModelScanApiV3ScanQuery200Response",
+            '200': "BeginMultiFileUpload200Response",
             '400': None,
-            '404': None,
+            '422': "ValidationErrorModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1041,18 +947,10 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def model_scan_api_v3_scan_query_with_http_info(
+    def complete_multipart_file_upload_with_http_info(
         self,
-        model_version_ids: Annotated[Optional[List[StrictStr]], Field(description="Model Version ID")] = None,
-        model_ids: Annotated[Optional[List[StrictStr]], Field(description="Model ID")] = None,
-        start_time: Annotated[Optional[datetime], Field(description="Start Time")] = None,
-        end_time: Annotated[Optional[datetime], Field(description="End Time")] = None,
-        severity: Annotated[Optional[List[StrictStr]], Field(description="Severities")] = None,
-        status: Annotated[Optional[List[StrictStr]], Field(description="Statuses")] = 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 status, severity or created at, ascending (+) or the default descending (-)")] = None,
-        latest_per_model_version_only: Annotated[Optional[StrictBool], Field(description="only return latest result per model version")] = None,
+        scan_id: StrictStr,
+        file_id: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1065,30 +963,14 @@ class ModelSupplyChainApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[ModelScanApiV3ScanQuery200Response]:
-        """Get condensed reports for a Model Scan
+    ) -> ApiResponse[BeginMultiFileUpload200Response]:
+        """Indicate that upload is completed for {file_id}
 
 
-        :param model_version_ids: Model Version ID
-        :type model_version_ids: List[str]
-        :param model_ids: Model ID
-        :type model_ids: List[str]
-        :param start_time: Start Time
-        :type start_time: datetime
-        :param end_time: End Time
-        :type end_time: datetime
-        :param severity: Severities
-        :type severity: List[str]
-        :param status: Statuses
-        :type status: List[str]
-        :param limit:
-        :type limit: int
-        :param offset:
-        :type offset: int
-        :param sort: allow sorting by status, severity or created at, ascending (+) or the default descending (-)
-        :type sort: str
-        :param latest_per_model_version_only: only return latest result per model version
-        :type latest_per_model_version_only: bool
+        :param scan_id: (required)
+        :type scan_id: str
+        :param file_id: (required)
+        :type file_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
@@ -1111,10 +993,721 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._model_scan_api_v3_scan_query_serialize(
-            model_version_ids=model_version_ids,
-            model_ids=model_ids,
-            start_time=start_time,
+        _param = self._complete_multipart_file_upload_serialize(
+            scan_id=scan_id,
+            file_id=file_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "BeginMultiFileUpload200Response",
+            '400': None,
+            '422': "ValidationErrorModel",
+        }
+        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 complete_multipart_file_upload_without_preload_content(
+        self,
+        scan_id: StrictStr,
+        file_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:
+        """Indicate that upload is completed for {file_id}
+
+
+        :param scan_id: (required)
+        :type scan_id: str
+        :param file_id: (required)
+        :type file_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._complete_multipart_file_upload_serialize(
+            scan_id=scan_id,
+            file_id=file_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "BeginMultiFileUpload200Response",
+            '400': None,
+            '422': "ValidationErrorModel",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _complete_multipart_file_upload_serialize(
+        self,
+        scan_id,
+        file_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 scan_id is not None:
+            _path_params['scan_id'] = scan_id
+        if file_id is not None:
+            _path_params['file_id'] = file_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='PATCH',
+            resource_path='/scan/v3/upload/{scan_id}/file/{file_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 create_scan_job(
+        self,
+        scan_job: Annotated[ScanJob, Field(description="Request body for create scan 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,
+    ) -> None:
+        """Request a Model Scan Job
+
+
+        :param scan_job: Request body for create scan request (required)
+        :type scan_job: ScanJob
+        :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_scan_job_serialize(
+            scan_job=scan_job,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '201': None,
+            '400': None,
+            '422': "ProblemDetails",
+        }
+        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_scan_job_with_http_info(
+        self,
+        scan_job: Annotated[ScanJob, Field(description="Request body for create scan 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[None]:
+        """Request a Model Scan Job
+
+
+        :param scan_job: Request body for create scan request (required)
+        :type scan_job: ScanJob
+        :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_scan_job_serialize(
+            scan_job=scan_job,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '201': None,
+            '400': None,
+            '422': "ProblemDetails",
+        }
+        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_scan_job_without_preload_content(
+        self,
+        scan_job: Annotated[ScanJob, Field(description="Request body for create scan 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:
+        """Request a Model Scan Job
+
+
+        :param scan_job: Request body for create scan request (required)
+        :type scan_job: ScanJob
+        :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_scan_job_serialize(
+            scan_job=scan_job,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '201': None,
+            '400': None,
+            '422': "ProblemDetails",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _create_scan_job_serialize(
+        self,
+        scan_job,
+        _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 scan_job is not None:
+            _body_params = scan_job
+
+
+        # 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; charset=utf-8', 
+                        '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='POST',
+            resource_path='/scans/v3/jobs',
+            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_condensed_model_scan_reports(
+        self,
+        model_version_ids: Annotated[Optional[List[StrictStr]], Field(description="Model Version ID")] = None,
+        model_ids: Annotated[Optional[List[StrictStr]], Field(description="Model ID")] = None,
+        start_time: Annotated[Optional[datetime], Field(description="Start Time")] = None,
+        end_time: Annotated[Optional[datetime], Field(description="End Time")] = None,
+        severity: Annotated[Optional[List[StrictStr]], Field(description="Severities")] = None,
+        status: Annotated[Optional[List[StrictStr]], Field(description="Statuses")] = 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 status, severity or created at, ascending (+) or the default descending (-)")] = None,
+        latest_per_model_version_only: Annotated[Optional[StrictBool], Field(description="only return latest result per model version")] = 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,
+    ) -> GetCondensedModelScanReports200Response:
+        """Get condensed reports for a Model Scan
+
+
+        :param model_version_ids: Model Version ID
+        :type model_version_ids: List[str]
+        :param model_ids: Model ID
+        :type model_ids: List[str]
+        :param start_time: Start Time
+        :type start_time: datetime
+        :param end_time: End Time
+        :type end_time: datetime
+        :param severity: Severities
+        :type severity: List[str]
+        :param status: Statuses
+        :type status: List[str]
+        :param limit:
+        :type limit: int
+        :param offset:
+        :type offset: int
+        :param sort: allow sorting by status, severity or created at, ascending (+) or the default descending (-)
+        :type sort: str
+        :param latest_per_model_version_only: only return latest result per model version
+        :type latest_per_model_version_only: bool
+        :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_condensed_model_scan_reports_serialize(
+            model_version_ids=model_version_ids,
+            model_ids=model_ids,
+            start_time=start_time,
+            end_time=end_time,
+            severity=severity,
+            status=status,
+            limit=limit,
+            offset=offset,
+            sort=sort,
+            latest_per_model_version_only=latest_per_model_version_only,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GetCondensedModelScanReports200Response",
+            '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_condensed_model_scan_reports_with_http_info(
+        self,
+        model_version_ids: Annotated[Optional[List[StrictStr]], Field(description="Model Version ID")] = None,
+        model_ids: Annotated[Optional[List[StrictStr]], Field(description="Model ID")] = None,
+        start_time: Annotated[Optional[datetime], Field(description="Start Time")] = None,
+        end_time: Annotated[Optional[datetime], Field(description="End Time")] = None,
+        severity: Annotated[Optional[List[StrictStr]], Field(description="Severities")] = None,
+        status: Annotated[Optional[List[StrictStr]], Field(description="Statuses")] = 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 status, severity or created at, ascending (+) or the default descending (-)")] = None,
+        latest_per_model_version_only: Annotated[Optional[StrictBool], Field(description="only return latest result per model version")] = 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[GetCondensedModelScanReports200Response]:
+        """Get condensed reports for a Model Scan
+
+
+        :param model_version_ids: Model Version ID
+        :type model_version_ids: List[str]
+        :param model_ids: Model ID
+        :type model_ids: List[str]
+        :param start_time: Start Time
+        :type start_time: datetime
+        :param end_time: End Time
+        :type end_time: datetime
+        :param severity: Severities
+        :type severity: List[str]
+        :param status: Statuses
+        :type status: List[str]
+        :param limit:
+        :type limit: int
+        :param offset:
+        :type offset: int
+        :param sort: allow sorting by status, severity or created at, ascending (+) or the default descending (-)
+        :type sort: str
+        :param latest_per_model_version_only: only return latest result per model version
+        :type latest_per_model_version_only: bool
+        :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_condensed_model_scan_reports_serialize(
+            model_version_ids=model_version_ids,
+            model_ids=model_ids,
+            start_time=start_time,
+            end_time=end_time,
+            severity=severity,
+            status=status,
+            limit=limit,
+            offset=offset,
+            sort=sort,
+            latest_per_model_version_only=latest_per_model_version_only,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GetCondensedModelScanReports200Response",
+            '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_condensed_model_scan_reports_without_preload_content(
+        self,
+        model_version_ids: Annotated[Optional[List[StrictStr]], Field(description="Model Version ID")] = None,
+        model_ids: Annotated[Optional[List[StrictStr]], Field(description="Model ID")] = None,
+        start_time: Annotated[Optional[datetime], Field(description="Start Time")] = None,
+        end_time: Annotated[Optional[datetime], Field(description="End Time")] = None,
+        severity: Annotated[Optional[List[StrictStr]], Field(description="Severities")] = None,
+        status: Annotated[Optional[List[StrictStr]], Field(description="Statuses")] = 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 status, severity or created at, ascending (+) or the default descending (-)")] = None,
+        latest_per_model_version_only: Annotated[Optional[StrictBool], Field(description="only return latest result per model version")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Get condensed reports for a Model Scan
+
+
+        :param model_version_ids: Model Version ID
+        :type model_version_ids: List[str]
+        :param model_ids: Model ID
+        :type model_ids: List[str]
+        :param start_time: Start Time
+        :type start_time: datetime
+        :param end_time: End Time
+        :type end_time: datetime
+        :param severity: Severities
+        :type severity: List[str]
+        :param status: Statuses
+        :type status: List[str]
+        :param limit:
+        :type limit: int
+        :param offset:
+        :type offset: int
+        :param sort: allow sorting by status, severity or created at, ascending (+) or the default descending (-)
+        :type sort: str
+        :param latest_per_model_version_only: only return latest result per model version
+        :type latest_per_model_version_only: bool
+        :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_condensed_model_scan_reports_serialize(
+            model_version_ids=model_version_ids,
+            model_ids=model_ids,
+            start_time=start_time,
             end_time=end_time,
             severity=severity,
             status=status,
@@ -1129,7 +1722,451 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ModelScanApiV3ScanQuery200Response",
+            '200': "GetCondensedModelScanReports200Response",
+            '400': None,
+            '404': None,
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_condensed_model_scan_reports_serialize(
+        self,
+        model_version_ids,
+        model_ids,
+        start_time,
+        end_time,
+        severity,
+        status,
+        limit,
+        offset,
+        sort,
+        latest_per_model_version_only,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+            'model_version_ids': 'csv',
+            'model_ids': 'csv',
+            'severity': 'csv',
+            'status': 'csv',
+        }
+
+        _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_version_ids is not None:
+            
+            _query_params.append(('model_version_ids', model_version_ids))
+            
+        if model_ids is not None:
+            
+            _query_params.append(('model_ids', model_ids))
+            
+        if start_time is not None:
+            if isinstance(start_time, datetime):
+                _query_params.append(
+                    (
+                        'start_time',
+                        start_time.strftime(
+                            self.api_client.configuration.datetime_format
+                        )
+                    )
+                )
+            else:
+                _query_params.append(('start_time', start_time))
+            
+        if end_time is not None:
+            if isinstance(end_time, datetime):
+                _query_params.append(
+                    (
+                        'end_time',
+                        end_time.strftime(
+                            self.api_client.configuration.datetime_format
+                        )
+                    )
+                )
+            else:
+                _query_params.append(('end_time', end_time))
+            
+        if severity is not None:
+            
+            _query_params.append(('severity', severity))
+            
+        if status is not None:
+            
+            _query_params.append(('status', status))
+            
+        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))
+            
+        if latest_per_model_version_only is not None:
+            
+            _query_params.append(('latest_per_model_version_only', latest_per_model_version_only))
+            
+        # 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; charset=utf-8'
+            ]
+        )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'BearerAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/scan/v3/results',
+            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_scan_jobs(
+        self,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> List[ScanJob]:
+        """List all Model Scan Jobs
+
+
+        :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_scan_jobs_serialize(
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "List[ScanJob]",
+            '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_scan_jobs_with_http_info(
+        self,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[List[ScanJob]]:
+        """List all Model Scan Jobs
+
+
+        :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_scan_jobs_serialize(
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "List[ScanJob]",
+            '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_scan_jobs_without_preload_content(
+        self,
+        _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 all Model Scan Jobs
+
+
+        :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_scan_jobs_serialize(
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "List[ScanJob]",
+            '400': None,
+            '404': None,
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_scan_jobs_serialize(
+        self,
+        _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
+
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            [
+                'application/json; charset=utf-8'
+            ]
+        )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'BearerAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/scans/v3/jobs',
+            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_scan_results(
+        self,
+        scan_id: StrictStr,
+        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = 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,
+    ) -> ScanReportV3:
+        """Get Result of a Model Scan
+
+
+        :param scan_id: (required)
+        :type scan_id: str
+        :param has_detections: Filter file_results to only those that have detections (and parents)
+        :type has_detections: bool
+        :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_scan_results_serialize(
+            scan_id=scan_id,
+            has_detections=has_detections,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ScanReportV3",
             '400': None,
             '404': None,
         }
@@ -1141,22 +2178,86 @@ class ModelSupplyChainApi:
         return self.api_client.response_deserialize(
             response_data=response_data,
             response_types_map=_response_types_map,
-        )
+        ).data
 
 
     @validate_call
-    def model_scan_api_v3_scan_query_without_preload_content(
+    def get_scan_results_with_http_info(
         self,
-        model_version_ids: Annotated[Optional[List[StrictStr]], Field(description="Model Version ID")] = None,
-        model_ids: Annotated[Optional[List[StrictStr]], Field(description="Model ID")] = None,
-        start_time: Annotated[Optional[datetime], Field(description="Start Time")] = None,
-        end_time: Annotated[Optional[datetime], Field(description="End Time")] = None,
-        severity: Annotated[Optional[List[StrictStr]], Field(description="Severities")] = None,
-        status: Annotated[Optional[List[StrictStr]], Field(description="Statuses")] = 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 status, severity or created at, ascending (+) or the default descending (-)")] = None,
-        latest_per_model_version_only: Annotated[Optional[StrictBool], Field(description="only return latest result per model version")] = None,
+        scan_id: StrictStr,
+        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = 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[ScanReportV3]:
+        """Get Result of a Model Scan
+
+
+        :param scan_id: (required)
+        :type scan_id: str
+        :param has_detections: Filter file_results to only those that have detections (and parents)
+        :type has_detections: bool
+        :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_scan_results_serialize(
+            scan_id=scan_id,
+            has_detections=has_detections,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ScanReportV3",
+            '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_scan_results_without_preload_content(
+        self,
+        scan_id: StrictStr,
+        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1170,29 +2271,13 @@ class ModelSupplyChainApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Get condensed reports for a Model Scan
+        """Get Result of a Model Scan
 
 
-        :param model_version_ids: Model Version ID
-        :type model_version_ids: List[str]
-        :param model_ids: Model ID
-        :type model_ids: List[str]
-        :param start_time: Start Time
-        :type start_time: datetime
-        :param end_time: End Time
-        :type end_time: datetime
-        :param severity: Severities
-        :type severity: List[str]
-        :param status: Statuses
-        :type status: List[str]
-        :param limit:
-        :type limit: int
-        :param offset:
-        :type offset: int
-        :param sort: allow sorting by status, severity or created at, ascending (+) or the default descending (-)
-        :type sort: str
-        :param latest_per_model_version_only: only return latest result per model version
-        :type latest_per_model_version_only: bool
+        :param scan_id: (required)
+        :type scan_id: str
+        :param has_detections: Filter file_results to only those that have detections (and parents)
+        :type has_detections: bool
         :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
@@ -1215,17 +2300,9 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._model_scan_api_v3_scan_query_serialize(
-            model_version_ids=model_version_ids,
-            model_ids=model_ids,
-            start_time=start_time,
-            end_time=end_time,
-            severity=severity,
-            status=status,
-            limit=limit,
-            offset=offset,
-            sort=sort,
-            latest_per_model_version_only=latest_per_model_version_only,
+        _param = self._get_scan_results_serialize(
+            scan_id=scan_id,
+            has_detections=has_detections,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1233,7 +2310,7 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ModelScanApiV3ScanQuery200Response",
+            '200': "ScanReportV3",
             '400': None,
             '404': None,
         }
@@ -1244,18 +2321,10 @@ class ModelSupplyChainApi:
         return response_data.response
 
 
-    def _model_scan_api_v3_scan_query_serialize(
+    def _get_scan_results_serialize(
         self,
-        model_version_ids,
-        model_ids,
-        start_time,
-        end_time,
-        severity,
-        status,
-        limit,
-        offset,
-        sort,
-        latest_per_model_version_only,
+        scan_id,
+        has_detections,
         _request_auth,
         _content_type,
         _headers,
@@ -1265,10 +2334,6 @@ class ModelSupplyChainApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
-            'model_version_ids': 'csv',
-            'model_ids': 'csv',
-            'severity': 'csv',
-            'status': 'csv',
         }
 
         _path_params: Dict[str, str] = {}
@@ -1279,64 +2344,12 @@ class ModelSupplyChainApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if scan_id is not None:
+            _path_params['scan_id'] = scan_id
         # process the query parameters
-        if model_version_ids is not None:
-            
-            _query_params.append(('model_version_ids', model_version_ids))
-            
-        if model_ids is not None:
-            
-            _query_params.append(('model_ids', model_ids))
-            
-        if start_time is not None:
-            if isinstance(start_time, datetime):
-                _query_params.append(
-                    (
-                        'start_time',
-                        start_time.strftime(
-                            self.api_client.configuration.datetime_format
-                        )
-                    )
-                )
-            else:
-                _query_params.append(('start_time', start_time))
-            
-        if end_time is not None:
-            if isinstance(end_time, datetime):
-                _query_params.append(
-                    (
-                        'end_time',
-                        end_time.strftime(
-                            self.api_client.configuration.datetime_format
-                        )
-                    )
-                )
-            else:
-                _query_params.append(('end_time', end_time))
-            
-        if severity is not None:
-            
-            _query_params.append(('severity', severity))
-            
-        if status is not None:
-            
-            _query_params.append(('status', status))
-            
-        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))
-            
-        if latest_per_model_version_only is not None:
+        if has_detections is not None:
             
-            _query_params.append(('latest_per_model_version_only', latest_per_model_version_only))
+            _query_params.append(('has_detections', has_detections))
             
         # process the header parameters
         # process the form parameters
@@ -1346,7 +2359,8 @@ class ModelSupplyChainApi:
         # set the HTTP header `Accept`
         _header_params['Accept'] = self.api_client.select_header_accept(
             [
-                'application/json; charset=utf-8'
+                'application/json; charset=utf-8', 
+                'application/sarif+json'
             ]
         )
 
@@ -1358,7 +2372,7 @@ class ModelSupplyChainApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/scan/v3/results',
+            resource_path='/scan/v3/results/{scan_id}',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1375,9 +2389,11 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscan_api_v3_get_scan_results(
+    def get_scan_results1(
         self,
         scan_id: Optional[StrictStr] = None,
+        cursor: Optional[StrictStr] = None,
+        page_size: Optional[Annotated[int, Field(strict=True, ge=1)]] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1390,12 +2406,16 @@ class ModelSupplyChainApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> List[ScanResultsV2]:
+    ) -> List[ScanResultsMapV3]:
         """Retrieve Model Scan Results
 
 
         :param scan_id:
         :type scan_id: str
+        :param cursor:
+        :type cursor: str
+        :param page_size:
+        :type page_size: int
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1418,8 +2438,10 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscan_api_v3_get_scan_results_serialize(
+        _param = self._get_scan_results1_serialize(
             scan_id=scan_id,
+            cursor=cursor,
+            page_size=page_size,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1427,11 +2449,10 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "List[ScanResultsV2]",
-            '202': "List[ScanResultsV2]",
+            '200': "List[ScanResultsMapV3]",
             '400': None,
             '404': None,
-            '422': "ValidationErrorModel",
+            '405': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1445,9 +2466,11 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscan_api_v3_get_scan_results_with_http_info(
+    def get_scan_results1_with_http_info(
         self,
         scan_id: Optional[StrictStr] = None,
+        cursor: Optional[StrictStr] = None,
+        page_size: Optional[Annotated[int, Field(strict=True, ge=1)]] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1460,12 +2483,16 @@ class ModelSupplyChainApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[List[ScanResultsV2]]:
+    ) -> ApiResponse[List[ScanResultsMapV3]]:
         """Retrieve Model Scan Results
 
 
         :param scan_id:
         :type scan_id: str
+        :param cursor:
+        :type cursor: str
+        :param page_size:
+        :type page_size: int
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1488,8 +2515,10 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscan_api_v3_get_scan_results_serialize(
+        _param = self._get_scan_results1_serialize(
             scan_id=scan_id,
+            cursor=cursor,
+            page_size=page_size,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1497,11 +2526,10 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "List[ScanResultsV2]",
-            '202': "List[ScanResultsV2]",
+            '200': "List[ScanResultsMapV3]",
             '400': None,
             '404': None,
-            '422': "ValidationErrorModel",
+            '405': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1515,9 +2543,11 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscan_api_v3_get_scan_results_without_preload_content(
+    def get_scan_results1_without_preload_content(
         self,
         scan_id: Optional[StrictStr] = None,
+        cursor: Optional[StrictStr] = None,
+        page_size: Optional[Annotated[int, Field(strict=True, ge=1)]] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1536,6 +2566,10 @@ class ModelSupplyChainApi:
 
         :param scan_id:
         :type scan_id: str
+        :param cursor:
+        :type cursor: str
+        :param page_size:
+        :type page_size: int
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1558,8 +2592,10 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscan_api_v3_get_scan_results_serialize(
+        _param = self._get_scan_results1_serialize(
             scan_id=scan_id,
+            cursor=cursor,
+            page_size=page_size,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1567,11 +2603,10 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "List[ScanResultsV2]",
-            '202': "List[ScanResultsV2]",
+            '200': "List[ScanResultsMapV3]",
             '400': None,
             '404': None,
-            '422': "ValidationErrorModel",
+            '405': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1580,9 +2615,11 @@ class ModelSupplyChainApi:
         return response_data.response
 
 
-    def _modelscan_api_v3_get_scan_results_serialize(
+    def _get_scan_results1_serialize(
         self,
         scan_id,
+        cursor,
+        page_size,
         _request_auth,
         _content_type,
         _headers,
@@ -1605,6 +2642,14 @@ class ModelSupplyChainApi:
         if scan_id is not None:
             _path_params['scan_id'] = scan_id
         # process the query parameters
+        if cursor is not None:
+            
+            _query_params.append(('cursor', cursor))
+            
+        if page_size is not None:
+            
+            _query_params.append(('page_size', page_size))
+            
         # process the header parameters
         # process the form parameters
         # process the body parameter
@@ -1613,8 +2658,7 @@ class ModelSupplyChainApi:
         # set the HTTP header `Accept`
         _header_params['Accept'] = self.api_client.select_header_accept(
             [
-                'application/json; charset=utf-8', 
-                'application/json'
+                'application/json; charset=utf-8'
             ]
         )
 
@@ -1643,10 +2687,8 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscan_api_v3_post_scan_results(
+    def modelscanner_api_v3_health_check(
         self,
-        scan_id: StrictStr,
-        scan_create_request: Annotated[ScanCreateRequest, Field(description="Request body for reporting a scan of one or more file results")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1660,13 +2702,9 @@ class ModelSupplyChainApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> None:
-        """Engine Report Endpoint of Model Scan Results
+        """Health check endpoint for Model Supply Chain Services
 
 
-        :param scan_id: (required)
-        :type scan_id: str
-        :param scan_create_request: Request body for reporting a scan of one or more file results (required)
-        :type scan_create_request: ScanCreateRequest
         :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
@@ -1689,9 +2727,7 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscan_api_v3_post_scan_results_serialize(
-            scan_id=scan_id,
-            scan_create_request=scan_create_request,
+        _param = self._modelscanner_api_v3_health_check_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1699,9 +2735,8 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '204': None,
-            '400': None,
-            '422': "ValidationErrorModel",
+            '200': None,
+            '503': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1715,10 +2750,8 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscan_api_v3_post_scan_results_with_http_info(
+    def modelscanner_api_v3_health_check_with_http_info(
         self,
-        scan_id: StrictStr,
-        scan_create_request: Annotated[ScanCreateRequest, Field(description="Request body for reporting a scan of one or more file results")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1732,13 +2765,9 @@ class ModelSupplyChainApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[None]:
-        """Engine Report Endpoint of Model Scan Results
+        """Health check endpoint for Model Supply Chain Services
 
 
-        :param scan_id: (required)
-        :type scan_id: str
-        :param scan_create_request: Request body for reporting a scan of one or more file results (required)
-        :type scan_create_request: ScanCreateRequest
         :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
@@ -1761,9 +2790,7 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscan_api_v3_post_scan_results_serialize(
-            scan_id=scan_id,
-            scan_create_request=scan_create_request,
+        _param = self._modelscanner_api_v3_health_check_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1771,9 +2798,8 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '204': None,
-            '400': None,
-            '422': "ValidationErrorModel",
+            '200': None,
+            '503': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1787,10 +2813,8 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscan_api_v3_post_scan_results_without_preload_content(
+    def modelscanner_api_v3_health_check_without_preload_content(
         self,
-        scan_id: StrictStr,
-        scan_create_request: Annotated[ScanCreateRequest, Field(description="Request body for reporting a scan of one or more file results")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1804,13 +2828,9 @@ class ModelSupplyChainApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Engine Report Endpoint of Model Scan Results
+        """Health check endpoint for Model Supply Chain Services
 
 
-        :param scan_id: (required)
-        :type scan_id: str
-        :param scan_create_request: Request body for reporting a scan of one or more file results (required)
-        :type scan_create_request: ScanCreateRequest
         :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
@@ -1833,9 +2853,7 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscan_api_v3_post_scan_results_serialize(
-            scan_id=scan_id,
-            scan_create_request=scan_create_request,
+        _param = self._modelscanner_api_v3_health_check_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1843,9 +2861,8 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '204': None,
-            '400': None,
-            '422': "ValidationErrorModel",
+            '200': None,
+            '503': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1854,10 +2871,8 @@ class ModelSupplyChainApi:
         return response_data.response
 
 
-    def _modelscan_api_v3_post_scan_results_serialize(
+    def _modelscanner_api_v3_health_check_serialize(
         self,
-        scan_id,
-        scan_create_request,
         _request_auth,
         _content_type,
         _headers,
@@ -1877,37 +2892,13 @@ class ModelSupplyChainApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
-        if scan_id is not None:
-            _path_params['scan_id'] = scan_id
         # process the query parameters
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if scan_create_request is not None:
-            _body_params = scan_create_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', 
-                        'application/octet-stream'
-                    ]
-                )
-            )
-            if _default_content_type is not None:
-                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
@@ -1915,8 +2906,8 @@ class ModelSupplyChainApi:
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/scans/v3/reports/{scan_id}',
+            method='GET',
+            resource_path='/scans/v3/health',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1933,7 +2924,7 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscanner_api_v3_get_jobs(
+    def modelscanner_api_v3_readiness_check(
         self,
         _request_timeout: Union[
             None,
@@ -1947,8 +2938,8 @@ class ModelSupplyChainApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> List[ScanJob]:
-        """List all Model Scan Jobs
+    ) -> None:
+        """Readiness check endpoint for Model Supply Chain Services
 
 
         :param _request_timeout: timeout setting for this request. If one
@@ -1973,7 +2964,7 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscanner_api_v3_get_jobs_serialize(
+        _param = self._modelscanner_api_v3_readiness_check_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1981,9 +2972,8 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "List[ScanJob]",
-            '400': None,
-            '404': None,
+            '200': None,
+            '503': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1997,7 +2987,7 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscanner_api_v3_get_jobs_with_http_info(
+    def modelscanner_api_v3_readiness_check_with_http_info(
         self,
         _request_timeout: Union[
             None,
@@ -2011,8 +3001,8 @@ class ModelSupplyChainApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[List[ScanJob]]:
-        """List all Model Scan Jobs
+    ) -> ApiResponse[None]:
+        """Readiness check endpoint for Model Supply Chain Services
 
 
         :param _request_timeout: timeout setting for this request. If one
@@ -2037,7 +3027,7 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscanner_api_v3_get_jobs_serialize(
+        _param = self._modelscanner_api_v3_readiness_check_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2045,9 +3035,8 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "List[ScanJob]",
-            '400': None,
-            '404': None,
+            '200': None,
+            '503': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2061,7 +3050,7 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscanner_api_v3_get_jobs_without_preload_content(
+    def modelscanner_api_v3_readiness_check_without_preload_content(
         self,
         _request_timeout: Union[
             None,
@@ -2076,7 +3065,7 @@ class ModelSupplyChainApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """List all Model Scan Jobs
+        """Readiness check endpoint for Model Supply Chain Services
 
 
         :param _request_timeout: timeout setting for this request. If one
@@ -2101,7 +3090,7 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscanner_api_v3_get_jobs_serialize(
+        _param = self._modelscanner_api_v3_readiness_check_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2109,9 +3098,8 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "List[ScanJob]",
-            '400': None,
-            '404': None,
+            '200': None,
+            '503': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2120,7 +3108,7 @@ class ModelSupplyChainApi:
         return response_data.response
 
 
-    def _modelscanner_api_v3_get_jobs_serialize(
+    def _modelscanner_api_v3_readiness_check_serialize(
         self,
         _request_auth,
         _content_type,
@@ -2147,14 +3135,8 @@ class ModelSupplyChainApi:
         # process the body parameter
 
 
-        # set the HTTP header `Accept`
-        _header_params['Accept'] = self.api_client.select_header_accept(
-            [
-                'application/json; charset=utf-8'
-            ]
-        )
-
-
+
+
         # authentication setting
         _auth_settings: List[str] = [
             'BearerAuth'
@@ -2162,7 +3144,7 @@ class ModelSupplyChainApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/scans/v3/jobs',
+            resource_path='/scans/v3/readiness',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -2179,8 +3161,11 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscanner_api_v3_health_check(
+    def notify_model_scan_completed(
         self,
+        scan_id: StrictStr,
+        scan_report_v3: Annotated[ScanReportV3, Field(description="Request body for partial update")],
+        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2193,10 +3178,16 @@ class ModelSupplyChainApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> None:
-        """Health check endpoint for Model Supply Chain Services
+    ) -> NotifyModelScanCompleted200Response:
+        """Indicate part (file or files) of a model scan has completed
 
 
+        :param scan_id: (required)
+        :type scan_id: str
+        :param scan_report_v3: Request body for partial update (required)
+        :type scan_report_v3: ScanReportV3
+        :param has_detections: Filter file_results to only those that have detections (and parents)
+        :type has_detections: bool
         :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
@@ -2219,7 +3210,10 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscanner_api_v3_health_check_serialize(
+        _param = self._notify_model_scan_completed_serialize(
+            scan_id=scan_id,
+            scan_report_v3=scan_report_v3,
+            has_detections=has_detections,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2227,8 +3221,9 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
-            '503': None,
+            '200': "NotifyModelScanCompleted200Response",
+            '400': None,
+            '422': "ValidationErrorModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2242,8 +3237,11 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscanner_api_v3_health_check_with_http_info(
+    def notify_model_scan_completed_with_http_info(
         self,
+        scan_id: StrictStr,
+        scan_report_v3: Annotated[ScanReportV3, Field(description="Request body for partial update")],
+        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2256,10 +3254,16 @@ class ModelSupplyChainApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[None]:
-        """Health check endpoint for Model Supply Chain Services
+    ) -> ApiResponse[NotifyModelScanCompleted200Response]:
+        """Indicate part (file or files) of a model scan has completed
 
 
+        :param scan_id: (required)
+        :type scan_id: str
+        :param scan_report_v3: Request body for partial update (required)
+        :type scan_report_v3: ScanReportV3
+        :param has_detections: Filter file_results to only those that have detections (and parents)
+        :type has_detections: bool
         :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
@@ -2282,7 +3286,10 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscanner_api_v3_health_check_serialize(
+        _param = self._notify_model_scan_completed_serialize(
+            scan_id=scan_id,
+            scan_report_v3=scan_report_v3,
+            has_detections=has_detections,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2290,8 +3297,9 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
-            '503': None,
+            '200': "NotifyModelScanCompleted200Response",
+            '400': None,
+            '422': "ValidationErrorModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2305,8 +3313,11 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscanner_api_v3_health_check_without_preload_content(
+    def notify_model_scan_completed_without_preload_content(
         self,
+        scan_id: StrictStr,
+        scan_report_v3: Annotated[ScanReportV3, Field(description="Request body for partial update")],
+        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2320,9 +3331,15 @@ class ModelSupplyChainApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Health check endpoint for Model Supply Chain Services
+        """Indicate part (file or files) of a model scan has completed
 
 
+        :param scan_id: (required)
+        :type scan_id: str
+        :param scan_report_v3: Request body for partial update (required)
+        :type scan_report_v3: ScanReportV3
+        :param has_detections: Filter file_results to only those that have detections (and parents)
+        :type has_detections: bool
         :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
@@ -2345,7 +3362,10 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscanner_api_v3_health_check_serialize(
+        _param = self._notify_model_scan_completed_serialize(
+            scan_id=scan_id,
+            scan_report_v3=scan_report_v3,
+            has_detections=has_detections,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2353,8 +3373,9 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
-            '503': None,
+            '200': "NotifyModelScanCompleted200Response",
+            '400': None,
+            '422': "ValidationErrorModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2363,8 +3384,11 @@ class ModelSupplyChainApi:
         return response_data.response
 
 
-    def _modelscanner_api_v3_health_check_serialize(
+    def _notify_model_scan_completed_serialize(
         self,
+        scan_id,
+        scan_report_v3,
+        has_detections,
         _request_auth,
         _content_type,
         _headers,
@@ -2384,13 +3408,40 @@ class ModelSupplyChainApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if scan_id is not None:
+            _path_params['scan_id'] = scan_id
         # process the query parameters
+        if has_detections is not None:
+            
+            _query_params.append(('has_detections', has_detections))
+            
         # process the header parameters
         # process the form parameters
         # process the body parameter
+        if scan_report_v3 is not None:
+            _body_params = scan_report_v3
 
 
+        # 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] = [
@@ -2398,8 +3449,8 @@ class ModelSupplyChainApi:
         ]
 
         return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/scans/v3/health',
+            method='PATCH',
+            resource_path='/scan/v3/results/{scan_id}',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -2416,9 +3467,11 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscanner_api_v3_post_request(
+    def notify_model_scan_started(
         self,
-        scan_job: Annotated[ScanJob, Field(description="Request body for create scan request")],
+        scan_id: StrictStr,
+        scan_report_v3: Annotated[ScanReportV3, Field(description="Request body for create")],
+        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2432,11 +3485,15 @@ class ModelSupplyChainApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> None:
-        """Request a Model Scan Job
+        """Indicate model scan has started
 
 
-        :param scan_job: Request body for create scan request (required)
-        :type scan_job: ScanJob
+        :param scan_id: (required)
+        :type scan_id: str
+        :param scan_report_v3: Request body for create (required)
+        :type scan_report_v3: ScanReportV3
+        :param has_detections: Filter file_results to only those that have detections (and parents)
+        :type has_detections: bool
         :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
@@ -2459,8 +3516,10 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscanner_api_v3_post_request_serialize(
-            scan_job=scan_job,
+        _param = self._notify_model_scan_started_serialize(
+            scan_id=scan_id,
+            scan_report_v3=scan_report_v3,
+            has_detections=has_detections,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2484,9 +3543,11 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscanner_api_v3_post_request_with_http_info(
+    def notify_model_scan_started_with_http_info(
         self,
-        scan_job: Annotated[ScanJob, Field(description="Request body for create scan request")],
+        scan_id: StrictStr,
+        scan_report_v3: Annotated[ScanReportV3, Field(description="Request body for create")],
+        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2500,11 +3561,15 @@ class ModelSupplyChainApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[None]:
-        """Request a Model Scan Job
+        """Indicate model scan has started
 
 
-        :param scan_job: Request body for create scan request (required)
-        :type scan_job: ScanJob
+        :param scan_id: (required)
+        :type scan_id: str
+        :param scan_report_v3: Request body for create (required)
+        :type scan_report_v3: ScanReportV3
+        :param has_detections: Filter file_results to only those that have detections (and parents)
+        :type has_detections: bool
         :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
@@ -2527,8 +3592,10 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscanner_api_v3_post_request_serialize(
-            scan_job=scan_job,
+        _param = self._notify_model_scan_started_serialize(
+            scan_id=scan_id,
+            scan_report_v3=scan_report_v3,
+            has_detections=has_detections,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2552,9 +3619,11 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscanner_api_v3_post_request_without_preload_content(
+    def notify_model_scan_started_without_preload_content(
         self,
-        scan_job: Annotated[ScanJob, Field(description="Request body for create scan request")],
+        scan_id: StrictStr,
+        scan_report_v3: Annotated[ScanReportV3, Field(description="Request body for create")],
+        has_detections: Annotated[Optional[StrictBool], Field(description="Filter file_results to only those that have detections (and parents)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2568,11 +3637,15 @@ class ModelSupplyChainApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Request a Model Scan Job
+        """Indicate model scan has started
 
 
-        :param scan_job: Request body for create scan request (required)
-        :type scan_job: ScanJob
+        :param scan_id: (required)
+        :type scan_id: str
+        :param scan_report_v3: Request body for create (required)
+        :type scan_report_v3: ScanReportV3
+        :param has_detections: Filter file_results to only those that have detections (and parents)
+        :type has_detections: bool
         :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
@@ -2595,8 +3668,10 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscanner_api_v3_post_request_serialize(
-            scan_job=scan_job,
+        _param = self._notify_model_scan_started_serialize(
+            scan_id=scan_id,
+            scan_report_v3=scan_report_v3,
+            has_detections=has_detections,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2615,9 +3690,11 @@ class ModelSupplyChainApi:
         return response_data.response
 
 
-    def _modelscanner_api_v3_post_request_serialize(
+    def _notify_model_scan_started_serialize(
         self,
-        scan_job,
+        scan_id,
+        scan_report_v3,
+        has_detections,
         _request_auth,
         _content_type,
         _headers,
@@ -2637,12 +3714,18 @@ class ModelSupplyChainApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if scan_id is not None:
+            _path_params['scan_id'] = scan_id
         # process the query parameters
+        if has_detections is not None:
+            
+            _query_params.append(('has_detections', has_detections))
+            
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if scan_job is not None:
-            _body_params = scan_job
+        if scan_report_v3 is not None:
+            _body_params = scan_report_v3
 
 
         # set the HTTP header `Accept`
@@ -2659,8 +3742,7 @@ class ModelSupplyChainApi:
             _default_content_type = (
                 self.api_client.select_header_content_type(
                     [
-                        'application/json; charset=utf-8', 
-                        'application/octet-stream'
+                        'application/json'
                     ]
                 )
             )
@@ -2674,7 +3756,7 @@ class ModelSupplyChainApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/scans/v3/jobs',
+            resource_path='/scan/v3/results/{scan_id}',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -2691,8 +3773,10 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscanner_api_v3_readiness_check(
+    def report_scan_results(
         self,
+        scan_id: StrictStr,
+        scan_create_request: Annotated[ScanCreateRequest, Field(description="Request body for reporting a scan of one or more file results")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2706,9 +3790,13 @@ class ModelSupplyChainApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> None:
-        """Readiness check endpoint for Model Supply Chain Services
+        """Engine Report Endpoint of Model Scan Results
 
 
+        :param scan_id: (required)
+        :type scan_id: str
+        :param scan_create_request: Request body for reporting a scan of one or more file results (required)
+        :type scan_create_request: ScanCreateRequest
         :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
@@ -2731,7 +3819,9 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscanner_api_v3_readiness_check_serialize(
+        _param = self._report_scan_results_serialize(
+            scan_id=scan_id,
+            scan_create_request=scan_create_request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2739,8 +3829,9 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
-            '503': None,
+            '204': None,
+            '400': None,
+            '422': "ValidationErrorModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2754,8 +3845,10 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscanner_api_v3_readiness_check_with_http_info(
+    def report_scan_results_with_http_info(
         self,
+        scan_id: StrictStr,
+        scan_create_request: Annotated[ScanCreateRequest, Field(description="Request body for reporting a scan of one or more file results")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2769,9 +3862,13 @@ class ModelSupplyChainApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[None]:
-        """Readiness check endpoint for Model Supply Chain Services
+        """Engine Report Endpoint of Model Scan Results
 
 
+        :param scan_id: (required)
+        :type scan_id: str
+        :param scan_create_request: Request body for reporting a scan of one or more file results (required)
+        :type scan_create_request: ScanCreateRequest
         :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
@@ -2794,7 +3891,9 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscanner_api_v3_readiness_check_serialize(
+        _param = self._report_scan_results_serialize(
+            scan_id=scan_id,
+            scan_create_request=scan_create_request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2802,8 +3901,9 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
-            '503': None,
+            '204': None,
+            '400': None,
+            '422': "ValidationErrorModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2817,8 +3917,10 @@ class ModelSupplyChainApi:
 
 
     @validate_call
-    def modelscanner_api_v3_readiness_check_without_preload_content(
+    def report_scan_results_without_preload_content(
         self,
+        scan_id: StrictStr,
+        scan_create_request: Annotated[ScanCreateRequest, Field(description="Request body for reporting a scan of one or more file results")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2832,9 +3934,13 @@ class ModelSupplyChainApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Readiness check endpoint for Model Supply Chain Services
+        """Engine Report Endpoint of Model Scan Results
 
 
+        :param scan_id: (required)
+        :type scan_id: str
+        :param scan_create_request: Request body for reporting a scan of one or more file results (required)
+        :type scan_create_request: ScanCreateRequest
         :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
@@ -2857,7 +3963,9 @@ class ModelSupplyChainApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._modelscanner_api_v3_readiness_check_serialize(
+        _param = self._report_scan_results_serialize(
+            scan_id=scan_id,
+            scan_create_request=scan_create_request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2865,8 +3973,9 @@ class ModelSupplyChainApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
-            '503': None,
+            '204': None,
+            '400': None,
+            '422': "ValidationErrorModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2875,8 +3984,10 @@ class ModelSupplyChainApi:
         return response_data.response
 
 
-    def _modelscanner_api_v3_readiness_check_serialize(
+    def _report_scan_results_serialize(
         self,
+        scan_id,
+        scan_create_request,
         _request_auth,
         _content_type,
         _headers,
@@ -2896,13 +4007,37 @@ class ModelSupplyChainApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if scan_id is not None:
+            _path_params['scan_id'] = scan_id
         # process the query parameters
         # process the header parameters
         # process the form parameters
         # process the body parameter
+        if scan_create_request is not None:
+            _body_params = scan_create_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', 
+                        'application/octet-stream'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
@@ -2910,8 +4045,8 @@ class ModelSupplyChainApi:
         ]
 
         return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/scans/v3/readiness',
+            method='POST',
+            resource_path='/scans/v3/reports/{scan_id}',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,