rapidata 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

rapidata/api_client/api/order_api.py

@@ -23,8 +23,6 @@ from rapidata.api_client.models.clone_order_model import CloneOrderModel
 from rapidata.api_client.models.clone_order_result import CloneOrderResult
 from rapidata.api_client.models.create_complex_order_model import CreateComplexOrderModel
 from rapidata.api_client.models.create_complex_order_result import CreateComplexOrderResult
-from rapidata.api_client.models.create_default_order_model import CreateDefaultOrderModel
-from rapidata.api_client.models.create_legacy_order_result import CreateLegacyOrderResult
 from rapidata.api_client.models.create_order_model import CreateOrderModel
 from rapidata.api_client.models.create_order_result import CreateOrderResult
 from rapidata.api_client.models.create_unsupported_order_model import CreateUnsupportedOrderModel
@@ -32,13 +30,11 @@ from rapidata.api_client.models.feedback_model import FeedbackModel
 from rapidata.api_client.models.get_order_by_id_result import GetOrderByIdResult
 from rapidata.api_client.models.get_order_results_result import GetOrderResultsResult
 from rapidata.api_client.models.get_public_orders_result import GetPublicOrdersResult
-from rapidata.api_client.models.get_workflow_config_result import GetWorkflowConfigResult
 from rapidata.api_client.models.order_query_get200_response import OrderQueryGet200Response
 from rapidata.api_client.models.query_orders_model import QueryOrdersModel
 from rapidata.api_client.models.unlock_order_result import UnlockOrderResult
 from rapidata.api_client.models.update_access_model import UpdateAccessModel
 from rapidata.api_client.models.update_order_model import UpdateOrderModel
-from rapidata.api_client.models.update_workflow_config_model import UpdateWorkflowConfigModel
 
 from rapidata.api_client.api_client import ApiClient, RequestSerialized
 from rapidata.api_client.api_response import ApiResponse
@@ -867,284 +863,6 @@ class OrderApi:
 
 
 
-    @validate_call
-    def order_create_default_order_post(
-        self,
-        create_default_order_model: Annotated[Optional[CreateDefaultOrderModel], Field(description="The body content of the request")] = 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,
-    ) -> CreateLegacyOrderResult:
-        """(Deprecated) Creates a new order with a default pipeline.
-
-
-        :param create_default_order_model: The body content of the request
-        :type create_default_order_model: CreateDefaultOrderModel
-        :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
-        warnings.warn("POST /Order/CreateDefaultOrder is deprecated.", DeprecationWarning)
-
-        _param = self._order_create_default_order_post_serialize(
-            create_default_order_model=create_default_order_model,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateLegacyOrderResult",
-        }
-        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 order_create_default_order_post_with_http_info(
-        self,
-        create_default_order_model: Annotated[Optional[CreateDefaultOrderModel], Field(description="The body content of the request")] = 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[CreateLegacyOrderResult]:
-        """(Deprecated) Creates a new order with a default pipeline.
-
-
-        :param create_default_order_model: The body content of the request
-        :type create_default_order_model: CreateDefaultOrderModel
-        :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
-        warnings.warn("POST /Order/CreateDefaultOrder is deprecated.", DeprecationWarning)
-
-        _param = self._order_create_default_order_post_serialize(
-            create_default_order_model=create_default_order_model,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateLegacyOrderResult",
-        }
-        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 order_create_default_order_post_without_preload_content(
-        self,
-        create_default_order_model: Annotated[Optional[CreateDefaultOrderModel], Field(description="The body content of the request")] = 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:
-        """(Deprecated) Creates a new order with a default pipeline.
-
-
-        :param create_default_order_model: The body content of the request
-        :type create_default_order_model: CreateDefaultOrderModel
-        :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
-        warnings.warn("POST /Order/CreateDefaultOrder is deprecated.", DeprecationWarning)
-
-        _param = self._order_create_default_order_post_serialize(
-            create_default_order_model=create_default_order_model,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateLegacyOrderResult",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _order_create_default_order_post_serialize(
-        self,
-        create_default_order_model,
-        _request_auth,
-        _content_type,
-        _headers,
-        _host_index,
-    ) -> RequestSerialized:
-
-        _host = None
-
-        _collection_formats: Dict[str, str] = {
-        }
-
-        _path_params: Dict[str, str] = {}
-        _query_params: List[Tuple[str, str]] = []
-        _header_params: Dict[str, Optional[str]] = _headers or {}
-        _form_params: List[Tuple[str, str]] = []
-        _files: Dict[
-            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
-        ] = {}
-        _body_params: Optional[bytes] = None
-
-        # process the path parameters
-        # process the query parameters
-        # process the header parameters
-        # process the form parameters
-        # process the body parameter
-        if create_default_order_model is not None:
-            _body_params = create_default_order_model
-
-
-        # set the HTTP header `Accept`
-        if 'Accept' not in _header_params:
-            _header_params['Accept'] = self.api_client.select_header_accept(
-                [
-                    'text/plain', 
-                    'application/json', 
-                    'text/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', 
-                        'text/json', 
-                        'application/*+json'
-                    ]
-                )
-            )
-            if _default_content_type is not None:
-                _header_params['Content-Type'] = _default_content_type
-
-        # authentication setting
-        _auth_settings: List[str] = [
-            'bearer'
-        ]
-
-        return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/Order/CreateDefaultOrder',
-            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 order_create_post(
         self,
@@ -2975,10 +2693,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_get_workflow_config_get(
+    def order_pause_post(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order")] = None,
-        artifact_identifier: Annotated[Optional[StrictStr], Field(description="The identifier of the workflow config artifact in the pipeline. If using the default pipeline this is not needed.")] = None,
+        order_id: Optional[StrictStr] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2991,15 +2708,12 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> GetWorkflowConfigResult:
-        """Retrieves the workflow configuration for an order.
+    ) -> None:
+        """Pauses an order that is processing. Meaning all campaigns in the order will be paused.
 
-        A workflow configuration defines how rapids are created, processed, and aggregated.
 
-        :param order_id: The id of the order
+        :param order_id: 
         :type order_id: str
-        :param artifact_identifier: The identifier of the workflow config artifact in the pipeline. If using the default pipeline this is not needed.
-        :type artifact_identifier: 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
@@ -3022,9 +2736,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_get_workflow_config_get_serialize(
+        _param = self._order_pause_post_serialize(
             order_id=order_id,
-            artifact_identifier=artifact_identifier,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3032,7 +2745,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetWorkflowConfigResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3046,10 +2759,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_get_workflow_config_get_with_http_info(
+    def order_pause_post_with_http_info(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order")] = None,
-        artifact_identifier: Annotated[Optional[StrictStr], Field(description="The identifier of the workflow config artifact in the pipeline. If using the default pipeline this is not needed.")] = None,
+        order_id: Optional[StrictStr] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3062,15 +2774,12 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[GetWorkflowConfigResult]:
-        """Retrieves the workflow configuration for an order.
+    ) -> ApiResponse[None]:
+        """Pauses an order that is processing. Meaning all campaigns in the order will be paused.
 
-        A workflow configuration defines how rapids are created, processed, and aggregated.
 
-        :param order_id: The id of the order
+        :param order_id: 
         :type order_id: str
-        :param artifact_identifier: The identifier of the workflow config artifact in the pipeline. If using the default pipeline this is not needed.
-        :type artifact_identifier: 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
@@ -3093,9 +2802,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_get_workflow_config_get_serialize(
+        _param = self._order_pause_post_serialize(
             order_id=order_id,
-            artifact_identifier=artifact_identifier,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3103,7 +2811,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetWorkflowConfigResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3117,10 +2825,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_get_workflow_config_get_without_preload_content(
+    def order_pause_post_without_preload_content(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order")] = None,
-        artifact_identifier: Annotated[Optional[StrictStr], Field(description="The identifier of the workflow config artifact in the pipeline. If using the default pipeline this is not needed.")] = None,
+        order_id: Optional[StrictStr] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3134,14 +2841,11 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Retrieves the workflow configuration for an order.
+        """Pauses an order that is processing. Meaning all campaigns in the order will be paused.
 
-        A workflow configuration defines how rapids are created, processed, and aggregated.
 
-        :param order_id: The id of the order
+        :param order_id: 
         :type order_id: str
-        :param artifact_identifier: The identifier of the workflow config artifact in the pipeline. If using the default pipeline this is not needed.
-        :type artifact_identifier: 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
@@ -3164,9 +2868,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_get_workflow_config_get_serialize(
+        _param = self._order_pause_post_serialize(
             order_id=order_id,
-            artifact_identifier=artifact_identifier,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3174,7 +2877,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetWorkflowConfigResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3183,10 +2886,9 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_get_workflow_config_get_serialize(
+    def _order_pause_post_serialize(
         self,
         order_id,
-        artifact_identifier,
         _request_auth,
         _content_type,
         _headers,
@@ -3211,26 +2913,13 @@ class OrderApi:
         # process the query parameters
         if order_id is not None:
             
-            _query_params.append(('OrderId', order_id))
-            
-        if artifact_identifier is not None:
-            
-            _query_params.append(('ArtifactIdentifier', artifact_identifier))
+            _query_params.append(('orderId', order_id))
             
         # process the header parameters
         # process the form parameters
         # process the body parameter
 
 
-        # set the HTTP header `Accept`
-        if 'Accept' not in _header_params:
-            _header_params['Accept'] = self.api_client.select_header_accept(
-                [
-                    'text/plain', 
-                    'application/json', 
-                    'text/json'
-                ]
-            )
 
 
         # authentication setting
@@ -3239,8 +2928,8 @@ class OrderApi:
         ]
 
         return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/Order/GetWorkflowConfig',
+            method='POST',
+            resource_path='/Order/Pause',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -3779,9 +3468,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_retry_failed_post(
+    def order_resume_post(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to retry")] = None,
+        order_id: Optional[StrictStr] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3795,10 +3484,10 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> None:
-        """Retries a failed order.
+        """Resumes a paused order. Meaning all campaigns in the order will be resumed.
 
 
-        :param order_id: The id of the order to retry
+        :param order_id: 
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -3822,7 +3511,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_retry_failed_post_serialize(
+        _param = self._order_resume_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -3845,9 +3534,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_retry_failed_post_with_http_info(
+    def order_resume_post_with_http_info(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to retry")] = None,
+        order_id: Optional[StrictStr] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3861,10 +3550,10 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[None]:
-        """Retries a failed order.
+        """Resumes a paused order. Meaning all campaigns in the order will be resumed.
 
 
-        :param order_id: The id of the order to retry
+        :param order_id: 
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -3888,7 +3577,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_retry_failed_post_serialize(
+        _param = self._order_resume_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -3911,9 +3600,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_retry_failed_post_without_preload_content(
+    def order_resume_post_without_preload_content(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to retry")] = None,
+        order_id: Optional[StrictStr] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3927,10 +3616,10 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Retries a failed order.
+        """Resumes a paused order. Meaning all campaigns in the order will be resumed.
 
 
-        :param order_id: The id of the order to retry
+        :param order_id: 
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -3954,7 +3643,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_retry_failed_post_serialize(
+        _param = self._order_resume_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -3972,7 +3661,7 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_retry_failed_post_serialize(
+    def _order_resume_post_serialize(
         self,
         order_id,
         _request_auth,
@@ -4015,7 +3704,7 @@ class OrderApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Order/RetryFailed',
+            resource_path='/Order/Resume',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -4032,9 +3721,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_share_put(
+    def order_retry_failed_post(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
+        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to retry")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4048,10 +3737,10 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> None:
-        """Updates whether an order is public or not.
+        """Retries a failed order.
 
 
-        :param order_id: The id of the order to update
+        :param order_id: The id of the order to retry
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -4075,7 +3764,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_share_put_serialize(
+        _param = self._order_retry_failed_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -4098,9 +3787,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_share_put_with_http_info(
+    def order_retry_failed_post_with_http_info(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
+        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to retry")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4114,10 +3803,10 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[None]:
-        """Updates whether an order is public or not.
+        """Retries a failed order.
 
 
-        :param order_id: The id of the order to update
+        :param order_id: The id of the order to retry
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -4141,7 +3830,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_share_put_serialize(
+        _param = self._order_retry_failed_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -4164,9 +3853,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_share_put_without_preload_content(
+    def order_retry_failed_post_without_preload_content(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
+        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to retry")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4180,10 +3869,10 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Updates whether an order is public or not.
+        """Retries a failed order.
 
 
-        :param order_id: The id of the order to update
+        :param order_id: The id of the order to retry
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -4207,7 +3896,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_share_put_serialize(
+        _param = self._order_retry_failed_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -4225,7 +3914,7 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_share_put_serialize(
+    def _order_retry_failed_post_serialize(
         self,
         order_id,
         _request_auth,
@@ -4267,8 +3956,8 @@ class OrderApi:
         ]
 
         return self.api_client.param_serialize(
-            method='PUT',
-            resource_path='/Order/Share',
+            method='POST',
+            resource_path='/Order/RetryFailed',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -4285,9 +3974,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_submit_post(
+    def order_share_put(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to submit")] = None,
+        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4301,11 +3990,10 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> None:
-        """Submits an order for approval.
+        """Updates whether an order is public or not.
 
-        Once an order is created its order id and dataset id is returned.  The dataset id can be used to fill the dataset with data points.  Once submitted, the order will be locked and no further changes can be made.
 
-        :param order_id: The id of the order to submit
+        :param order_id: The id of the order to update
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -4329,7 +4017,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_submit_post_serialize(
+        _param = self._order_share_put_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -4352,9 +4040,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_submit_post_with_http_info(
+    def order_share_put_with_http_info(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to submit")] = None,
+        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4368,11 +4056,10 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[None]:
-        """Submits an order for approval.
+        """Updates whether an order is public or not.
 
-        Once an order is created its order id and dataset id is returned.  The dataset id can be used to fill the dataset with data points.  Once submitted, the order will be locked and no further changes can be made.
 
-        :param order_id: The id of the order to submit
+        :param order_id: The id of the order to update
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -4396,7 +4083,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_submit_post_serialize(
+        _param = self._order_share_put_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -4419,9 +4106,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_submit_post_without_preload_content(
+    def order_share_put_without_preload_content(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to submit")] = None,
+        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4435,11 +4122,10 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Submits an order for approval.
+        """Updates whether an order is public or not.
 
-        Once an order is created its order id and dataset id is returned.  The dataset id can be used to fill the dataset with data points.  Once submitted, the order will be locked and no further changes can be made.
 
-        :param order_id: The id of the order to submit
+        :param order_id: The id of the order to update
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -4463,7 +4149,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_submit_post_serialize(
+        _param = self._order_share_put_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -4481,7 +4167,7 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_submit_post_serialize(
+    def _order_share_put_serialize(
         self,
         order_id,
         _request_auth,
@@ -4523,8 +4209,8 @@ class OrderApi:
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/Order/Submit',
+            method='PUT',
+            resource_path='/Order/Share',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -4541,9 +4227,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_unlock_post(
+    def order_submit_post(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to unlock")] = None,
+        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to submit")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4556,12 +4242,12 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> UnlockOrderResult:
-        """Unlocks a newly cloned order.
+    ) -> None:
+        """Submits an order for approval.
 
-        When an order is cloned only the necessary information is copied.  In order to make changes to the order, it must be unlocked first.  Unlocking the order will clone the entire dataset and its datapoints.
+        Once an order is created its order id and dataset id is returned.  The dataset id can be used to fill the dataset with data points.  Once submitted, the order will be locked and no further changes can be made.
 
-        :param order_id: The id of the order to unlock
+        :param order_id: The id of the order to submit
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -4585,7 +4271,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_unlock_post_serialize(
+        _param = self._order_submit_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -4594,7 +4280,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UnlockOrderResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4608,9 +4294,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_unlock_post_with_http_info(
+    def order_submit_post_with_http_info(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to unlock")] = None,
+        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to submit")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4623,12 +4309,12 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[UnlockOrderResult]:
-        """Unlocks a newly cloned order.
+    ) -> ApiResponse[None]:
+        """Submits an order for approval.
 
-        When an order is cloned only the necessary information is copied.  In order to make changes to the order, it must be unlocked first.  Unlocking the order will clone the entire dataset and its datapoints.
+        Once an order is created its order id and dataset id is returned.  The dataset id can be used to fill the dataset with data points.  Once submitted, the order will be locked and no further changes can be made.
 
-        :param order_id: The id of the order to unlock
+        :param order_id: The id of the order to submit
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -4652,7 +4338,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_unlock_post_serialize(
+        _param = self._order_submit_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -4661,7 +4347,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UnlockOrderResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4675,9 +4361,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_unlock_post_without_preload_content(
+    def order_submit_post_without_preload_content(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to unlock")] = None,
+        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to submit")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4691,11 +4377,11 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Unlocks a newly cloned order.
+        """Submits an order for approval.
 
-        When an order is cloned only the necessary information is copied.  In order to make changes to the order, it must be unlocked first.  Unlocking the order will clone the entire dataset and its datapoints.
+        Once an order is created its order id and dataset id is returned.  The dataset id can be used to fill the dataset with data points.  Once submitted, the order will be locked and no further changes can be made.
 
-        :param order_id: The id of the order to unlock
+        :param order_id: The id of the order to submit
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -4719,7 +4405,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_unlock_post_serialize(
+        _param = self._order_submit_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -4728,7 +4414,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UnlockOrderResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4737,7 +4423,7 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_unlock_post_serialize(
+    def _order_submit_post_serialize(
         self,
         order_id,
         _request_auth,
@@ -4771,15 +4457,6 @@ class OrderApi:
         # process the body parameter
 
 
-        # set the HTTP header `Accept`
-        if 'Accept' not in _header_params:
-            _header_params['Accept'] = self.api_client.select_header_accept(
-                [
-                    'text/plain', 
-                    'application/json', 
-                    'text/json'
-                ]
-            )
 
 
         # authentication setting
@@ -4789,7 +4466,7 @@ class OrderApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Order/Unlock',
+            resource_path='/Order/Submit',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -4806,10 +4483,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_update_access_put(
+    def order_unlock_post(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
-        update_access_model: Annotated[Optional[UpdateAccessModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to unlock")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4822,14 +4498,13 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> None:
-        """Updates whether an order is public or not.
+    ) -> UnlockOrderResult:
+        """Unlocks a newly cloned order.
 
+        When an order is cloned only the necessary information is copied.  In order to make changes to the order, it must be unlocked first.  Unlocking the order will clone the entire dataset and its datapoints.
 
-        :param order_id: The id of the order to update
+        :param order_id: The id of the order to unlock
         :type order_id: str
-        :param update_access_model: The body content of the request
-        :type update_access_model: UpdateAccessModel
         :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
@@ -4852,9 +4527,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_update_access_put_serialize(
+        _param = self._order_unlock_post_serialize(
             order_id=order_id,
-            update_access_model=update_access_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4862,7 +4536,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "UnlockOrderResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4876,10 +4550,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_update_access_put_with_http_info(
+    def order_unlock_post_with_http_info(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
-        update_access_model: Annotated[Optional[UpdateAccessModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to unlock")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4892,14 +4565,13 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[None]:
-        """Updates whether an order is public or not.
+    ) -> ApiResponse[UnlockOrderResult]:
+        """Unlocks a newly cloned order.
 
+        When an order is cloned only the necessary information is copied.  In order to make changes to the order, it must be unlocked first.  Unlocking the order will clone the entire dataset and its datapoints.
 
-        :param order_id: The id of the order to update
+        :param order_id: The id of the order to unlock
         :type order_id: str
-        :param update_access_model: The body content of the request
-        :type update_access_model: UpdateAccessModel
         :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
@@ -4922,9 +4594,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_update_access_put_serialize(
+        _param = self._order_unlock_post_serialize(
             order_id=order_id,
-            update_access_model=update_access_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4932,7 +4603,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "UnlockOrderResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4946,10 +4617,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_update_access_put_without_preload_content(
+    def order_unlock_post_without_preload_content(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
-        update_access_model: Annotated[Optional[UpdateAccessModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to unlock")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4963,13 +4633,12 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Updates whether an order is public or not.
+        """Unlocks a newly cloned order.
 
+        When an order is cloned only the necessary information is copied.  In order to make changes to the order, it must be unlocked first.  Unlocking the order will clone the entire dataset and its datapoints.
 
-        :param order_id: The id of the order to update
+        :param order_id: The id of the order to unlock
         :type order_id: str
-        :param update_access_model: The body content of the request
-        :type update_access_model: UpdateAccessModel
         :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
@@ -4992,9 +4661,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_update_access_put_serialize(
+        _param = self._order_unlock_post_serialize(
             order_id=order_id,
-            update_access_model=update_access_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -5002,7 +4670,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "UnlockOrderResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -5011,10 +4679,9 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_update_access_put_serialize(
+    def _order_unlock_post_serialize(
         self,
         order_id,
-        update_access_model,
         _request_auth,
         _content_type,
         _headers,
@@ -5044,26 +4711,18 @@ class OrderApi:
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if update_access_model is not None:
-            _body_params = update_access_model
-
 
 
-        # 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', 
-                        'text/json', 
-                        'application/*+json'
-                    ]
-                )
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'text/plain', 
+                    'application/json', 
+                    'text/json'
+                ]
             )
-            if _default_content_type is not None:
-                _header_params['Content-Type'] = _default_content_type
+
 
         # authentication setting
         _auth_settings: List[str] = [
@@ -5071,8 +4730,8 @@ class OrderApi:
         ]
 
         return self.api_client.param_serialize(
-            method='PUT',
-            resource_path='/Order/UpdateAccess',
+            method='POST',
+            resource_path='/Order/Unlock',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -5089,10 +4748,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_update_order_name_put(
+    def order_update_access_put(
         self,
         order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
-        update_order_model: Annotated[Optional[UpdateOrderModel], Field(description="The body content of the request")] = None,
+        update_access_model: Annotated[Optional[UpdateAccessModel], Field(description="The body content of the request")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5106,13 +4765,13 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> None:
-        """Updates the name of an order.
+        """Updates whether an order is public or not.
 
 
         :param order_id: The id of the order to update
         :type order_id: str
-        :param update_order_model: The body content of the request
-        :type update_order_model: UpdateOrderModel
+        :param update_access_model: The body content of the request
+        :type update_access_model: UpdateAccessModel
         :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
@@ -5135,9 +4794,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_update_order_name_put_serialize(
+        _param = self._order_update_access_put_serialize(
             order_id=order_id,
-            update_order_model=update_order_model,
+            update_access_model=update_access_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -5159,10 +4818,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_update_order_name_put_with_http_info(
+    def order_update_access_put_with_http_info(
         self,
         order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
-        update_order_model: Annotated[Optional[UpdateOrderModel], Field(description="The body content of the request")] = None,
+        update_access_model: Annotated[Optional[UpdateAccessModel], Field(description="The body content of the request")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5176,13 +4835,13 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[None]:
-        """Updates the name of an order.
+        """Updates whether an order is public or not.
 
 
         :param order_id: The id of the order to update
         :type order_id: str
-        :param update_order_model: The body content of the request
-        :type update_order_model: UpdateOrderModel
+        :param update_access_model: The body content of the request
+        :type update_access_model: UpdateAccessModel
         :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
@@ -5205,9 +4864,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_update_order_name_put_serialize(
+        _param = self._order_update_access_put_serialize(
             order_id=order_id,
-            update_order_model=update_order_model,
+            update_access_model=update_access_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -5229,10 +4888,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_update_order_name_put_without_preload_content(
+    def order_update_access_put_without_preload_content(
         self,
         order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
-        update_order_model: Annotated[Optional[UpdateOrderModel], Field(description="The body content of the request")] = None,
+        update_access_model: Annotated[Optional[UpdateAccessModel], Field(description="The body content of the request")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5246,13 +4905,13 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Updates the name of an order.
+        """Updates whether an order is public or not.
 
 
         :param order_id: The id of the order to update
         :type order_id: str
-        :param update_order_model: The body content of the request
-        :type update_order_model: UpdateOrderModel
+        :param update_access_model: The body content of the request
+        :type update_access_model: UpdateAccessModel
         :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
@@ -5275,9 +4934,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_update_order_name_put_serialize(
+        _param = self._order_update_access_put_serialize(
             order_id=order_id,
-            update_order_model=update_order_model,
+            update_access_model=update_access_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -5294,10 +4953,10 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_update_order_name_put_serialize(
+    def _order_update_access_put_serialize(
         self,
         order_id,
-        update_order_model,
+        update_access_model,
         _request_auth,
         _content_type,
         _headers,
@@ -5327,8 +4986,8 @@ class OrderApi:
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if update_order_model is not None:
-            _body_params = update_order_model
+        if update_access_model is not None:
+            _body_params = update_access_model
 
 
 
@@ -5355,7 +5014,7 @@ class OrderApi:
 
         return self.api_client.param_serialize(
             method='PUT',
-            resource_path='/Order/UpdateOrderName',
+            resource_path='/Order/UpdateAccess',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -5372,9 +5031,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_update_workflow_config_put(
+    def order_update_order_name_put(
         self,
-        update_workflow_config_model: Annotated[Optional[UpdateWorkflowConfigModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
+        update_order_model: Annotated[Optional[UpdateOrderModel], Field(description="The body content of the request")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5388,12 +5048,13 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> None:
-        """(Deprecated) Updates the workflow configuration of an order.
+        """Updates the name of an order.
 
-        A workflow configuration defines how rapids are created, processed, and aggregated.
 
-        :param update_workflow_config_model: The body content of the request
-        :type update_workflow_config_model: UpdateWorkflowConfigModel
+        :param order_id: The id of the order to update
+        :type order_id: str
+        :param update_order_model: The body content of the request
+        :type update_order_model: UpdateOrderModel
         :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
@@ -5415,10 +5076,10 @@ class OrderApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("PUT /Order/UpdateWorkflowConfig is deprecated.", DeprecationWarning)
 
-        _param = self._order_update_workflow_config_put_serialize(
-            update_workflow_config_model=update_workflow_config_model,
+        _param = self._order_update_order_name_put_serialize(
+            order_id=order_id,
+            update_order_model=update_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -5440,9 +5101,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_update_workflow_config_put_with_http_info(
+    def order_update_order_name_put_with_http_info(
         self,
-        update_workflow_config_model: Annotated[Optional[UpdateWorkflowConfigModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
+        update_order_model: Annotated[Optional[UpdateOrderModel], Field(description="The body content of the request")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5456,12 +5118,13 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[None]:
-        """(Deprecated) Updates the workflow configuration of an order.
+        """Updates the name of an order.
 
-        A workflow configuration defines how rapids are created, processed, and aggregated.
 
-        :param update_workflow_config_model: The body content of the request
-        :type update_workflow_config_model: UpdateWorkflowConfigModel
+        :param order_id: The id of the order to update
+        :type order_id: str
+        :param update_order_model: The body content of the request
+        :type update_order_model: UpdateOrderModel
         :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
@@ -5483,10 +5146,10 @@ class OrderApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("PUT /Order/UpdateWorkflowConfig is deprecated.", DeprecationWarning)
 
-        _param = self._order_update_workflow_config_put_serialize(
-            update_workflow_config_model=update_workflow_config_model,
+        _param = self._order_update_order_name_put_serialize(
+            order_id=order_id,
+            update_order_model=update_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -5508,9 +5171,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_update_workflow_config_put_without_preload_content(
+    def order_update_order_name_put_without_preload_content(
         self,
-        update_workflow_config_model: Annotated[Optional[UpdateWorkflowConfigModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
+        update_order_model: Annotated[Optional[UpdateOrderModel], Field(description="The body content of the request")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5524,12 +5188,13 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """(Deprecated) Updates the workflow configuration of an order.
+        """Updates the name of an order.
 
-        A workflow configuration defines how rapids are created, processed, and aggregated.
 
-        :param update_workflow_config_model: The body content of the request
-        :type update_workflow_config_model: UpdateWorkflowConfigModel
+        :param order_id: The id of the order to update
+        :type order_id: str
+        :param update_order_model: The body content of the request
+        :type update_order_model: UpdateOrderModel
         :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
@@ -5551,10 +5216,10 @@ class OrderApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("PUT /Order/UpdateWorkflowConfig is deprecated.", DeprecationWarning)
 
-        _param = self._order_update_workflow_config_put_serialize(
-            update_workflow_config_model=update_workflow_config_model,
+        _param = self._order_update_order_name_put_serialize(
+            order_id=order_id,
+            update_order_model=update_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -5571,9 +5236,10 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_update_workflow_config_put_serialize(
+    def _order_update_order_name_put_serialize(
         self,
-        update_workflow_config_model,
+        order_id,
+        update_order_model,
         _request_auth,
         _content_type,
         _headers,
@@ -5596,11 +5262,15 @@ class OrderApi:
 
         # process the path parameters
         # process the query parameters
+        if order_id is not None:
+            
+            _query_params.append(('orderId', order_id))
+            
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if update_workflow_config_model is not None:
-            _body_params = update_workflow_config_model
+        if update_order_model is not None:
+            _body_params = update_order_model
 
 
 
@@ -5627,7 +5297,7 @@ class OrderApi:
 
         return self.api_client.param_serialize(
             method='PUT',
-            resource_path='/Order/UpdateWorkflowConfig',
+            resource_path='/Order/UpdateOrderName',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,