lusid-sdk 1.1.257__py3-none-any.whl → 2.0.430__py3-none-any.whl

lusid/api/order_management_api.py

@@ -5,400 +5,123 @@
 
     FINBOURNE Technology  # noqa: E501
 
-    The version of the OpenAPI document: 1.1.257
     Contact: info@finbourne.com
-    Generated by: https://openapi-generator.tech
-"""
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
 
+    Do not edit the class manually.
+"""
 
-from __future__ import absolute_import
 
 import re  # noqa: F401
+import io
+import warnings
 
-# python 2 and python 3 compatibility library
-import six
+from pydantic import validate_arguments, ValidationError
+from typing import overload, Optional, Union, Awaitable
 
-from lusid.api_client import ApiClient
-from lusid.exceptions import (  # noqa: F401
-    ApiTypeError,
-    ApiValueError
-)
+from typing_extensions import Annotated
+from pydantic import Field, StrictBool, conlist, constr, validator
+
+from typing import Optional
+
+from lusid.models.allocation_service_run_response import AllocationServiceRunResponse
 from lusid.models.block_and_orders_create_request import BlockAndOrdersCreateRequest
-from lusid.models.cancel_orders_and_move_remaining_request import CancelOrdersAndMoveRemainingRequest
-from lusid.models.cancel_orders_and_move_remaining_response import CancelOrdersAndMoveRemainingResponse
-from lusid.models.cancel_orders_response import CancelOrdersResponse
-from lusid.models.cancel_placements_response import CancelPlacementsResponse
-from lusid.models.lusid_problem_details import LusidProblemDetails
-from lusid.models.lusid_validation_problem_details import LusidValidationProblemDetails
+from lusid.models.book_transactions_request import BookTransactionsRequest
+from lusid.models.book_transactions_response import BookTransactionsResponse
 from lusid.models.move_orders_to_different_blocks_request import MoveOrdersToDifferentBlocksRequest
-from lusid.models.order_update_request import OrderUpdateRequest
 from lusid.models.place_blocks_request import PlaceBlocksRequest
-from lusid.models.placement_update_request import PlacementUpdateRequest
 from lusid.models.resource_id import ResourceId
 from lusid.models.resource_list_of_block_and_orders import ResourceListOfBlockAndOrders
 from lusid.models.resource_list_of_moved_order_to_different_block_response import ResourceListOfMovedOrderToDifferentBlockResponse
 from lusid.models.resource_list_of_placement import ResourceListOfPlacement
-from lusid.models.update_orders_response import UpdateOrdersResponse
-from lusid.models.update_placements_response import UpdatePlacementsResponse
 
+from lusid.api_client import ApiClient
+from lusid.api_response import ApiResponse
+from lusid.exceptions import (  # noqa: F401
+    ApiTypeError,
+    ApiValueError
+)
 
-class OrderManagementApi(object):
+
+class OrderManagementApi:
     """NOTE: This class is auto generated by OpenAPI Generator
     Ref: https://openapi-generator.tech
 
     Do not edit the class manually.
     """
 
-    def __init__(self, api_client=None):
+    def __init__(self, api_client=None) -> None:
         if api_client is None:
-            api_client = ApiClient()
+            api_client = ApiClient.get_default()
         self.api_client = api_client
 
-    def cancel_orders(self, request_body, **kwargs):  # noqa: E501
-        """[EARLY ACCESS] CancelOrders: Cancel existing orders  # noqa: E501
+    @overload
+    async def book_transactions(self, book_transactions_request : Annotated[BookTransactionsRequest, Field(..., description="The allocations to create transactions for")], apply_fees_and_commission : Annotated[Optional[StrictBool], Field(description="Whether to apply fees and commissions to transactions (default: true)")] = None, **kwargs) -> BookTransactionsResponse:  # noqa: E501
+        ...
 
-        The response returns both the collection of successfully canceled orders, as well as those  that failed. For each failure, a reason is provided. It is important to check the failed set for  unsuccessful results.  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
+    @overload
+    def book_transactions(self, book_transactions_request : Annotated[BookTransactionsRequest, Field(..., description="The allocations to create transactions for")], apply_fees_and_commission : Annotated[Optional[StrictBool], Field(description="Whether to apply fees and commissions to transactions (default: true)")] = None, async_req: Optional[bool]=True, **kwargs) -> BookTransactionsResponse:  # noqa: E501
+        ...
 
-        >>> thread = api.cancel_orders(request_body, async_req=True)
-        >>> result = thread.get()
+    @validate_arguments
+    def book_transactions(self, book_transactions_request : Annotated[BookTransactionsRequest, Field(..., description="The allocations to create transactions for")], apply_fees_and_commission : Annotated[Optional[StrictBool], Field(description="Whether to apply fees and commissions to transactions (default: true)")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BookTransactionsResponse, Awaitable[BookTransactionsResponse]]:  # noqa: E501
+        """[EXPERIMENTAL] BookTransactions: Books transactions using specific allocations as a source.  # noqa: E501
 
-        :param request_body: The request containing the ids of the orders to be cancelled. (required)
-        :type request_body: dict(str, ResourceId)
-        :param async_req: Whether to execute the request asynchronously.
-        :type async_req: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :type _preload_content: bool, optional
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: Returns the result object.
-                 If the method is called asynchronously,
-                 returns the request thread.
-        :rtype: CancelOrdersResponse
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.cancel_orders_with_http_info(request_body, **kwargs)  # noqa: E501
-
-    def cancel_orders_with_http_info(self, request_body, **kwargs):  # noqa: E501
-        """[EARLY ACCESS] CancelOrders: Cancel existing orders  # noqa: E501
-
-        The response returns both the collection of successfully canceled orders, as well as those  that failed. For each failure, a reason is provided. It is important to check the failed set for  unsuccessful results.  # noqa: E501
+        Takes a collection of allocation IDs, and maps fields from those allocations and related orders onto new transactions.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.cancel_orders_with_http_info(request_body, async_req=True)
+        >>> thread = api.book_transactions(book_transactions_request, apply_fees_and_commission, async_req=True)
         >>> result = thread.get()
 
-        :param request_body: The request containing the ids of the orders to be cancelled. (required)
-        :type request_body: dict(str, ResourceId)
+        :param book_transactions_request: The allocations to create transactions for (required)
+        :type book_transactions_request: BookTransactionsRequest
+        :param apply_fees_and_commission: Whether to apply fees and commissions to transactions (default: true)
+        :type apply_fees_and_commission: bool
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :type _return_http_data_only: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :type _preload_content: bool, optional
-        :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.
-        :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
-        :return: Returns the result object, the HTTP status code, and the headers.
-                 If the method is called asynchronously,
-                 returns the request thread.
-        :rtype: (CancelOrdersResponse, int, HTTPHeaderDict)
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'request_body'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout',
-                '_request_auth',
-                '_headers'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method cancel_orders" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'request_body' is set
-        if self.api_client.client_side_validation and ('request_body' not in local_var_params or  # noqa: E501
-                                                        local_var_params['request_body'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `request_body` when calling `cancel_orders`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-
-        query_params = []
-
-        header_params = dict(local_var_params.get('_headers', {}))
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        if 'request_body' in local_var_params:
-            body_params = local_var_params['request_body']
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
-            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
-
-        header_params['Accept-Encoding'] = "gzip, deflate, br"
-
-        # HTTP header `Content-Type`
-        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
-            ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json'])  # noqa: E501
-
-        # set the LUSID header
-        header_params['X-LUSID-SDK-Language'] = 'Python'
-        header_params['X-LUSID-SDK-Version'] = '1.1.257'
-
-        # Authentication setting
-        auth_settings = ['oauth2']  # noqa: E501
-
-        response_types_map = {
-            200: "CancelOrdersResponse",
-            400: "LusidValidationProblemDetails",
-        }
-
-        return self.api_client.call_api(
-            '/api/ordermanagement/cancelorders', 'POST',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_types_map=response_types_map,
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats,
-            _request_auth=local_var_params.get('_request_auth'))
-
-    def cancel_orders_and_move_remaining(self, request_body, **kwargs):  # noqa: E501
-        """[EARLY ACCESS] CancelOrdersAndMoveRemaining: Cancel existing orders and move any unplaced quantities to new orders in new blocks  # noqa: E501
-
-        Cancels existing orders, reducing their quantities to those aleady placed. Any remaining quantities are moved  to new orders in new blocks. The placed quantities are distributed to the cancelled orders on a pro-rata basis.  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-
-        >>> thread = api.cancel_orders_and_move_remaining(request_body, async_req=True)
-        >>> result = thread.get()
-
-        :param request_body: The request containing the orders to be cancelled, and the destinations of remaining quantities. (required)
-        :type request_body: dict(str, CancelOrdersAndMoveRemainingRequest)
-        :param async_req: Whether to execute the request asynchronously.
-        :type async_req: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :type _preload_content: bool, optional
-        :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.
+        :param _request_timeout: timeout setting for this request.
+               If one number provided, it will be total request
+               timeout. It can also be a pair (tuple) of
+               (connection, read) timeouts.
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: CancelOrdersAndMoveRemainingResponse
+        :rtype: BookTransactionsResponse
         """
         kwargs['_return_http_data_only'] = True
-        return self.cancel_orders_and_move_remaining_with_http_info(request_body, **kwargs)  # noqa: E501
-
-    def cancel_orders_and_move_remaining_with_http_info(self, request_body, **kwargs):  # noqa: E501
-        """[EARLY ACCESS] CancelOrdersAndMoveRemaining: Cancel existing orders and move any unplaced quantities to new orders in new blocks  # noqa: E501
-
-        Cancels existing orders, reducing their quantities to those aleady placed. Any remaining quantities are moved  to new orders in new blocks. The placed quantities are distributed to the cancelled orders on a pro-rata basis.  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-
-        >>> thread = api.cancel_orders_and_move_remaining_with_http_info(request_body, async_req=True)
-        >>> result = thread.get()
-
-        :param request_body: The request containing the orders to be cancelled, and the destinations of remaining quantities. (required)
-        :type request_body: dict(str, CancelOrdersAndMoveRemainingRequest)
-        :param async_req: Whether to execute the request asynchronously.
-        :type async_req: bool, optional
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :type _return_http_data_only: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :type _preload_content: bool, optional
-        :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.
-        :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
-        :return: Returns the result object, the HTTP status code, and the headers.
-                 If the method is called asynchronously,
-                 returns the request thread.
-        :rtype: (CancelOrdersAndMoveRemainingResponse, int, HTTPHeaderDict)
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'request_body'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout',
-                '_request_auth',
-                '_headers'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method cancel_orders_and_move_remaining" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'request_body' is set
-        if self.api_client.client_side_validation and ('request_body' not in local_var_params or  # noqa: E501
-                                                        local_var_params['request_body'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `request_body` when calling `cancel_orders_and_move_remaining`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-
-        query_params = []
-
-        header_params = dict(local_var_params.get('_headers', {}))
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        if 'request_body' in local_var_params:
-            body_params = local_var_params['request_body']
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
-            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
-
-        header_params['Accept-Encoding'] = "gzip, deflate, br"
-
-        # HTTP header `Content-Type`
-        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
-            ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json'])  # noqa: E501
-
-        # set the LUSID header
-        header_params['X-LUSID-SDK-Language'] = 'Python'
-        header_params['X-LUSID-SDK-Version'] = '1.1.257'
-
-        # Authentication setting
-        auth_settings = ['oauth2']  # noqa: E501
-
-        response_types_map = {
-            200: "CancelOrdersAndMoveRemainingResponse",
-            400: "LusidValidationProblemDetails",
-        }
-
-        return self.api_client.call_api(
-            '/api/ordermanagement/cancelordersandmoveremaining', 'POST',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_types_map=response_types_map,
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats,
-            _request_auth=local_var_params.get('_request_auth'))
-
-    def cancel_placements(self, request_body, **kwargs):  # noqa: E501
-        """[EARLY ACCESS] CancelPlacements: Cancel existing placements  # noqa: E501
-
-        The response returns both the collection of successfully canceled placements, as well as those  that failed. For each failure, a reason is provided. It is important to check the failed set for  unsuccessful results.  # noqa: E501
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the book_transactions_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
+        return self.book_transactions_with_http_info(book_transactions_request, apply_fees_and_commission, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def book_transactions_with_http_info(self, book_transactions_request : Annotated[BookTransactionsRequest, Field(..., description="The allocations to create transactions for")], apply_fees_and_commission : Annotated[Optional[StrictBool], Field(description="Whether to apply fees and commissions to transactions (default: true)")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+        """[EXPERIMENTAL] BookTransactions: Books transactions using specific allocations as a source.  # noqa: E501
+
+        Takes a collection of allocation IDs, and maps fields from those allocations and related orders onto new transactions.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.cancel_placements(request_body, async_req=True)
+        >>> thread = api.book_transactions_with_http_info(book_transactions_request, apply_fees_and_commission, async_req=True)
         >>> result = thread.get()
 
-        :param request_body: The request containing the ids of the placements to be cancelled. (required)
-        :type request_body: dict(str, ResourceId)
+        :param book_transactions_request: The allocations to create transactions for (required)
+        :type book_transactions_request: BookTransactionsRequest
+        :param apply_fees_and_commission: Whether to apply fees and commissions to transactions (default: true)
+        :type apply_fees_and_commission: bool
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
         :type _preload_content: bool, optional
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: Returns the result object.
-                 If the method is called asynchronously,
-                 returns the request thread.
-        :rtype: CancelPlacementsResponse
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.cancel_placements_with_http_info(request_body, **kwargs)  # noqa: E501
-
-    def cancel_placements_with_http_info(self, request_body, **kwargs):  # noqa: E501
-        """[EARLY ACCESS] CancelPlacements: Cancel existing placements  # noqa: E501
-
-        The response returns both the collection of successfully canceled placements, as well as those  that failed. For each failure, a reason is provided. It is important to check the failed set for  unsuccessful results.  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-
-        >>> thread = api.cancel_placements_with_http_info(request_body, async_req=True)
-        >>> result = thread.get()
-
-        :param request_body: The request containing the ids of the placements to be cancelled. (required)
-        :type request_body: dict(str, ResourceId)
-        :param async_req: Whether to execute the request asynchronously.
-        :type async_req: bool, optional
-        :param _return_http_data_only: response data without head status code
-                                       and headers
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
         :type _return_http_data_only: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :type _preload_content: bool, optional
         :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
@@ -407,95 +130,107 @@ class OrderManagementApi(object):
                               request; this effectively ignores the authentication
                               in the spec for a single request.
         :type _request_auth: dict, optional
-        :return: Returns the result object, the HTTP status code, and the headers.
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: (CancelPlacementsResponse, int, HTTPHeaderDict)
+        :rtype: tuple(BookTransactionsResponse, status_code(int), headers(HTTPHeaderDict))
         """
 
-        local_var_params = locals()
+        _params = locals()
 
-        all_params = [
-            'request_body'
+        _all_params = [
+            'book_transactions_request',
+            'apply_fees_and_commission'
         ]
-        all_params.extend(
+        _all_params.extend(
             [
                 'async_req',
                 '_return_http_data_only',
                 '_preload_content',
                 '_request_timeout',
                 '_request_auth',
+                '_content_type',
                 '_headers'
             ]
         )
 
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method cancel_placements" % key
+                    " to method book_transactions" % _key
                 )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'request_body' is set
-        if self.api_client.client_side_validation and ('request_body' not in local_var_params or  # noqa: E501
-                                                        local_var_params['request_body'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `request_body` when calling `cancel_placements`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-
-        query_params = []
-
-        header_params = dict(local_var_params.get('_headers', {}))
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        if 'request_body' in local_var_params:
-            body_params = local_var_params['request_body']
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+
+        # process the query parameters
+        _query_params = []
+        if _params.get('apply_fees_and_commission') is not None:  # noqa: E501
+            _query_params.append(('applyFeesAndCommission', _params['apply_fees_and_commission']))
+
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params['book_transactions_request'] is not None:
+            _body_params = _params['book_transactions_request']
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
             ['text/plain', 'application/json', 'text/json'])  # noqa: E501
 
-        header_params['Accept-Encoding'] = "gzip, deflate, br"
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get('_content_type',
+            self.api_client.select_header_content_type(
+                ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json']))
+        if _content_types_list:
+                _header_params['Content-Type'] = _content_types_list
 
-        # HTTP header `Content-Type`
-        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
-            ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json'])  # noqa: E501
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
 
-        # set the LUSID header
-        header_params['X-LUSID-SDK-Language'] = 'Python'
-        header_params['X-LUSID-SDK-Version'] = '1.1.257'
-
-        # Authentication setting
-        auth_settings = ['oauth2']  # noqa: E501
-
-        response_types_map = {
-            200: "CancelPlacementsResponse",
-            400: "LusidValidationProblemDetails",
+        _response_types_map = {
+            '200': "BookTransactionsResponse",
+            '400': "LusidValidationProblemDetails",
         }
 
         return self.api_client.call_api(
-            '/api/ordermanagement/$cancelplacements', 'POST',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_types_map=response_types_map,
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats,
-            _request_auth=local_var_params.get('_request_auth'))
-
-    def create_orders(self, block_and_orders_create_request, **kwargs):  # noqa: E501
+            '/api/ordermanagement/booktransactions', 'POST',
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
+    @overload
+    async def create_orders(self, block_and_orders_create_request : Annotated[BlockAndOrdersCreateRequest, Field(..., description="The collection of block and orders requests.")], **kwargs) -> ResourceListOfBlockAndOrders:  # noqa: E501
+        ...
+
+    @overload
+    def create_orders(self, block_and_orders_create_request : Annotated[BlockAndOrdersCreateRequest, Field(..., description="The collection of block and orders requests.")], async_req: Optional[bool]=True, **kwargs) -> ResourceListOfBlockAndOrders:  # noqa: E501
+        ...
+
+    @validate_arguments
+    def create_orders(self, block_and_orders_create_request : Annotated[BlockAndOrdersCreateRequest, Field(..., description="The collection of block and orders requests.")], async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfBlockAndOrders, Awaitable[ResourceListOfBlockAndOrders]]:  # noqa: E501
         """[EARLY ACCESS] CreateOrders: Upsert a Block and associated orders  # noqa: E501
 
         Upsert a Block and create associated orders.  This will fail if the block exists and already references orders with differing fields to the upsert request.  # noqa: E501
@@ -509,23 +244,25 @@ class OrderManagementApi(object):
         :type block_and_orders_create_request: BlockAndOrdersCreateRequest
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :type _preload_content: bool, optional
-        :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.
+        :param _request_timeout: timeout setting for this request.
+               If one number provided, it will be total request
+               timeout. It can also be a pair (tuple) of
+               (connection, read) timeouts.
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
         :rtype: ResourceListOfBlockAndOrders
         """
         kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the create_orders_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
         return self.create_orders_with_http_info(block_and_orders_create_request, **kwargs)  # noqa: E501
 
-    def create_orders_with_http_info(self, block_and_orders_create_request, **kwargs):  # noqa: E501
+    @validate_arguments
+    def create_orders_with_http_info(self, block_and_orders_create_request : Annotated[BlockAndOrdersCreateRequest, Field(..., description="The collection of block and orders requests.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] CreateOrders: Upsert a Block and associated orders  # noqa: E501
 
         Upsert a Block and create associated orders.  This will fail if the block exists and already references orders with differing fields to the upsert request.  # noqa: E501
@@ -539,13 +276,14 @@ class OrderManagementApi(object):
         :type block_and_orders_create_request: BlockAndOrdersCreateRequest
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :type _return_http_data_only: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
         :type _preload_content: bool, optional
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
         :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
@@ -554,95 +292,103 @@ class OrderManagementApi(object):
                               request; this effectively ignores the authentication
                               in the spec for a single request.
         :type _request_auth: dict, optional
-        :return: Returns the result object, the HTTP status code, and the headers.
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: (ResourceListOfBlockAndOrders, int, HTTPHeaderDict)
+        :rtype: tuple(ResourceListOfBlockAndOrders, status_code(int), headers(HTTPHeaderDict))
         """
 
-        local_var_params = locals()
+        _params = locals()
 
-        all_params = [
+        _all_params = [
             'block_and_orders_create_request'
         ]
-        all_params.extend(
+        _all_params.extend(
             [
                 'async_req',
                 '_return_http_data_only',
                 '_preload_content',
                 '_request_timeout',
                 '_request_auth',
+                '_content_type',
                 '_headers'
             ]
         )
 
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method create_orders" % key
+                    " to method create_orders" % _key
                 )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'block_and_orders_create_request' is set
-        if self.api_client.client_side_validation and ('block_and_orders_create_request' not in local_var_params or  # noqa: E501
-                                                        local_var_params['block_and_orders_create_request'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `block_and_orders_create_request` when calling `create_orders`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-
-        query_params = []
-
-        header_params = dict(local_var_params.get('_headers', {}))
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        if 'block_and_orders_create_request' in local_var_params:
-            body_params = local_var_params['block_and_orders_create_request']
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+
+        # process the query parameters
+        _query_params = []
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params['block_and_orders_create_request'] is not None:
+            _body_params = _params['block_and_orders_create_request']
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
             ['text/plain', 'application/json', 'text/json'])  # noqa: E501
 
-        header_params['Accept-Encoding'] = "gzip, deflate, br"
-
-        # HTTP header `Content-Type`
-        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
-            ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json'])  # noqa: E501
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get('_content_type',
+            self.api_client.select_header_content_type(
+                ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json']))
+        if _content_types_list:
+                _header_params['Content-Type'] = _content_types_list
 
-        # set the LUSID header
-        header_params['X-LUSID-SDK-Language'] = 'Python'
-        header_params['X-LUSID-SDK-Version'] = '1.1.257'
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
 
-        # Authentication setting
-        auth_settings = ['oauth2']  # noqa: E501
-
-        response_types_map = {
-            201: "ResourceListOfBlockAndOrders",
-            400: "LusidValidationProblemDetails",
+        _response_types_map = {
+            '201': "ResourceListOfBlockAndOrders",
+            '400': "LusidValidationProblemDetails",
         }
 
         return self.api_client.call_api(
             '/api/ordermanagement/createorders', 'POST',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_types_map=response_types_map,
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats,
-            _request_auth=local_var_params.get('_request_auth'))
-
-    def move_orders(self, move_orders_to_different_blocks_request, **kwargs):  # noqa: E501
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
+    @overload
+    async def move_orders(self, move_orders_to_different_blocks_request : Annotated[MoveOrdersToDifferentBlocksRequest, Field(..., description="The collection of order and destination block ids.")], **kwargs) -> ResourceListOfMovedOrderToDifferentBlockResponse:  # noqa: E501
+        ...
+
+    @overload
+    def move_orders(self, move_orders_to_different_blocks_request : Annotated[MoveOrdersToDifferentBlocksRequest, Field(..., description="The collection of order and destination block ids.")], async_req: Optional[bool]=True, **kwargs) -> ResourceListOfMovedOrderToDifferentBlockResponse:  # noqa: E501
+        ...
+
+    @validate_arguments
+    def move_orders(self, move_orders_to_different_blocks_request : Annotated[MoveOrdersToDifferentBlocksRequest, Field(..., description="The collection of order and destination block ids.")], async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfMovedOrderToDifferentBlockResponse, Awaitable[ResourceListOfMovedOrderToDifferentBlockResponse]]:  # noqa: E501
         """[EARLY ACCESS] MoveOrders: Move orders to new or existing block  # noqa: E501
 
         Move an order to a block, creating the block if it does not already exist.   This will fail if the block exists and already references orders with differing fields to the upsert request.  # noqa: E501
@@ -656,23 +402,25 @@ class OrderManagementApi(object):
         :type move_orders_to_different_blocks_request: MoveOrdersToDifferentBlocksRequest
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :type _preload_content: bool, optional
-        :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.
+        :param _request_timeout: timeout setting for this request.
+               If one number provided, it will be total request
+               timeout. It can also be a pair (tuple) of
+               (connection, read) timeouts.
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
         :rtype: ResourceListOfMovedOrderToDifferentBlockResponse
         """
         kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the move_orders_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
         return self.move_orders_with_http_info(move_orders_to_different_blocks_request, **kwargs)  # noqa: E501
 
-    def move_orders_with_http_info(self, move_orders_to_different_blocks_request, **kwargs):  # noqa: E501
+    @validate_arguments
+    def move_orders_with_http_info(self, move_orders_to_different_blocks_request : Annotated[MoveOrdersToDifferentBlocksRequest, Field(..., description="The collection of order and destination block ids.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] MoveOrders: Move orders to new or existing block  # noqa: E501
 
         Move an order to a block, creating the block if it does not already exist.   This will fail if the block exists and already references orders with differing fields to the upsert request.  # noqa: E501
@@ -686,13 +434,14 @@ class OrderManagementApi(object):
         :type move_orders_to_different_blocks_request: MoveOrdersToDifferentBlocksRequest
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :type _return_http_data_only: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
         :type _preload_content: bool, optional
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
         :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
@@ -701,145 +450,156 @@ class OrderManagementApi(object):
                               request; this effectively ignores the authentication
                               in the spec for a single request.
         :type _request_auth: dict, optional
-        :return: Returns the result object, the HTTP status code, and the headers.
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: (ResourceListOfMovedOrderToDifferentBlockResponse, int, HTTPHeaderDict)
+        :rtype: tuple(ResourceListOfMovedOrderToDifferentBlockResponse, status_code(int), headers(HTTPHeaderDict))
         """
 
-        local_var_params = locals()
+        _params = locals()
 
-        all_params = [
+        _all_params = [
             'move_orders_to_different_blocks_request'
         ]
-        all_params.extend(
+        _all_params.extend(
             [
                 'async_req',
                 '_return_http_data_only',
                 '_preload_content',
                 '_request_timeout',
                 '_request_auth',
+                '_content_type',
                 '_headers'
             ]
         )
 
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method move_orders" % key
+                    " to method move_orders" % _key
                 )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'move_orders_to_different_blocks_request' is set
-        if self.api_client.client_side_validation and ('move_orders_to_different_blocks_request' not in local_var_params or  # noqa: E501
-                                                        local_var_params['move_orders_to_different_blocks_request'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `move_orders_to_different_blocks_request` when calling `move_orders`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-
-        query_params = []
-
-        header_params = dict(local_var_params.get('_headers', {}))
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        if 'move_orders_to_different_blocks_request' in local_var_params:
-            body_params = local_var_params['move_orders_to_different_blocks_request']
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+
+        # process the query parameters
+        _query_params = []
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params['move_orders_to_different_blocks_request'] is not None:
+            _body_params = _params['move_orders_to_different_blocks_request']
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
             ['text/plain', 'application/json', 'text/json'])  # noqa: E501
 
-        header_params['Accept-Encoding'] = "gzip, deflate, br"
-
-        # HTTP header `Content-Type`
-        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
-            ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json'])  # noqa: E501
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get('_content_type',
+            self.api_client.select_header_content_type(
+                ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json']))
+        if _content_types_list:
+                _header_params['Content-Type'] = _content_types_list
 
-        # set the LUSID header
-        header_params['X-LUSID-SDK-Language'] = 'Python'
-        header_params['X-LUSID-SDK-Version'] = '1.1.257'
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
 
-        # Authentication setting
-        auth_settings = ['oauth2']  # noqa: E501
-
-        response_types_map = {
-            200: "ResourceListOfMovedOrderToDifferentBlockResponse",
-            400: "LusidValidationProblemDetails",
+        _response_types_map = {
+            '200': "ResourceListOfMovedOrderToDifferentBlockResponse",
+            '400': "LusidValidationProblemDetails",
         }
 
         return self.api_client.call_api(
             '/api/ordermanagement/moveorders', 'POST',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_types_map=response_types_map,
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats,
-            _request_auth=local_var_params.get('_request_auth'))
-
-    def place_blocks(self, **kwargs):  # noqa: E501
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
+    @overload
+    async def place_blocks(self, place_blocks_request : Annotated[Optional[PlaceBlocksRequest], Field(description="The request containing the blocks to the placed.")] = None, **kwargs) -> ResourceListOfPlacement:  # noqa: E501
+        ...
+
+    @overload
+    def place_blocks(self, place_blocks_request : Annotated[Optional[PlaceBlocksRequest], Field(description="The request containing the blocks to the placed.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfPlacement:  # noqa: E501
+        ...
+
+    @validate_arguments
+    def place_blocks(self, place_blocks_request : Annotated[Optional[PlaceBlocksRequest], Field(description="The request containing the blocks to the placed.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfPlacement, Awaitable[ResourceListOfPlacement]]:  # noqa: E501
         """[EARLY ACCESS] PlaceBlocks: Places blocks for a given list of placement requests.  # noqa: E501
 
         The referenced block's existence will be verified.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.place_blocks(async_req=True)
+        >>> thread = api.place_blocks(place_blocks_request, async_req=True)
         >>> result = thread.get()
 
         :param place_blocks_request: The request containing the blocks to the placed.
         :type place_blocks_request: PlaceBlocksRequest
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :type _preload_content: bool, optional
-        :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.
+        :param _request_timeout: timeout setting for this request.
+               If one number provided, it will be total request
+               timeout. It can also be a pair (tuple) of
+               (connection, read) timeouts.
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
         :rtype: ResourceListOfPlacement
         """
         kwargs['_return_http_data_only'] = True
-        return self.place_blocks_with_http_info(**kwargs)  # noqa: E501
-
-    def place_blocks_with_http_info(self, **kwargs):  # noqa: E501
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the place_blocks_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
+        return self.place_blocks_with_http_info(place_blocks_request, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def place_blocks_with_http_info(self, place_blocks_request : Annotated[Optional[PlaceBlocksRequest], Field(description="The request containing the blocks to the placed.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] PlaceBlocks: Places blocks for a given list of placement requests.  # noqa: E501
 
         The referenced block's existence will be verified.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.place_blocks_with_http_info(async_req=True)
+        >>> thread = api.place_blocks_with_http_info(place_blocks_request, async_req=True)
         >>> result = thread.get()
 
         :param place_blocks_request: The request containing the blocks to the placed.
         :type place_blocks_request: PlaceBlocksRequest
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :type _return_http_data_only: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
         :type _preload_content: bool, optional
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
         :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
@@ -848,288 +608,160 @@ class OrderManagementApi(object):
                               request; this effectively ignores the authentication
                               in the spec for a single request.
         :type _request_auth: dict, optional
-        :return: Returns the result object, the HTTP status code, and the headers.
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: (ResourceListOfPlacement, int, HTTPHeaderDict)
+        :rtype: tuple(ResourceListOfPlacement, status_code(int), headers(HTTPHeaderDict))
         """
 
-        local_var_params = locals()
+        _params = locals()
 
-        all_params = [
+        _all_params = [
             'place_blocks_request'
         ]
-        all_params.extend(
+        _all_params.extend(
             [
                 'async_req',
                 '_return_http_data_only',
                 '_preload_content',
                 '_request_timeout',
                 '_request_auth',
+                '_content_type',
                 '_headers'
             ]
         )
 
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method place_blocks" % key
+                    " to method place_blocks" % _key
                 )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-
-        collection_formats = {}
-
-        path_params = {}
-
-        query_params = []
-
-        header_params = dict(local_var_params.get('_headers', {}))
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        if 'place_blocks_request' in local_var_params:
-            body_params = local_var_params['place_blocks_request']
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+
+        # process the query parameters
+        _query_params = []
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params['place_blocks_request'] is not None:
+            _body_params = _params['place_blocks_request']
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
             ['text/plain', 'application/json', 'text/json'])  # noqa: E501
 
-        header_params['Accept-Encoding'] = "gzip, deflate, br"
-
-        # HTTP header `Content-Type`
-        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
-            ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json'])  # noqa: E501
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get('_content_type',
+            self.api_client.select_header_content_type(
+                ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json']))
+        if _content_types_list:
+                _header_params['Content-Type'] = _content_types_list
 
-        # set the LUSID header
-        header_params['X-LUSID-SDK-Language'] = 'Python'
-        header_params['X-LUSID-SDK-Version'] = '1.1.257'
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
 
-        # Authentication setting
-        auth_settings = ['oauth2']  # noqa: E501
-
-        response_types_map = {
-            200: "ResourceListOfPlacement",
-            400: "LusidValidationProblemDetails",
+        _response_types_map = {
+            '200': "ResourceListOfPlacement",
+            '400': "LusidValidationProblemDetails",
         }
 
         return self.api_client.call_api(
             '/api/ordermanagement/placeblocks', 'POST',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_types_map=response_types_map,
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats,
-            _request_auth=local_var_params.get('_request_auth'))
-
-    def update_orders(self, request_body, **kwargs):  # noqa: E501
-        """[EARLY ACCESS] UpdateOrders: Update existing orders  # noqa: E501
-
-        The response returns both the collection of successfully updated orders, as well as those  that failed. For each failure, a reason is provided. It is important to check the failed set for  unsuccessful results.  # noqa: E501
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
+    @overload
+    async def run_allocation_service(self, resource_id : Annotated[conlist(ResourceId, max_items=100), Field(..., description="The List of Placement IDs for which you wish to allocate executions.")], allocation_algorithm : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="A string representation of the allocation algorithm you would like to use to allocate shares from executions e.g. \"PR-FIFO\".  This defaults to \"PR-FIFO\".")] = None, **kwargs) -> AllocationServiceRunResponse:  # noqa: E501
+        ...
+
+    @overload
+    def run_allocation_service(self, resource_id : Annotated[conlist(ResourceId, max_items=100), Field(..., description="The List of Placement IDs for which you wish to allocate executions.")], allocation_algorithm : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="A string representation of the allocation algorithm you would like to use to allocate shares from executions e.g. \"PR-FIFO\".  This defaults to \"PR-FIFO\".")] = None, async_req: Optional[bool]=True, **kwargs) -> AllocationServiceRunResponse:  # noqa: E501
+        ...
+
+    @validate_arguments
+    def run_allocation_service(self, resource_id : Annotated[conlist(ResourceId, max_items=100), Field(..., description="The List of Placement IDs for which you wish to allocate executions.")], allocation_algorithm : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="A string representation of the allocation algorithm you would like to use to allocate shares from executions e.g. \"PR-FIFO\".  This defaults to \"PR-FIFO\".")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[AllocationServiceRunResponse, Awaitable[AllocationServiceRunResponse]]:  # noqa: E501
+        """[EXPERIMENTAL] RunAllocationService: Runs the Allocation Service  # noqa: E501
+
+        This will allocate executions for a given list of placements back to their originating orders.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.update_orders(request_body, async_req=True)
+        >>> thread = api.run_allocation_service(resource_id, allocation_algorithm, async_req=True)
         >>> result = thread.get()
 
-        :param request_body: The request containing the orders to be updated. (required)
-        :type request_body: dict(str, OrderUpdateRequest)
+        :param resource_id: The List of Placement IDs for which you wish to allocate executions. (required)
+        :type resource_id: List[ResourceId]
+        :param allocation_algorithm: A string representation of the allocation algorithm you would like to use to allocate shares from executions e.g. \"PR-FIFO\".  This defaults to \"PR-FIFO\".
+        :type allocation_algorithm: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :type _preload_content: bool, optional
-        :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.
+        :param _request_timeout: timeout setting for this request.
+               If one number provided, it will be total request
+               timeout. It can also be a pair (tuple) of
+               (connection, read) timeouts.
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: UpdateOrdersResponse
+        :rtype: AllocationServiceRunResponse
         """
         kwargs['_return_http_data_only'] = True
-        return self.update_orders_with_http_info(request_body, **kwargs)  # noqa: E501
-
-    def update_orders_with_http_info(self, request_body, **kwargs):  # noqa: E501
-        """[EARLY ACCESS] UpdateOrders: Update existing orders  # noqa: E501
-
-        The response returns both the collection of successfully updated orders, as well as those  that failed. For each failure, a reason is provided. It is important to check the failed set for  unsuccessful results.  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-
-        >>> thread = api.update_orders_with_http_info(request_body, async_req=True)
-        >>> result = thread.get()
-
-        :param request_body: The request containing the orders to be updated. (required)
-        :type request_body: dict(str, OrderUpdateRequest)
-        :param async_req: Whether to execute the request asynchronously.
-        :type async_req: bool, optional
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :type _return_http_data_only: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :type _preload_content: bool, optional
-        :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.
-        :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
-        :return: Returns the result object, the HTTP status code, and the headers.
-                 If the method is called asynchronously,
-                 returns the request thread.
-        :rtype: (UpdateOrdersResponse, int, HTTPHeaderDict)
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'request_body'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout',
-                '_request_auth',
-                '_headers'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method update_orders" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'request_body' is set
-        if self.api_client.client_side_validation and ('request_body' not in local_var_params or  # noqa: E501
-                                                        local_var_params['request_body'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `request_body` when calling `update_orders`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-
-        query_params = []
-
-        header_params = dict(local_var_params.get('_headers', {}))
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        if 'request_body' in local_var_params:
-            body_params = local_var_params['request_body']
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
-            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
-
-        header_params['Accept-Encoding'] = "gzip, deflate, br"
-
-        # HTTP header `Content-Type`
-        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
-            ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json'])  # noqa: E501
-
-        # set the LUSID header
-        header_params['X-LUSID-SDK-Language'] = 'Python'
-        header_params['X-LUSID-SDK-Version'] = '1.1.257'
-
-        # Authentication setting
-        auth_settings = ['oauth2']  # noqa: E501
-
-        response_types_map = {
-            200: "UpdateOrdersResponse",
-            400: "LusidValidationProblemDetails",
-        }
-
-        return self.api_client.call_api(
-            '/api/ordermanagement/updateorders', 'POST',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_types_map=response_types_map,
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats,
-            _request_auth=local_var_params.get('_request_auth'))
-
-    def update_placements(self, request_body, **kwargs):  # noqa: E501
-        """[EARLY ACCESS] UpdatePlacements: Update existing placements  # noqa: E501
-
-        The response returns both the collection of successfully updated placements, as well as those  that failed. For each failure, a reason is provided. It is important to check the failed set for  unsuccessful results.  # noqa: E501
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the run_allocation_service_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
+        return self.run_allocation_service_with_http_info(resource_id, allocation_algorithm, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def run_allocation_service_with_http_info(self, resource_id : Annotated[conlist(ResourceId, max_items=100), Field(..., description="The List of Placement IDs for which you wish to allocate executions.")], allocation_algorithm : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="A string representation of the allocation algorithm you would like to use to allocate shares from executions e.g. \"PR-FIFO\".  This defaults to \"PR-FIFO\".")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+        """[EXPERIMENTAL] RunAllocationService: Runs the Allocation Service  # noqa: E501
+
+        This will allocate executions for a given list of placements back to their originating orders.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.update_placements(request_body, async_req=True)
+        >>> thread = api.run_allocation_service_with_http_info(resource_id, allocation_algorithm, async_req=True)
         >>> result = thread.get()
 
-        :param request_body: The request containing the placements to be updated. (required)
-        :type request_body: dict(str, PlacementUpdateRequest)
+        :param resource_id: The List of Placement IDs for which you wish to allocate executions. (required)
+        :type resource_id: List[ResourceId]
+        :param allocation_algorithm: A string representation of the allocation algorithm you would like to use to allocate shares from executions e.g. \"PR-FIFO\".  This defaults to \"PR-FIFO\".
+        :type allocation_algorithm: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
         :type _preload_content: bool, optional
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: Returns the result object.
-                 If the method is called asynchronously,
-                 returns the request thread.
-        :rtype: UpdatePlacementsResponse
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.update_placements_with_http_info(request_body, **kwargs)  # noqa: E501
-
-    def update_placements_with_http_info(self, request_body, **kwargs):  # noqa: E501
-        """[EARLY ACCESS] UpdatePlacements: Update existing placements  # noqa: E501
-
-        The response returns both the collection of successfully updated placements, as well as those  that failed. For each failure, a reason is provided. It is important to check the failed set for  unsuccessful results.  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-
-        >>> thread = api.update_placements_with_http_info(request_body, async_req=True)
-        >>> result = thread.get()
-
-        :param request_body: The request containing the placements to be updated. (required)
-        :type request_body: dict(str, PlacementUpdateRequest)
-        :param async_req: Whether to execute the request asynchronously.
-        :type async_req: bool, optional
-        :param _return_http_data_only: response data without head status code
-                                       and headers
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
         :type _return_http_data_only: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :type _preload_content: bool, optional
         :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
@@ -1138,90 +770,93 @@ class OrderManagementApi(object):
                               request; this effectively ignores the authentication
                               in the spec for a single request.
         :type _request_auth: dict, optional
-        :return: Returns the result object, the HTTP status code, and the headers.
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: (UpdatePlacementsResponse, int, HTTPHeaderDict)
+        :rtype: tuple(AllocationServiceRunResponse, status_code(int), headers(HTTPHeaderDict))
         """
 
-        local_var_params = locals()
+        _params = locals()
 
-        all_params = [
-            'request_body'
+        _all_params = [
+            'resource_id',
+            'allocation_algorithm'
         ]
-        all_params.extend(
+        _all_params.extend(
             [
                 'async_req',
                 '_return_http_data_only',
                 '_preload_content',
                 '_request_timeout',
                 '_request_auth',
+                '_content_type',
                 '_headers'
             ]
         )
 
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method update_placements" % key
+                    " to method run_allocation_service" % _key
                 )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'request_body' is set
-        if self.api_client.client_side_validation and ('request_body' not in local_var_params or  # noqa: E501
-                                                        local_var_params['request_body'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `request_body` when calling `update_placements`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-
-        query_params = []
-
-        header_params = dict(local_var_params.get('_headers', {}))
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        if 'request_body' in local_var_params:
-            body_params = local_var_params['request_body']
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+
+        # process the query parameters
+        _query_params = []
+        if _params.get('allocation_algorithm') is not None:  # noqa: E501
+            _query_params.append(('allocationAlgorithm', _params['allocation_algorithm']))
+
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params['resource_id'] is not None:
+            _body_params = _params['resource_id']
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
             ['text/plain', 'application/json', 'text/json'])  # noqa: E501
 
-        header_params['Accept-Encoding'] = "gzip, deflate, br"
-
-        # HTTP header `Content-Type`
-        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
-            ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json'])  # noqa: E501
-
-        # set the LUSID header
-        header_params['X-LUSID-SDK-Language'] = 'Python'
-        header_params['X-LUSID-SDK-Version'] = '1.1.257'
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get('_content_type',
+            self.api_client.select_header_content_type(
+                ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json']))
+        if _content_types_list:
+                _header_params['Content-Type'] = _content_types_list
 
-        # Authentication setting
-        auth_settings = ['oauth2']  # noqa: E501
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
 
-        response_types_map = {
-            200: "UpdatePlacementsResponse",
-            400: "LusidValidationProblemDetails",
+        _response_types_map = {
+            '200': "AllocationServiceRunResponse",
+            '400': "LusidValidationProblemDetails",
         }
 
         return self.api_client.call_api(
-            '/api/ordermanagement/$updateplacements', 'POST',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_types_map=response_types_map,
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats,
-            _request_auth=local_var_params.get('_request_auth'))
+            '/api/ordermanagement/allocate', 'POST',
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))