rapidata 1.8.3__py3-none-any.whl → 2.44.4__py3-none-any.whl

rapidata/api_client/api/order_api.py

@@ -1,9 +1,9 @@
 # coding: utf-8
 
 """
-    Rapidata.Dataset
+    Rapidata Asset API
 
-    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+    The API for the Rapidata Asset service
 
     The version of the OpenAPI document: v1
     Generated by OpenAPI Generator (https://openapi-generator.tech)
@@ -16,8 +16,8 @@ from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
 from typing import Any, Dict, List, Optional, Tuple, Union
 from typing_extensions import Annotated
 
-from pydantic import Field, StrictStr
-from typing import Optional
+from pydantic import Field, StrictBool, StrictBytes, StrictStr
+from typing import Optional, Tuple, Union
 from typing_extensions import Annotated
 from rapidata.api_client.models.clone_order_model import CloneOrderModel
 from rapidata.api_client.models.clone_order_result import CloneOrderResult
@@ -26,15 +26,15 @@ from rapidata.api_client.models.create_complex_order_result import CreateComplex
 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
-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.order_model_paged_result import OrderModelPagedResult
+from rapidata.api_client.models.paged_result_of_aggregated_orders_model import PagedResultOfAggregatedOrdersModel
+from rapidata.api_client.models.paged_result_of_order_model import PagedResultOfOrderModel
+from rapidata.api_client.models.preview_order_model import PreviewOrderModel
 from rapidata.api_client.models.query_model import QueryModel
+from rapidata.api_client.models.submit_order_model import SubmitOrderModel
 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_order_name_model import UpdateOrderNameModel
 
 from rapidata.api_client.api_client import ApiClient, RequestSerialized
 from rapidata.api_client.api_response import ApiResponse
@@ -55,9 +55,286 @@ class OrderApi:
 
 
     @validate_call
-    def order_approve_post(
+    def order_complex_post(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to approve")] = None,
+        create_complex_order_model: Annotated[CreateComplexOrderModel, Field(description="The body content of the 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,
+    ) -> CreateComplexOrderResult:
+        """Creates a new order with a custom pipeline.
+
+
+        :param create_complex_order_model: The body content of the request (required)
+        :type create_complex_order_model: CreateComplexOrderModel
+        :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._order_complex_post_serialize(
+            create_complex_order_model=create_complex_order_model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CreateComplexOrderResult",
+        }
+        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_complex_post_with_http_info(
+        self,
+        create_complex_order_model: Annotated[CreateComplexOrderModel, Field(description="The body content of the 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[CreateComplexOrderResult]:
+        """Creates a new order with a custom pipeline.
+
+
+        :param create_complex_order_model: The body content of the request (required)
+        :type create_complex_order_model: CreateComplexOrderModel
+        :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._order_complex_post_serialize(
+            create_complex_order_model=create_complex_order_model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CreateComplexOrderResult",
+        }
+        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_complex_post_without_preload_content(
+        self,
+        create_complex_order_model: Annotated[CreateComplexOrderModel, Field(description="The body content of the 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:
+        """Creates a new order with a custom pipeline.
+
+
+        :param create_complex_order_model: The body content of the request (required)
+        :type create_complex_order_model: CreateComplexOrderModel
+        :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._order_complex_post_serialize(
+            create_complex_order_model=create_complex_order_model,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CreateComplexOrderResult",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _order_complex_post_serialize(
+        self,
+        create_complex_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_complex_order_model is not None:
+            _body_params = create_complex_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] = [
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/order/complex',
+            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_order_id_approve_post(
+        self,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to approve")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -75,7 +352,7 @@ class OrderApi:
 
         An order is submitted for manual approval when the automatic approval process could not automatically  determine if the order is safe to process.  Once an order is approved, the pipeline will start processing the order.
 
-        :param order_id: The id of the order to approve
+        :param order_id: The id of the order to approve (required)
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -99,7 +376,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_approve_post_serialize(
+        _param = self._order_order_id_approve_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -108,7 +385,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -122,9 +399,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_approve_post_with_http_info(
+    def order_order_id_approve_post_with_http_info(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to approve")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to approve")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -142,7 +419,7 @@ class OrderApi:
 
         An order is submitted for manual approval when the automatic approval process could not automatically  determine if the order is safe to process.  Once an order is approved, the pipeline will start processing the order.
 
-        :param order_id: The id of the order to approve
+        :param order_id: The id of the order to approve (required)
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -166,7 +443,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_approve_post_serialize(
+        _param = self._order_order_id_approve_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -175,7 +452,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -189,9 +466,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_approve_post_without_preload_content(
+    def order_order_id_approve_post_without_preload_content(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to approve")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to approve")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -209,7 +486,7 @@ class OrderApi:
 
         An order is submitted for manual approval when the automatic approval process could not automatically  determine if the order is safe to process.  Once an order is approved, the pipeline will start processing the order.
 
-        :param order_id: The id of the order to approve
+        :param order_id: The id of the order to approve (required)
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -233,7 +510,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_approve_post_serialize(
+        _param = self._order_order_id_approve_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -242,7 +519,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -251,7 +528,7 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_approve_post_serialize(
+    def _order_order_id_approve_post_serialize(
         self,
         order_id,
         _request_auth,
@@ -275,11 +552,9 @@ class OrderApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
-        # process the query parameters
         if order_id is not None:
-            
-            _query_params.append(('orderId', order_id))
-            
+            _path_params['orderId'] = order_id
+        # process the query parameters
         # process the header parameters
         # process the form parameters
         # process the body parameter
@@ -289,13 +564,14 @@ class OrderApi:
 
         # authentication setting
         _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Order/Approve',
+            resource_path='/order/{orderId}/approve',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -312,9 +588,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_clone_order_post(
+    def order_order_id_clone_post(
         self,
-        clone_order_model: Annotated[Optional[CloneOrderModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to clone")],
+        clone_order_model: Annotated[CloneOrderModel, Field(description="The body content of the request")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -332,7 +609,9 @@ class OrderApi:
 
         In order to clone an order, the existing order must be marked as public.
 
-        :param clone_order_model: The body content of the request
+        :param order_id: The id of the order to clone (required)
+        :type order_id: str
+        :param clone_order_model: The body content of the request (required)
         :type clone_order_model: CloneOrderModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -356,7 +635,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_clone_order_post_serialize(
+        _param = self._order_order_id_clone_post_serialize(
+            order_id=order_id,
             clone_order_model=clone_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -379,9 +659,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_clone_order_post_with_http_info(
+    def order_order_id_clone_post_with_http_info(
         self,
-        clone_order_model: Annotated[Optional[CloneOrderModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to clone")],
+        clone_order_model: Annotated[CloneOrderModel, Field(description="The body content of the request")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -399,7 +680,9 @@ class OrderApi:
 
         In order to clone an order, the existing order must be marked as public.
 
-        :param clone_order_model: The body content of the request
+        :param order_id: The id of the order to clone (required)
+        :type order_id: str
+        :param clone_order_model: The body content of the request (required)
         :type clone_order_model: CloneOrderModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -423,7 +706,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_clone_order_post_serialize(
+        _param = self._order_order_id_clone_post_serialize(
+            order_id=order_id,
             clone_order_model=clone_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -446,9 +730,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_clone_order_post_without_preload_content(
+    def order_order_id_clone_post_without_preload_content(
         self,
-        clone_order_model: Annotated[Optional[CloneOrderModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to clone")],
+        clone_order_model: Annotated[CloneOrderModel, Field(description="The body content of the request")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -466,7 +751,9 @@ class OrderApi:
 
         In order to clone an order, the existing order must be marked as public.
 
-        :param clone_order_model: The body content of the request
+        :param order_id: The id of the order to clone (required)
+        :type order_id: str
+        :param clone_order_model: The body content of the request (required)
         :type clone_order_model: CloneOrderModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -490,7 +777,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_clone_order_post_serialize(
+        _param = self._order_order_id_clone_post_serialize(
+            order_id=order_id,
             clone_order_model=clone_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -508,8 +796,9 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_clone_order_post_serialize(
+    def _order_order_id_clone_post_serialize(
         self,
+        order_id,
         clone_order_model,
         _request_auth,
         _content_type,
@@ -532,6 +821,8 @@ class OrderApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if order_id is not None:
+            _path_params['orderId'] = order_id
         # process the query parameters
         # process the header parameters
         # process the form parameters
@@ -568,13 +859,14 @@ class OrderApi:
 
         # authentication setting
         _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Order/CloneOrder',
+            resource_path='/order/{orderId}/clone',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -591,9 +883,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_create_complex_order_post(
+    def order_order_id_delete(
         self,
-        create_complex_order_model: Annotated[Optional[CreateComplexOrderModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to delete")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -606,12 +898,12 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> CreateComplexOrderResult:
-        """Creates a new order with a custom pipeline.
+    ) -> None:
+        """Deletes an order.
 
 
-        :param create_complex_order_model: The body content of the request
-        :type create_complex_order_model: CreateComplexOrderModel
+        :param order_id: The id of the order to delete (required)
+        :type order_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
@@ -634,8 +926,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_create_complex_order_post_serialize(
-            create_complex_order_model=create_complex_order_model,
+        _param = self._order_order_id_delete_serialize(
+            order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -643,7 +935,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateComplexOrderResult",
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -657,9 +949,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_create_complex_order_post_with_http_info(
+    def order_order_id_delete_with_http_info(
         self,
-        create_complex_order_model: Annotated[Optional[CreateComplexOrderModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to delete")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -672,12 +964,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[CreateComplexOrderResult]:
-        """Creates a new order with a custom pipeline.
+    ) -> ApiResponse[None]:
+        """Deletes an order.
 
 
-        :param create_complex_order_model: The body content of the request
-        :type create_complex_order_model: CreateComplexOrderModel
+        :param order_id: The id of the order to delete (required)
+        :type order_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
@@ -700,8 +992,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_create_complex_order_post_serialize(
-            create_complex_order_model=create_complex_order_model,
+        _param = self._order_order_id_delete_serialize(
+            order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -709,7 +1001,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateComplexOrderResult",
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -723,9 +1015,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_create_complex_order_post_without_preload_content(
+    def order_order_id_delete_without_preload_content(
         self,
-        create_complex_order_model: Annotated[Optional[CreateComplexOrderModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to delete")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -739,11 +1031,11 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Creates a new order with a custom pipeline.
+        """Deletes an order.
 
 
-        :param create_complex_order_model: The body content of the request
-        :type create_complex_order_model: CreateComplexOrderModel
+        :param order_id: The id of the order to delete (required)
+        :type order_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
@@ -766,8 +1058,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_create_complex_order_post_serialize(
-            create_complex_order_model=create_complex_order_model,
+        _param = self._order_order_id_delete_serialize(
+            order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -775,7 +1067,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateComplexOrderResult",
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -784,9 +1076,9 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_create_complex_order_post_serialize(
+    def _order_order_id_delete_serialize(
         self,
-        create_complex_order_model,
+        order_id,
         _request_auth,
         _content_type,
         _headers,
@@ -808,49 +1100,26 @@ class OrderApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if order_id is not None:
+            _path_params['orderId'] = order_id
         # process the query parameters
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if create_complex_order_model is not None:
-            _body_params = create_complex_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', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/Order/CreateComplexOrder',
+            method='DELETE',
+            resource_path='/order/{orderId}',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -867,9 +1136,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_create_post(
+    def order_order_id_demo_patch(
         self,
-        create_order_model: Optional[CreateOrderModel] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to update")],
+        is_demo: Annotated[Optional[StrictBool], Field(description="Whether to mark or unmark the order as a demo")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -882,12 +1152,14 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> CreateOrderResult:
-        """Used to create a new order.
+    ) -> None:
+        """Updates whether an order is a demo or not.
 
 
-        :param create_order_model: 
-        :type create_order_model: CreateOrderModel
+        :param order_id: The id of the order to update (required)
+        :type order_id: str
+        :param is_demo: Whether to mark or unmark the order as a demo
+        :type is_demo: 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
@@ -910,8 +1182,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_create_post_serialize(
-            create_order_model=create_order_model,
+        _param = self._order_order_id_demo_patch_serialize(
+            order_id=order_id,
+            is_demo=is_demo,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -919,7 +1192,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateOrderResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -933,9 +1206,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_create_post_with_http_info(
+    def order_order_id_demo_patch_with_http_info(
         self,
-        create_order_model: Optional[CreateOrderModel] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to update")],
+        is_demo: Annotated[Optional[StrictBool], Field(description="Whether to mark or unmark the order as a demo")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -948,12 +1222,14 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[CreateOrderResult]:
-        """Used to create a new order.
+    ) -> ApiResponse[None]:
+        """Updates whether an order is a demo or not.
 
 
-        :param create_order_model: 
-        :type create_order_model: CreateOrderModel
+        :param order_id: The id of the order to update (required)
+        :type order_id: str
+        :param is_demo: Whether to mark or unmark the order as a demo
+        :type is_demo: 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
@@ -976,8 +1252,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_create_post_serialize(
-            create_order_model=create_order_model,
+        _param = self._order_order_id_demo_patch_serialize(
+            order_id=order_id,
+            is_demo=is_demo,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -985,7 +1262,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateOrderResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -999,9 +1276,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_create_post_without_preload_content(
+    def order_order_id_demo_patch_without_preload_content(
         self,
-        create_order_model: Optional[CreateOrderModel] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to update")],
+        is_demo: Annotated[Optional[StrictBool], Field(description="Whether to mark or unmark the order as a demo")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1015,11 +1293,13 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Used to create a new order.
+        """Updates whether an order is a demo or not.
 
 
-        :param create_order_model: 
-        :type create_order_model: CreateOrderModel
+        :param order_id: The id of the order to update (required)
+        :type order_id: str
+        :param is_demo: Whether to mark or unmark the order as a demo
+        :type is_demo: 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
@@ -1042,8 +1322,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_create_post_serialize(
-            create_order_model=create_order_model,
+        _param = self._order_order_id_demo_patch_serialize(
+            order_id=order_id,
+            is_demo=is_demo,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1051,7 +1332,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateOrderResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1060,9 +1341,10 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_create_post_serialize(
+    def _order_order_id_demo_patch_serialize(
         self,
-        create_order_model,
+        order_id,
+        is_demo,
         _request_auth,
         _content_type,
         _headers,
@@ -1084,49 +1366,30 @@ class OrderApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if order_id is not None:
+            _path_params['orderId'] = order_id
         # process the query parameters
+        if is_demo is not None:
+            
+            _query_params.append(('isDemo', is_demo))
+            
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if create_order_model is not None:
-            _body_params = create_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', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/Order/Create',
+            method='PATCH',
+            resource_path='/order/{orderId}/demo',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1143,9 +1406,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_create_unsupported_order_post(
+    def order_order_id_download_results_get(
         self,
-        create_unsupported_order_model: Annotated[Optional[CreateUnsupportedOrderModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1158,12 +1421,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:
-        """Notifies the admins that a user wants to create an order with an unsupported label type or data type.
+    ) -> bytearray:
+        """Aggregates the results of an order and returns it as a file attachment.
 
+        Returns the aggregated result as a file with a given name.  The annotated type of the response represents the content type of the file.
 
-        :param create_unsupported_order_model: The body content of the request
-        :type create_unsupported_order_model: CreateUnsupportedOrderModel
+        :param order_id: The id of the order (required)
+        :type order_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
@@ -1186,8 +1450,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_create_unsupported_order_post_serialize(
-            create_unsupported_order_model=create_unsupported_order_model,
+        _param = self._order_order_id_download_results_get_serialize(
+            order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1195,7 +1459,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "bytearray",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1209,9 +1473,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_create_unsupported_order_post_with_http_info(
+    def order_order_id_download_results_get_with_http_info(
         self,
-        create_unsupported_order_model: Annotated[Optional[CreateUnsupportedOrderModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1224,12 +1488,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]:
-        """Notifies the admins that a user wants to create an order with an unsupported label type or data type.
+    ) -> ApiResponse[bytearray]:
+        """Aggregates the results of an order and returns it as a file attachment.
 
+        Returns the aggregated result as a file with a given name.  The annotated type of the response represents the content type of the file.
 
-        :param create_unsupported_order_model: The body content of the request
-        :type create_unsupported_order_model: CreateUnsupportedOrderModel
+        :param order_id: The id of the order (required)
+        :type order_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
@@ -1252,8 +1517,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_create_unsupported_order_post_serialize(
-            create_unsupported_order_model=create_unsupported_order_model,
+        _param = self._order_order_id_download_results_get_serialize(
+            order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1261,7 +1526,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "bytearray",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1275,9 +1540,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_create_unsupported_order_post_without_preload_content(
+    def order_order_id_download_results_get_without_preload_content(
         self,
-        create_unsupported_order_model: Annotated[Optional[CreateUnsupportedOrderModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1291,11 +1556,12 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Notifies the admins that a user wants to create an order with an unsupported label type or data type.
+        """Aggregates the results of an order and returns it as a file attachment.
 
+        Returns the aggregated result as a file with a given name.  The annotated type of the response represents the content type of the file.
 
-        :param create_unsupported_order_model: The body content of the request
-        :type create_unsupported_order_model: CreateUnsupportedOrderModel
+        :param order_id: The id of the order (required)
+        :type order_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
@@ -1318,8 +1584,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_create_unsupported_order_post_serialize(
-            create_unsupported_order_model=create_unsupported_order_model,
+        _param = self._order_order_id_download_results_get_serialize(
+            order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1327,7 +1593,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "bytearray",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1336,9 +1602,9 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_create_unsupported_order_post_serialize(
+    def _order_order_id_download_results_get_serialize(
         self,
-        create_unsupported_order_model,
+        order_id,
         _request_auth,
         _content_type,
         _headers,
@@ -1360,40 +1626,35 @@ class OrderApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if order_id is not None:
+            _path_params['orderId'] = order_id
         # process the query parameters
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if create_unsupported_order_model is not None:
-            _body_params = create_unsupported_order_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] = [
-            'bearer', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/Order/CreateUnsupportedOrder',
+            method='GET',
+            resource_path='/order/{orderId}/download-results',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1410,9 +1671,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_delete_delete(
+    def order_order_id_get(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to delete")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1425,11 +1686,11 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> None:
-        """Deletes an order.
+    ) -> GetOrderByIdResult:
+        """Retrieves an order by its id.
 
 
-        :param order_id: The id of the order to delete
+        :param order_id: The id of the order (required)
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -1453,7 +1714,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_delete_delete_serialize(
+        _param = self._order_order_id_get_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -1462,7 +1723,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "GetOrderByIdResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1476,9 +1737,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_delete_delete_with_http_info(
+    def order_order_id_get_with_http_info(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to delete")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1491,11 +1752,11 @@ 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]:
-        """Deletes an order.
+    ) -> ApiResponse[GetOrderByIdResult]:
+        """Retrieves an order by its id.
 
 
-        :param order_id: The id of the order to delete
+        :param order_id: The id of the order (required)
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -1519,7 +1780,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_delete_delete_serialize(
+        _param = self._order_order_id_get_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -1528,7 +1789,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "GetOrderByIdResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1542,9 +1803,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_delete_delete_without_preload_content(
+    def order_order_id_get_without_preload_content(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to delete")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1558,10 +1819,10 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Deletes an order.
+        """Retrieves an order by its id.
 
 
-        :param order_id: The id of the order to delete
+        :param order_id: The id of the order (required)
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -1585,7 +1846,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_delete_delete_serialize(
+        _param = self._order_order_id_get_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -1594,7 +1855,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "GetOrderByIdResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1603,7 +1864,7 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_delete_delete_serialize(
+    def _order_order_id_get_serialize(
         self,
         order_id,
         _request_auth,
@@ -1627,27 +1888,35 @@ class OrderApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
-        # process the query parameters
         if order_id is not None:
-            
-            _query_params.append(('orderId', order_id))
-            
+            _path_params['orderId'] = order_id
+        # process the query parameters
         # 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
         _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
-            method='DELETE',
-            resource_path='/Order/Delete',
+            method='GET',
+            resource_path='/order/{orderId}',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1664,9 +1933,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_feedback_post(
+    def order_order_id_name_patch(
         self,
-        feedback_model: Annotated[Optional[FeedbackModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to update")],
+        update_order_name_model: Annotated[UpdateOrderNameModel, Field(description="The body content of the request")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1680,11 +1950,13 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> None:
-        """Submits feedback about our services.
+        """Updates the name of an order.
 
 
-        :param feedback_model: The body content of the request
-        :type feedback_model: FeedbackModel
+        :param order_id: The id of the order to update (required)
+        :type order_id: str
+        :param update_order_name_model: The body content of the request (required)
+        :type update_order_name_model: UpdateOrderNameModel
         :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
@@ -1707,8 +1979,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_feedback_post_serialize(
-            feedback_model=feedback_model,
+        _param = self._order_order_id_name_patch_serialize(
+            order_id=order_id,
+            update_order_name_model=update_order_name_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1716,7 +1989,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1730,9 +2003,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_feedback_post_with_http_info(
+    def order_order_id_name_patch_with_http_info(
         self,
-        feedback_model: Annotated[Optional[FeedbackModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to update")],
+        update_order_name_model: Annotated[UpdateOrderNameModel, Field(description="The body content of the request")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1746,11 +2020,13 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[None]:
-        """Submits feedback about our services.
+        """Updates the name of an order.
 
 
-        :param feedback_model: The body content of the request
-        :type feedback_model: FeedbackModel
+        :param order_id: The id of the order to update (required)
+        :type order_id: str
+        :param update_order_name_model: The body content of the request (required)
+        :type update_order_name_model: UpdateOrderNameModel
         :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
@@ -1773,8 +2049,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_feedback_post_serialize(
-            feedback_model=feedback_model,
+        _param = self._order_order_id_name_patch_serialize(
+            order_id=order_id,
+            update_order_name_model=update_order_name_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1782,7 +2059,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1796,9 +2073,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_feedback_post_without_preload_content(
+    def order_order_id_name_patch_without_preload_content(
         self,
-        feedback_model: Annotated[Optional[FeedbackModel], Field(description="The body content of the request")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to update")],
+        update_order_name_model: Annotated[UpdateOrderNameModel, Field(description="The body content of the request")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1812,11 +2090,13 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Submits feedback about our services.
+        """Updates the name of an order.
 
 
-        :param feedback_model: The body content of the request
-        :type feedback_model: FeedbackModel
+        :param order_id: The id of the order to update (required)
+        :type order_id: str
+        :param update_order_name_model: The body content of the request (required)
+        :type update_order_name_model: UpdateOrderNameModel
         :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
@@ -1839,8 +2119,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_feedback_post_serialize(
-            feedback_model=feedback_model,
+        _param = self._order_order_id_name_patch_serialize(
+            order_id=order_id,
+            update_order_name_model=update_order_name_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1848,7 +2129,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1857,9 +2138,10 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_feedback_post_serialize(
+    def _order_order_id_name_patch_serialize(
         self,
-        feedback_model,
+        order_id,
+        update_order_name_model,
         _request_auth,
         _content_type,
         _headers,
@@ -1881,12 +2163,14 @@ class OrderApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if order_id is not None:
+            _path_params['orderId'] = order_id
         # process the query parameters
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if feedback_model is not None:
-            _body_params = feedback_model
+        if update_order_name_model is not None:
+            _body_params = update_order_name_model
 
 
 
@@ -1908,13 +2192,14 @@ class OrderApi:
 
         # authentication setting
         _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/Order/Feedback',
+            method='PATCH',
+            resource_path='/order/{orderId}/name',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1931,9 +2216,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_get_by_id_get(
+    def order_order_id_pause_post(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the order")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to pause")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1946,12 +2231,12 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> GetOrderByIdResult:
-        """Retrieves an order by its id.
+    ) -> None:
+        """Pauses an order that is processing. Meaning all campaigns in the order will be paused.
 
 
-        :param id: The id of the order
-        :type id: str
+        :param order_id: The id of the order to pause (required)
+        :type order_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
@@ -1974,8 +2259,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_get_by_id_get_serialize(
-            id=id,
+        _param = self._order_order_id_pause_post_serialize(
+            order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1983,7 +2268,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetOrderByIdResult",
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1997,9 +2282,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_get_by_id_get_with_http_info(
+    def order_order_id_pause_post_with_http_info(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the order")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to pause")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2012,12 +2297,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[GetOrderByIdResult]:
-        """Retrieves an order by its id.
+    ) -> ApiResponse[None]:
+        """Pauses an order that is processing. Meaning all campaigns in the order will be paused.
 
 
-        :param id: The id of the order
-        :type id: str
+        :param order_id: The id of the order to pause (required)
+        :type order_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
@@ -2040,8 +2325,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_get_by_id_get_serialize(
-            id=id,
+        _param = self._order_order_id_pause_post_serialize(
+            order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2049,7 +2334,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetOrderByIdResult",
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2063,9 +2348,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_get_by_id_get_without_preload_content(
+    def order_order_id_pause_post_without_preload_content(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the order")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to pause")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2079,11 +2364,11 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Retrieves an order by its id.
+        """Pauses an order that is processing. Meaning all campaigns in the order will be paused.
 
 
-        :param id: The id of the order
-        :type id: str
+        :param order_id: The id of the order to pause (required)
+        :type order_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
@@ -2106,8 +2391,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_get_by_id_get_serialize(
-            id=id,
+        _param = self._order_order_id_pause_post_serialize(
+            order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2115,7 +2400,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetOrderByIdResult",
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2124,9 +2409,9 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_get_by_id_get_serialize(
+    def _order_order_id_pause_post_serialize(
         self,
-        id,
+        order_id,
         _request_auth,
         _content_type,
         _headers,
@@ -2148,36 +2433,26 @@ class OrderApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if order_id is not None:
+            _path_params['orderId'] = order_id
         # process the query parameters
-        if id is not None:
-            
-            _query_params.append(('id', 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
         _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/Order/GetById',
+            method='POST',
+            resource_path='/order/{orderId}/pause',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -2194,9 +2469,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_get_order_results_get(
+    def order_order_id_preview_post(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the order")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to submit")],
+        preview_order_model: Annotated[Optional[PreviewOrderModel], Field(description="The model containing additional information for the preview.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2209,12 +2485,14 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> GetOrderResultsResult:
-        """Aggregates the results of an order.
+    ) -> None:
+        """Puts the order into preview mode, where one can inspect what our labelers receive.
 
 
-        :param id: The id of the order
-        :type id: str
+        :param order_id: The id of the order to submit (required)
+        :type order_id: str
+        :param preview_order_model: The model containing additional information for the preview.
+        :type preview_order_model: PreviewOrderModel
         :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
@@ -2237,8 +2515,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_get_order_results_get_serialize(
-            id=id,
+        _param = self._order_order_id_preview_post_serialize(
+            order_id=order_id,
+            preview_order_model=preview_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2246,7 +2525,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetOrderResultsResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2260,9 +2539,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_get_order_results_get_with_http_info(
+    def order_order_id_preview_post_with_http_info(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the order")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to submit")],
+        preview_order_model: Annotated[Optional[PreviewOrderModel], Field(description="The model containing additional information for the preview.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2275,12 +2555,14 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[GetOrderResultsResult]:
-        """Aggregates the results of an order.
+    ) -> ApiResponse[None]:
+        """Puts the order into preview mode, where one can inspect what our labelers receive.
 
 
-        :param id: The id of the order
-        :type id: str
+        :param order_id: The id of the order to submit (required)
+        :type order_id: str
+        :param preview_order_model: The model containing additional information for the preview.
+        :type preview_order_model: PreviewOrderModel
         :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
@@ -2303,8 +2585,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_get_order_results_get_serialize(
-            id=id,
+        _param = self._order_order_id_preview_post_serialize(
+            order_id=order_id,
+            preview_order_model=preview_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2312,7 +2595,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetOrderResultsResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2326,9 +2609,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_get_order_results_get_without_preload_content(
+    def order_order_id_preview_post_without_preload_content(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the order")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to submit")],
+        preview_order_model: Annotated[Optional[PreviewOrderModel], Field(description="The model containing additional information for the preview.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2342,11 +2626,13 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Aggregates the results of an order.
+        """Puts the order into preview mode, where one can inspect what our labelers receive.
 
 
-        :param id: The id of the order
-        :type id: str
+        :param order_id: The id of the order to submit (required)
+        :type order_id: str
+        :param preview_order_model: The model containing additional information for the preview.
+        :type preview_order_model: PreviewOrderModel
         :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
@@ -2369,8 +2655,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_get_order_results_get_serialize(
-            id=id,
+        _param = self._order_order_id_preview_post_serialize(
+            order_id=order_id,
+            preview_order_model=preview_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2378,7 +2665,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetOrderResultsResult",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2387,9 +2674,10 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_get_order_results_get_serialize(
+    def _order_order_id_preview_post_serialize(
         self,
-        id,
+        order_id,
+        preview_order_model,
         _request_auth,
         _content_type,
         _headers,
@@ -2411,36 +2699,43 @@ class OrderApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if order_id is not None:
+            _path_params['orderId'] = order_id
         # process the query parameters
-        if id is not None:
-            
-            _query_params.append(('id', id))
-            
         # process the header parameters
         # process the form parameters
         # process the body parameter
+        if preview_order_model is not None:
+            _body_params = preview_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', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/Order/GetOrderResults',
+            method='POST',
+            resource_path='/order/{orderId}/preview',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -2457,8 +2752,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_get_public_get(
+    def order_order_id_results_get(
         self,
+        order_id: Annotated[StrictStr, Field(description="The id of the order")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2471,10 +2767,12 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> GetPublicOrdersResult:
-        """Retrieves orders that are public and can be cloned by any user.
+    ) -> str:
+        """Aggregates the results of an order and returns the result as a json body.
 
 
+        :param order_id: The id of the order (required)
+        :type order_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
@@ -2497,7 +2795,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_get_public_get_serialize(
+        _param = self._order_order_id_results_get_serialize(
+            order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2505,7 +2804,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetPublicOrdersResult",
+            '200': "str",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2519,8 +2818,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_get_public_get_with_http_info(
+    def order_order_id_results_get_with_http_info(
         self,
+        order_id: Annotated[StrictStr, Field(description="The id of the order")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2533,10 +2833,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[GetPublicOrdersResult]:
-        """Retrieves orders that are public and can be cloned by any user.
+    ) -> ApiResponse[str]:
+        """Aggregates the results of an order and returns the result as a json body.
 
 
+        :param order_id: The id of the order (required)
+        :type order_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
@@ -2559,7 +2861,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_get_public_get_serialize(
+        _param = self._order_order_id_results_get_serialize(
+            order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2567,7 +2870,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetPublicOrdersResult",
+            '200': "str",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2581,8 +2884,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_get_public_get_without_preload_content(
+    def order_order_id_results_get_without_preload_content(
         self,
+        order_id: Annotated[StrictStr, Field(description="The id of the order")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2596,9 +2900,11 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Retrieves orders that are public and can be cloned by any user.
+        """Aggregates the results of an order and returns the result as a json body.
 
 
+        :param order_id: The id of the order (required)
+        :type order_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
@@ -2621,7 +2927,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_get_public_get_serialize(
+        _param = self._order_order_id_results_get_serialize(
+            order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2629,7 +2936,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetPublicOrdersResult",
+            '200': "str",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2638,8 +2945,9 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_get_public_get_serialize(
+    def _order_order_id_results_get_serialize(
         self,
+        order_id,
         _request_auth,
         _content_type,
         _headers,
@@ -2661,6 +2969,8 @@ class OrderApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if order_id is not None:
+            _path_params['orderId'] = order_id
         # process the query parameters
         # process the header parameters
         # process the form parameters
@@ -2680,13 +2990,14 @@ class OrderApi:
 
         # authentication setting
         _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/Order/GetPublic',
+            resource_path='/order/{orderId}/results',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -2703,9 +3014,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_pause_post(
+    def order_order_id_resume_post(
         self,
-        order_id: Optional[StrictStr] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to resume")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2719,10 +3030,10 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> None:
-        """Pauses an order that is processing. Meaning all campaigns in the order will be paused.
+        """Resumes a paused order. Meaning all campaigns in the order will be resumed.
 
 
-        :param order_id: 
+        :param order_id: The id of the order to resume (required)
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -2746,7 +3057,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_pause_post_serialize(
+        _param = self._order_order_id_resume_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -2755,7 +3066,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2769,9 +3080,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_pause_post_with_http_info(
+    def order_order_id_resume_post_with_http_info(
         self,
-        order_id: Optional[StrictStr] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to resume")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2785,10 +3096,10 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[None]:
-        """Pauses an order that is processing. Meaning all campaigns in the order will be paused.
+        """Resumes a paused order. Meaning all campaigns in the order will be resumed.
 
 
-        :param order_id: 
+        :param order_id: The id of the order to resume (required)
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -2812,7 +3123,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_pause_post_serialize(
+        _param = self._order_order_id_resume_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -2821,7 +3132,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2835,9 +3146,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_pause_post_without_preload_content(
+    def order_order_id_resume_post_without_preload_content(
         self,
-        order_id: Optional[StrictStr] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to resume")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2851,10 +3162,10 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Pauses an order that is processing. Meaning all campaigns in the order will be paused.
+        """Resumes a paused order. Meaning all campaigns in the order will be resumed.
 
 
-        :param order_id: 
+        :param order_id: The id of the order to resume (required)
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -2878,7 +3189,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_pause_post_serialize(
+        _param = self._order_order_id_resume_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -2887,7 +3198,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2896,7 +3207,7 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_pause_post_serialize(
+    def _order_order_id_resume_post_serialize(
         self,
         order_id,
         _request_auth,
@@ -2920,11 +3231,9 @@ class OrderApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
-        # process the query parameters
         if order_id is not None:
-            
-            _query_params.append(('orderId', order_id))
-            
+            _path_params['orderId'] = order_id
+        # process the query parameters
         # process the header parameters
         # process the form parameters
         # process the body parameter
@@ -2934,13 +3243,14 @@ class OrderApi:
 
         # authentication setting
         _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Order/Pause',
+            resource_path='/order/{orderId}/resume',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -2957,9 +3267,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_query_get(
+    def order_order_id_retry_post(
         self,
-        request: Annotated[Optional[QueryModel], Field(description="The parameters for filtering, paging, and sorting")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to retry")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2972,12 +3282,12 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> OrderModelPagedResult:
-        """Queries orders based on a filter, page, and sort criteria.
+    ) -> None:
+        """Retries a failed order.
 
 
-        :param request: The parameters for filtering, paging, and sorting
-        :type request: QueryModel
+        :param order_id: The id of the order to retry (required)
+        :type order_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
@@ -3000,8 +3310,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_query_get_serialize(
-            request=request,
+        _param = self._order_order_id_retry_post_serialize(
+            order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3009,7 +3319,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "OrderModelPagedResult",
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3023,9 +3333,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_query_get_with_http_info(
+    def order_order_id_retry_post_with_http_info(
         self,
-        request: Annotated[Optional[QueryModel], Field(description="The parameters for filtering, paging, and sorting")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to retry")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3038,12 +3348,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[OrderModelPagedResult]:
-        """Queries orders based on a filter, page, and sort criteria.
+    ) -> ApiResponse[None]:
+        """Retries a failed order.
 
 
-        :param request: The parameters for filtering, paging, and sorting
-        :type request: QueryModel
+        :param order_id: The id of the order to retry (required)
+        :type order_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
@@ -3066,8 +3376,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_query_get_serialize(
-            request=request,
+        _param = self._order_order_id_retry_post_serialize(
+            order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3075,7 +3385,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "OrderModelPagedResult",
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3089,9 +3399,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_query_get_without_preload_content(
+    def order_order_id_retry_post_without_preload_content(
         self,
-        request: Annotated[Optional[QueryModel], Field(description="The parameters for filtering, paging, and sorting")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to retry")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3105,11 +3415,11 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Queries orders based on a filter, page, and sort criteria.
+        """Retries a failed order.
 
 
-        :param request: The parameters for filtering, paging, and sorting
-        :type request: QueryModel
+        :param order_id: The id of the order to retry (required)
+        :type order_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
@@ -3132,8 +3442,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_query_get_serialize(
-            request=request,
+        _param = self._order_order_id_retry_post_serialize(
+            order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3141,7 +3451,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "OrderModelPagedResult",
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3150,9 +3460,9 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_query_get_serialize(
+    def _order_order_id_retry_post_serialize(
         self,
-        request,
+        order_id,
         _request_auth,
         _content_type,
         _headers,
@@ -3174,36 +3484,26 @@ class OrderApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if order_id is not None:
+            _path_params['orderId'] = order_id
         # process the query parameters
-        if request is not None:
-            
-            _query_params.append(('request', request))
-            
         # 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
         _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/Order/Query',
+            method='POST',
+            resource_path='/order/{orderId}/retry',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -3220,9 +3520,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_result_get(
+    def order_order_id_share_patch(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the order")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to update")],
+        is_public: Annotated[Optional[StrictBool], Field(description="Whether to mark or unmark the order as public")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3235,12 +3536,14 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> str:
-        """Aggregates the results of an order.
+    ) -> None:
+        """Updates whether an order is public or not.
 
 
-        :param id: The id of the order
-        :type id: str
+        :param order_id: The id of the order to update (required)
+        :type order_id: str
+        :param is_public: Whether to mark or unmark the order as public
+        :type is_public: 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
@@ -3263,8 +3566,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_result_get_serialize(
-            id=id,
+        _param = self._order_order_id_share_patch_serialize(
+            order_id=order_id,
+            is_public=is_public,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3272,7 +3576,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "str",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3286,9 +3590,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_result_get_with_http_info(
+    def order_order_id_share_patch_with_http_info(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the order")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to update")],
+        is_public: Annotated[Optional[StrictBool], Field(description="Whether to mark or unmark the order as public")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3301,12 +3606,14 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[str]:
-        """Aggregates the results of an order.
+    ) -> ApiResponse[None]:
+        """Updates whether an order is public or not.
 
 
-        :param id: The id of the order
-        :type id: str
+        :param order_id: The id of the order to update (required)
+        :type order_id: str
+        :param is_public: Whether to mark or unmark the order as public
+        :type is_public: 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
@@ -3329,8 +3636,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_result_get_serialize(
-            id=id,
+        _param = self._order_order_id_share_patch_serialize(
+            order_id=order_id,
+            is_public=is_public,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3338,7 +3646,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "str",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3352,9 +3660,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_result_get_without_preload_content(
+    def order_order_id_share_patch_without_preload_content(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the order")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to update")],
+        is_public: Annotated[Optional[StrictBool], Field(description="Whether to mark or unmark the order as public")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3368,11 +3677,13 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Aggregates the results of an order.
+        """Updates whether an order is public or not.
 
 
-        :param id: The id of the order
-        :type id: str
+        :param order_id: The id of the order to update (required)
+        :type order_id: str
+        :param is_public: Whether to mark or unmark the order as public
+        :type is_public: 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
@@ -3395,8 +3706,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_result_get_serialize(
-            id=id,
+        _param = self._order_order_id_share_patch_serialize(
+            order_id=order_id,
+            is_public=is_public,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3404,7 +3716,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "str",
+            '200': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3413,9 +3725,10 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_result_get_serialize(
+    def _order_order_id_share_patch_serialize(
         self,
-        id,
+        order_id,
+        is_public,
         _request_auth,
         _content_type,
         _headers,
@@ -3437,36 +3750,30 @@ class OrderApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if order_id is not None:
+            _path_params['orderId'] = order_id
         # process the query parameters
-        if id is not None:
+        if is_public is not None:
             
-            _query_params.append(('id', id))
+            _query_params.append(('isPublic', is_public))
             
         # 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
         _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/Order/Result',
+            method='PATCH',
+            resource_path='/order/{orderId}/share',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -3483,9 +3790,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_resume_post(
+    def order_order_id_submit_post(
         self,
-        order_id: Optional[StrictStr] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to submit")],
+        submit_order_model: Annotated[Optional[SubmitOrderModel], Field(description="The model containing additional information for the submission.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3499,11 +3807,14 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> None:
-        """Resumes a paused order. Meaning all campaigns in the order will be resumed.
+        """Submits an order for approval.
 
+        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: 
+        :param order_id: The id of the order to submit (required)
         :type order_id: str
+        :param submit_order_model: The model containing additional information for the submission.
+        :type submit_order_model: SubmitOrderModel
         :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
@@ -3526,8 +3837,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_resume_post_serialize(
+        _param = self._order_order_id_submit_post_serialize(
             order_id=order_id,
+            submit_order_model=submit_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3549,9 +3861,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_resume_post_with_http_info(
+    def order_order_id_submit_post_with_http_info(
         self,
-        order_id: Optional[StrictStr] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to submit")],
+        submit_order_model: Annotated[Optional[SubmitOrderModel], Field(description="The model containing additional information for the submission.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3565,11 +3878,14 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[None]:
-        """Resumes a paused order. Meaning all campaigns in the order will be resumed.
+        """Submits an order for approval.
 
+        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: 
+        :param order_id: The id of the order to submit (required)
         :type order_id: str
+        :param submit_order_model: The model containing additional information for the submission.
+        :type submit_order_model: SubmitOrderModel
         :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
@@ -3592,8 +3908,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_resume_post_serialize(
+        _param = self._order_order_id_submit_post_serialize(
             order_id=order_id,
+            submit_order_model=submit_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3615,9 +3932,10 @@ class OrderApi:
 
 
     @validate_call
-    def order_resume_post_without_preload_content(
+    def order_order_id_submit_post_without_preload_content(
         self,
-        order_id: Optional[StrictStr] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to submit")],
+        submit_order_model: Annotated[Optional[SubmitOrderModel], Field(description="The model containing additional information for the submission.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3631,11 +3949,14 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Resumes a paused order. Meaning all campaigns in the order will be resumed.
+        """Submits an order for approval.
 
+        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: 
+        :param order_id: The id of the order to submit (required)
         :type order_id: str
+        :param submit_order_model: The model containing additional information for the submission.
+        :type submit_order_model: SubmitOrderModel
         :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
@@ -3658,8 +3979,9 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_resume_post_serialize(
+        _param = self._order_order_id_submit_post_serialize(
             order_id=order_id,
+            submit_order_model=submit_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3676,9 +3998,10 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_resume_post_serialize(
+    def _order_order_id_submit_post_serialize(
         self,
         order_id,
+        submit_order_model,
         _request_auth,
         _content_type,
         _headers,
@@ -3700,27 +4023,43 @@ class OrderApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
-        # process the query parameters
         if order_id is not None:
-            
-            _query_params.append(('orderId', order_id))
-            
+            _path_params['orderId'] = order_id
+        # process the query parameters
         # process the header parameters
         # process the form parameters
         # process the body parameter
+        if submit_order_model is not None:
+            _body_params = submit_order_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'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Order/Resume',
+            resource_path='/order/{orderId}/submit',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -3737,9 +4076,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_retry_failed_post(
+    def order_order_id_unlock_post(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to retry")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to unlock")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3752,11 +4091,12 @@ class OrderApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> None:
-        """Retries a failed order.
+    ) -> 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 retry
+        :param order_id: The id of the order to unlock (required)
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -3780,7 +4120,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_retry_failed_post_serialize(
+        _param = self._order_order_id_unlock_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -3789,7 +4129,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "UnlockOrderResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3803,9 +4143,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_retry_failed_post_with_http_info(
+    def order_order_id_unlock_post_with_http_info(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to retry")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to unlock")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3818,11 +4158,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[None]:
-        """Retries a failed order.
+    ) -> 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 retry
+        :param order_id: The id of the order to unlock (required)
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -3846,7 +4187,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_retry_failed_post_serialize(
+        _param = self._order_order_id_unlock_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -3855,7 +4196,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "UnlockOrderResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3869,9 +4210,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_retry_failed_post_without_preload_content(
+    def order_order_id_unlock_post_without_preload_content(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to retry")] = None,
+        order_id: Annotated[StrictStr, Field(description="The id of the order to unlock")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3885,10 +4226,11 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Retries a failed order.
+        """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 retry
+        :param order_id: The id of the order to unlock (required)
         :type order_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -3912,7 +4254,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_retry_failed_post_serialize(
+        _param = self._order_order_id_unlock_post_serialize(
             order_id=order_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -3921,7 +4263,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "UnlockOrderResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3930,7 +4272,7 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_retry_failed_post_serialize(
+    def _order_order_id_unlock_post_serialize(
         self,
         order_id,
         _request_auth,
@@ -3954,27 +4296,35 @@ class OrderApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
-        # process the query parameters
-        if order_id is not None:
-            
-            _query_params.append(('orderId', order_id))
-            
+        if order_id is not None:
+            _path_params['orderId'] = order_id
+        # process the query parameters
         # 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
         _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Order/RetryFailed',
+            resource_path='/order/{orderId}/unlock',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -3991,9 +4341,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_share_put(
+    def order_post(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
+        create_order_model: Annotated[CreateOrderModel, Field(description="The body request.")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4006,12 +4356,12 @@ 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.
+    ) -> CreateOrderResult:
+        """Used to create a new order.
 
 
-        :param order_id: The id of the order to update
-        :type order_id: str
+        :param create_order_model: The body request. (required)
+        :type create_order_model: CreateOrderModel
         :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
@@ -4034,8 +4384,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_share_put_serialize(
-            order_id=order_id,
+        _param = self._order_post_serialize(
+            create_order_model=create_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4043,7 +4393,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "CreateOrderResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4057,9 +4407,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_share_put_with_http_info(
+    def order_post_with_http_info(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
+        create_order_model: Annotated[CreateOrderModel, Field(description="The body request.")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4072,12 +4422,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[None]:
-        """Updates whether an order is public or not.
+    ) -> ApiResponse[CreateOrderResult]:
+        """Used to create a new order.
 
 
-        :param order_id: The id of the order to update
-        :type order_id: str
+        :param create_order_model: The body request. (required)
+        :type create_order_model: CreateOrderModel
         :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
@@ -4100,8 +4450,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_share_put_serialize(
-            order_id=order_id,
+        _param = self._order_post_serialize(
+            create_order_model=create_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4109,7 +4459,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "CreateOrderResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4123,9 +4473,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_share_put_without_preload_content(
+    def order_post_without_preload_content(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to update")] = None,
+        create_order_model: Annotated[CreateOrderModel, Field(description="The body request.")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4139,11 +4489,11 @@ 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.
+        """Used to create a new order.
 
 
-        :param order_id: The id of the order to update
-        :type order_id: str
+        :param create_order_model: The body request. (required)
+        :type create_order_model: CreateOrderModel
         :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
@@ -4166,8 +4516,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_share_put_serialize(
-            order_id=order_id,
+        _param = self._order_post_serialize(
+            create_order_model=create_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4175,7 +4525,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "CreateOrderResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4184,9 +4534,9 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_share_put_serialize(
+    def _order_post_serialize(
         self,
-        order_id,
+        create_order_model,
         _request_auth,
         _content_type,
         _headers,
@@ -4209,26 +4559,48 @@ 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 create_order_model is not None:
+            _body_params = create_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', 
+                        'application/*+json'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
-            method='PUT',
-            resource_path='/Order/Share',
+            method='POST',
+            resource_path='/order',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -4245,9 +4617,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_submit_post(
+    def order_unsupported_post(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to submit")] = None,
+        create_unsupported_order_model: Annotated[CreateUnsupportedOrderModel, Field(description="The body content of the request")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4261,12 +4633,11 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> None:
-        """Submits an order for approval.
+        """Notifies the admins that a user wants to create an order with an unsupported label type or data type.
 
-        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
-        :type order_id: str
+        :param create_unsupported_order_model: The body content of the request (required)
+        :type create_unsupported_order_model: CreateUnsupportedOrderModel
         :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
@@ -4289,8 +4660,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_submit_post_serialize(
-            order_id=order_id,
+        _param = self._order_unsupported_post_serialize(
+            create_unsupported_order_model=create_unsupported_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4298,7 +4669,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4312,9 +4683,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_submit_post_with_http_info(
+    def order_unsupported_post_with_http_info(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to submit")] = None,
+        create_unsupported_order_model: Annotated[CreateUnsupportedOrderModel, Field(description="The body content of the request")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4328,12 +4699,11 @@ 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.
+        """Notifies the admins that a user wants to create an order with an unsupported label type or data type.
 
-        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
-        :type order_id: str
+        :param create_unsupported_order_model: The body content of the request (required)
+        :type create_unsupported_order_model: CreateUnsupportedOrderModel
         :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
@@ -4356,8 +4726,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_submit_post_serialize(
-            order_id=order_id,
+        _param = self._order_unsupported_post_serialize(
+            create_unsupported_order_model=create_unsupported_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4365,7 +4735,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4379,9 +4749,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_submit_post_without_preload_content(
+    def order_unsupported_post_without_preload_content(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to submit")] = None,
+        create_unsupported_order_model: Annotated[CreateUnsupportedOrderModel, Field(description="The body content of the request")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4395,12 +4765,11 @@ class OrderApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Submits an order for approval.
+        """Notifies the admins that a user wants to create an order with an unsupported label type or data type.
 
-        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
-        :type order_id: str
+        :param create_unsupported_order_model: The body content of the request (required)
+        :type create_unsupported_order_model: CreateUnsupportedOrderModel
         :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
@@ -4423,8 +4792,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_submit_post_serialize(
-            order_id=order_id,
+        _param = self._order_unsupported_post_serialize(
+            create_unsupported_order_model=create_unsupported_order_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4432,7 +4801,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4441,9 +4810,9 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_submit_post_serialize(
+    def _order_unsupported_post_serialize(
         self,
-        order_id,
+        create_unsupported_order_model,
         _request_auth,
         _content_type,
         _headers,
@@ -4466,26 +4835,40 @@ 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 create_unsupported_order_model is not None:
+            _body_params = create_unsupported_order_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'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/Order/Submit',
+            resource_path='/order/unsupported',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -4502,9 +4885,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_unlock_post(
+    def orders_aggregated_overview_get(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to unlock")] = None,
+        request: Optional[QueryModel] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4517,13 +4900,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.
+    ) -> PagedResultOfAggregatedOrdersModel:
+        """Retrieves the orders aggregated by customer, with total amounts and most recent order informations.
 
-        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 unlock
-        :type order_id: str
+        :param request:
+        :type request: QueryModel
         :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
@@ -4546,8 +4928,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_unlock_post_serialize(
-            order_id=order_id,
+        _param = self._orders_aggregated_overview_get_serialize(
+            request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4555,7 +4937,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UnlockOrderResult",
+            '200': "PagedResultOfAggregatedOrdersModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4569,9 +4951,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_unlock_post_with_http_info(
+    def orders_aggregated_overview_get_with_http_info(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to unlock")] = None,
+        request: Optional[QueryModel] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4584,13 +4966,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[PagedResultOfAggregatedOrdersModel]:
+        """Retrieves the orders aggregated by customer, with total amounts and most recent order informations.
 
-        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 unlock
-        :type order_id: str
+        :param request:
+        :type request: QueryModel
         :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
@@ -4613,8 +4994,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_unlock_post_serialize(
-            order_id=order_id,
+        _param = self._orders_aggregated_overview_get_serialize(
+            request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4622,7 +5003,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UnlockOrderResult",
+            '200': "PagedResultOfAggregatedOrdersModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4636,9 +5017,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_unlock_post_without_preload_content(
+    def orders_aggregated_overview_get_without_preload_content(
         self,
-        order_id: Annotated[Optional[StrictStr], Field(description="The id of the order to unlock")] = None,
+        request: Optional[QueryModel] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4652,12 +5033,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.
+        """Retrieves the orders aggregated by customer, with total amounts and most recent order informations.
 
-        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 unlock
-        :type order_id: str
+        :param request:
+        :type request: QueryModel
         :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
@@ -4680,8 +5060,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_unlock_post_serialize(
-            order_id=order_id,
+        _param = self._orders_aggregated_overview_get_serialize(
+            request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4689,7 +5069,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UnlockOrderResult",
+            '200': "PagedResultOfAggregatedOrdersModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4698,9 +5078,9 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_unlock_post_serialize(
+    def _orders_aggregated_overview_get_serialize(
         self,
-        order_id,
+        request,
         _request_auth,
         _content_type,
         _headers,
@@ -4723,9 +5103,9 @@ class OrderApi:
 
         # process the path parameters
         # process the query parameters
-        if order_id is not None:
+        if request is not None:
             
-            _query_params.append(('orderId', order_id))
+            _query_params.append(('request', request))
             
         # process the header parameters
         # process the form parameters
@@ -4745,13 +5125,14 @@ class OrderApi:
 
         # authentication setting
         _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/Order/Unlock',
+            method='GET',
+            resource_path='/orders/aggregated-overview',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -4768,10 +5149,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_update_access_put(
+    def orders_get(
         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,
+        request: Annotated[Optional[QueryModel], Field(description="The parameters for filtering, paging, and sorting")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4784,14 +5164,12 @@ 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.
+    ) -> PagedResultOfOrderModel:
+        """Queries orders based on a filter, page, and sort criteria.
 
 
-        :param order_id: The id of the order to update
-        :type order_id: str
-        :param update_access_model: The body content of the request
-        :type update_access_model: UpdateAccessModel
+        :param request: The parameters for filtering, paging, and sorting
+        :type request: QueryModel
         :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
@@ -4814,9 +5192,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_update_access_put_serialize(
-            order_id=order_id,
-            update_access_model=update_access_model,
+        _param = self._orders_get_serialize(
+            request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4824,7 +5201,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "PagedResultOfOrderModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4838,10 +5215,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_update_access_put_with_http_info(
+    def orders_get_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,
+        request: Annotated[Optional[QueryModel], Field(description="The parameters for filtering, paging, and sorting")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4854,14 +5230,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[None]:
-        """Updates whether an order is public or not.
+    ) -> ApiResponse[PagedResultOfOrderModel]:
+        """Queries orders based on a filter, page, and sort criteria.
 
 
-        :param order_id: The id of the order to update
-        :type order_id: str
-        :param update_access_model: The body content of the request
-        :type update_access_model: UpdateAccessModel
+        :param request: The parameters for filtering, paging, and sorting
+        :type request: QueryModel
         :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
@@ -4884,9 +5258,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_update_access_put_serialize(
-            order_id=order_id,
-            update_access_model=update_access_model,
+        _param = self._orders_get_serialize(
+            request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4894,7 +5267,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "PagedResultOfOrderModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4908,10 +5281,9 @@ class OrderApi:
 
 
     @validate_call
-    def order_update_access_put_without_preload_content(
+    def orders_get_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,
+        request: Annotated[Optional[QueryModel], Field(description="The parameters for filtering, paging, and sorting")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4925,13 +5297,11 @@ 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.
+        """Queries orders based on a filter, page, and sort criteria.
 
 
-        :param order_id: The id of the order to update
-        :type order_id: str
-        :param update_access_model: The body content of the request
-        :type update_access_model: UpdateAccessModel
+        :param request: The parameters for filtering, paging, and sorting
+        :type request: QueryModel
         :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
@@ -4954,9 +5324,8 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_update_access_put_serialize(
-            order_id=order_id,
-            update_access_model=update_access_model,
+        _param = self._orders_get_serialize(
+            request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4964,7 +5333,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "PagedResultOfOrderModel",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4973,10 +5342,9 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_update_access_put_serialize(
+    def _orders_get_serialize(
         self,
-        order_id,
-        update_access_model,
+        request,
         _request_auth,
         _content_type,
         _headers,
@@ -4999,43 +5367,36 @@ class OrderApi:
 
         # process the path parameters
         # process the query parameters
-        if order_id is not None:
+        if request is not None:
             
-            _query_params.append(('orderId', order_id))
+            _query_params.append(('request', request))
             
         # 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] = [
-            'bearer', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
-            method='PUT',
-            resource_path='/Order/UpdateAccess',
+            method='GET',
+            resource_path='/orders',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -5052,10 +5413,8 @@ class OrderApi:
 
 
     @validate_call
-    def order_update_order_name_put(
+    def orders_public_get(
         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,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5068,14 +5427,10 @@ 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 the name of an order.
+    ) -> GetPublicOrdersResult:
+        """Retrieves orders that are public and can be cloned by any user.
 
 
-        :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
@@ -5098,9 +5453,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_update_order_name_put_serialize(
-            order_id=order_id,
-            update_order_model=update_order_model,
+        _param = self._orders_public_get_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -5108,7 +5461,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "GetPublicOrdersResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -5122,10 +5475,8 @@ class OrderApi:
 
 
     @validate_call
-    def order_update_order_name_put_with_http_info(
+    def orders_public_get_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,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5138,14 +5489,10 @@ 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 the name of an order.
+    ) -> ApiResponse[GetPublicOrdersResult]:
+        """Retrieves orders that are public and can be cloned by any user.
 
 
-        :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
@@ -5168,9 +5515,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_update_order_name_put_serialize(
-            order_id=order_id,
-            update_order_model=update_order_model,
+        _param = self._orders_public_get_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -5178,7 +5523,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "GetPublicOrdersResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -5192,10 +5537,8 @@ class OrderApi:
 
 
     @validate_call
-    def order_update_order_name_put_without_preload_content(
+    def orders_public_get_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,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -5209,13 +5552,9 @@ 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.
+        """Retrieves orders that are public and can be cloned by any user.
 
 
-        :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
@@ -5238,9 +5577,7 @@ class OrderApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._order_update_order_name_put_serialize(
-            order_id=order_id,
-            update_order_model=update_order_model,
+        _param = self._orders_public_get_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -5248,7 +5585,7 @@ class OrderApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '200': "GetPublicOrdersResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -5257,10 +5594,8 @@ class OrderApi:
         return response_data.response
 
 
-    def _order_update_order_name_put_serialize(
+    def _orders_public_get_serialize(
         self,
-        order_id,
-        update_order_model,
         _request_auth,
         _content_type,
         _headers,
@@ -5283,43 +5618,32 @@ 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_order_model is not None:
-            _body_params = update_order_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] = [
-            'bearer', 
-            'oauth2'
+            'OAuth2', 
+            'OpenIdConnect', 
+            'Bearer'
         ]
 
         return self.api_client.param_serialize(
-            method='PUT',
-            resource_path='/Order/UpdateOrderName',
+            method='GET',
+            resource_path='/orders/public',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,