lusid-sdk 2.1.790__py3-none-any.whl → 2.1.792__py3-none-any.whl

lusid/__init__.py

@@ -652,6 +652,7 @@ from lusid.models.investor_record import InvestorRecord
 from lusid.models.ir_vol_cube_data import IrVolCubeData
 from lusid.models.ir_vol_dependency import IrVolDependency
 from lusid.models.is_business_day_response import IsBusinessDayResponse
+from lusid.models.item_and_workspace import ItemAndWorkspace
 from lusid.models.journal_entry_line import JournalEntryLine
 from lusid.models.journal_entry_line_share_class_breakdown import JournalEntryLineShareClassBreakdown
 from lusid.models.journal_entry_lines_query_parameters import JournalEntryLinesQueryParameters
@@ -802,6 +803,7 @@ from lusid.models.paged_resource_list_of_identifier_definition import PagedResou
 from lusid.models.paged_resource_list_of_instrument import PagedResourceListOfInstrument
 from lusid.models.paged_resource_list_of_instrument_event_holder import PagedResourceListOfInstrumentEventHolder
 from lusid.models.paged_resource_list_of_instrument_event_instruction import PagedResourceListOfInstrumentEventInstruction
+from lusid.models.paged_resource_list_of_item_and_workspace import PagedResourceListOfItemAndWorkspace
 from lusid.models.paged_resource_list_of_legal_entity import PagedResourceListOfLegalEntity
 from lusid.models.paged_resource_list_of_order import PagedResourceListOfOrder
 from lusid.models.paged_resource_list_of_order_graph_block import PagedResourceListOfOrderGraphBlock
@@ -1958,6 +1960,7 @@ __all__ = [
     "IrVolCubeData",
     "IrVolDependency",
     "IsBusinessDayResponse",
+    "ItemAndWorkspace",
     "JournalEntryLine",
     "JournalEntryLineShareClassBreakdown",
     "JournalEntryLinesQueryParameters",
@@ -2108,6 +2111,7 @@ __all__ = [
     "PagedResourceListOfInstrument",
     "PagedResourceListOfInstrumentEventHolder",
     "PagedResourceListOfInstrumentEventInstruction",
+    "PagedResourceListOfItemAndWorkspace",
     "PagedResourceListOfLegalEntity",
     "PagedResourceListOfOrder",
     "PagedResourceListOfOrderGraphBlock",

lusid/api/investor_records_api.py

@@ -26,6 +26,7 @@ from pydantic.v1 import Field, StrictStr, conlist, constr, validator
 
 from typing import Dict, Optional
 
+from lusid.models.deleted_entity_response import DeletedEntityResponse
 from lusid.models.investor_record import InvestorRecord
 from lusid.models.upsert_investor_record_request import UpsertInvestorRecordRequest
 from lusid.models.upsert_investor_records_response import UpsertInvestorRecordsResponse
@@ -56,6 +57,174 @@ class InvestorRecordsApi:
         self.api_client = api_client
 
 
+    @overload
+    async def delete_investor_record(self, id_type_scope : Annotated[StrictStr, Field(..., description="The scope of the investor record identifier type.")], id_type_code : Annotated[StrictStr, Field(..., description="The code of the investor record identifier type.")], code : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code. This together with defined              identifier type uniquely identifies the investor record to delete.")], **kwargs) -> DeletedEntityResponse:  # noqa: E501
+        ...
+
+    @overload
+    def delete_investor_record(self, id_type_scope : Annotated[StrictStr, Field(..., description="The scope of the investor record identifier type.")], id_type_code : Annotated[StrictStr, Field(..., description="The code of the investor record identifier type.")], code : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code. This together with defined              identifier type uniquely identifies the investor record to delete.")], async_req: Optional[bool]=True, **kwargs) -> DeletedEntityResponse:  # noqa: E501
+        ...
+
+    @validate_arguments
+    def delete_investor_record(self, id_type_scope : Annotated[StrictStr, Field(..., description="The scope of the investor record identifier type.")], id_type_code : Annotated[StrictStr, Field(..., description="The code of the investor record identifier type.")], code : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code. This together with defined              identifier type uniquely identifies the investor record to delete.")], async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
+        """DeleteInvestorRecord: Delete Investor Record  # noqa: E501
+
+        Delete an investor record. Deletion will be valid from the investor record's creation datetime.  This means that the investor record will no longer exist at any effective datetime from the asAt datetime of deletion.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.delete_investor_record(id_type_scope, id_type_code, code, async_req=True)
+        >>> result = thread.get()
+
+        :param id_type_scope: The scope of the investor record identifier type. (required)
+        :type id_type_scope: str
+        :param id_type_code: The code of the investor record identifier type. (required)
+        :type id_type_code: str
+        :param code: Code of the investor record under specified identifier type's scope and code. This together with defined              identifier type uniquely identifies the investor record to delete. (required)
+        :type code: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: DeletedEntityResponse
+        """
+        kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the delete_investor_record_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.delete_investor_record_with_http_info(id_type_scope, id_type_code, code, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def delete_investor_record_with_http_info(self, id_type_scope : Annotated[StrictStr, Field(..., description="The scope of the investor record identifier type.")], id_type_code : Annotated[StrictStr, Field(..., description="The code of the investor record identifier type.")], code : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code. This together with defined              identifier type uniquely identifies the investor record to delete.")], **kwargs) -> ApiResponse:  # noqa: E501
+        """DeleteInvestorRecord: Delete Investor Record  # noqa: E501
+
+        Delete an investor record. Deletion will be valid from the investor record's creation datetime.  This means that the investor record will no longer exist at any effective datetime from the asAt datetime of deletion.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.delete_investor_record_with_http_info(id_type_scope, id_type_code, code, async_req=True)
+        >>> result = thread.get()
+
+        :param id_type_scope: The scope of the investor record identifier type. (required)
+        :type id_type_scope: str
+        :param id_type_code: The code of the investor record identifier type. (required)
+        :type id_type_code: str
+        :param code: Code of the investor record under specified identifier type's scope and code. This together with defined              identifier type uniquely identifies the investor record to delete. (required)
+        :type code: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :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. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, 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
+        :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: tuple(DeletedEntityResponse, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = [
+            'id_type_scope',
+            'id_type_code',
+            'code'
+        ]
+        _all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout',
+                '_request_auth',
+                '_content_type',
+                '_headers',
+                'opts'
+            ]
+        )
+
+        # 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 delete_investor_record" % _key
+                )
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params['id_type_scope']:
+            _path_params['idTypeScope'] = _params['id_type_scope']
+
+        if _params['id_type_code']:
+            _path_params['idTypeCode'] = _params['id_type_code']
+
+        if _params['code']:
+            _path_params['code'] = _params['code']
+
+
+        # 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
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
+
+        _response_types_map = {
+            '200': "DeletedEntityResponse",
+            '400': "LusidValidationProblemDetails",
+        }
+
+        return self.api_client.call_api(
+            '/api/investorrecords/{idTypeScope}/{idTypeCode}/{code}', 'DELETE',
+            _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'),
+            opts=_params.get('opts'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
+
     @overload
     async def get_investor_record(self, id_type_scope : Annotated[StrictStr, Field(..., description="Scope of the investor record identifier type.")], id_type_code : Annotated[StrictStr, Field(..., description="Code of the investor record identifier type.")], code : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code. This together with stated identifier type uniquely              identifies the investor record.")], property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys or identifier types (as property keys) from the \"InvestorRecord\" domain              to include for found investor record, or from any domain that supports relationships to decorate onto related entities.              These take the format {domain}/{scope}/{code} e.g. \"InvestorRecord/ContactDetails/Address\".")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the investor record. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the investor record. Defaults to return the latest version of the investor record if not specified.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the investor record in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> InvestorRecord:  # noqa: E501
         ...

lusid/api/order_management_api.py

@@ -75,22 +75,22 @@ class OrderManagementApi:
 
 
     @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, mark_orders_and_allocations_as_booked : Annotated[Optional[StrictBool], Field(description="Whether to mark allocations and fully-booked orders with state Booked")] = None, use_preview_transactions_for_pricing : Annotated[Optional[StrictBool], Field(description="Whether to use calculators for the transaction type to work out pricing fields on the booked transactions")] = None, **kwargs) -> BookTransactionsResponse:  # noqa: E501
+    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, mark_orders_and_allocations_as_booked : Annotated[Optional[StrictBool], Field(description="Whether to mark allocations and fully-booked orders with state Booked")] = None, **kwargs) -> BookTransactionsResponse:  # noqa: E501
         ...
 
     @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, mark_orders_and_allocations_as_booked : Annotated[Optional[StrictBool], Field(description="Whether to mark allocations and fully-booked orders with state Booked")] = None, use_preview_transactions_for_pricing : Annotated[Optional[StrictBool], Field(description="Whether to use calculators for the transaction type to work out pricing fields on the booked transactions")] = None, async_req: Optional[bool]=True, **kwargs) -> BookTransactionsResponse:  # noqa: E501
+    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, mark_orders_and_allocations_as_booked : Annotated[Optional[StrictBool], Field(description="Whether to mark allocations and fully-booked orders with state Booked")] = None, async_req: Optional[bool]=True, **kwargs) -> BookTransactionsResponse:  # noqa: E501
         ...
 
     @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, mark_orders_and_allocations_as_booked : Annotated[Optional[StrictBool], Field(description="Whether to mark allocations and fully-booked orders with state Booked")] = None, use_preview_transactions_for_pricing : Annotated[Optional[StrictBool], Field(description="Whether to use calculators for the transaction type to work out pricing fields on the booked transactions")] = 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
+    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, mark_orders_and_allocations_as_booked : Annotated[Optional[StrictBool], Field(description="Whether to mark allocations and fully-booked orders with state Booked")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BookTransactionsResponse, Awaitable[BookTransactionsResponse]]:  # noqa: E501
+        """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.book_transactions(book_transactions_request, apply_fees_and_commission, mark_orders_and_allocations_as_booked, use_preview_transactions_for_pricing, async_req=True)
+        >>> thread = api.book_transactions(book_transactions_request, apply_fees_and_commission, mark_orders_and_allocations_as_booked, async_req=True)
         >>> result = thread.get()
 
         :param book_transactions_request: The allocations to create transactions for (required)
@@ -99,8 +99,6 @@ class OrderManagementApi:
         :type apply_fees_and_commission: bool
         :param mark_orders_and_allocations_as_booked: Whether to mark allocations and fully-booked orders with state Booked
         :type mark_orders_and_allocations_as_booked: bool
-        :param use_preview_transactions_for_pricing: Whether to use calculators for the transaction type to work out pricing fields on the booked transactions
-        :type use_preview_transactions_for_pricing: bool
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
@@ -117,17 +115,17 @@ class OrderManagementApi:
             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, mark_orders_and_allocations_as_booked, use_preview_transactions_for_pricing, **kwargs)  # noqa: E501
+        return self.book_transactions_with_http_info(book_transactions_request, apply_fees_and_commission, mark_orders_and_allocations_as_booked, **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, mark_orders_and_allocations_as_booked : Annotated[Optional[StrictBool], Field(description="Whether to mark allocations and fully-booked orders with state Booked")] = None, use_preview_transactions_for_pricing : Annotated[Optional[StrictBool], Field(description="Whether to use calculators for the transaction type to work out pricing fields on the booked transactions")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] BookTransactions: Books transactions using specific allocations as a source.  # noqa: E501
+    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, mark_orders_and_allocations_as_booked : Annotated[Optional[StrictBool], Field(description="Whether to mark allocations and fully-booked orders with state Booked")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+        """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.book_transactions_with_http_info(book_transactions_request, apply_fees_and_commission, mark_orders_and_allocations_as_booked, use_preview_transactions_for_pricing, async_req=True)
+        >>> thread = api.book_transactions_with_http_info(book_transactions_request, apply_fees_and_commission, mark_orders_and_allocations_as_booked, async_req=True)
         >>> result = thread.get()
 
         :param book_transactions_request: The allocations to create transactions for (required)
@@ -136,8 +134,6 @@ class OrderManagementApi:
         :type apply_fees_and_commission: bool
         :param mark_orders_and_allocations_as_booked: Whether to mark allocations and fully-booked orders with state Booked
         :type mark_orders_and_allocations_as_booked: bool
-        :param use_preview_transactions_for_pricing: Whether to use calculators for the transaction type to work out pricing fields on the booked transactions
-        :type use_preview_transactions_for_pricing: bool
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -167,8 +163,7 @@ class OrderManagementApi:
         _all_params = [
             'book_transactions_request',
             'apply_fees_and_commission',
-            'mark_orders_and_allocations_as_booked',
-            'use_preview_transactions_for_pricing'
+            'mark_orders_and_allocations_as_booked'
         ]
         _all_params.extend(
             [
@@ -206,9 +201,6 @@ class OrderManagementApi:
         if _params.get('mark_orders_and_allocations_as_booked') is not None:  # noqa: E501
             _query_params.append(('markOrdersAndAllocationsAsBooked', _params['mark_orders_and_allocations_as_booked']))
 
-        if _params.get('use_preview_transactions_for_pricing') is not None:  # noqa: E501
-            _query_params.append(('usePreviewTransactionsForPricing', _params['use_preview_transactions_for_pricing']))
-
         # process the header parameters
         _header_params = dict(_params.get('_headers', {}))
         # process the form parameters
@@ -744,9 +736,9 @@ class OrderManagementApi:
 
     @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
+        """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
+        Create orders, and blocks if they don't already exist.  This will fail if the block exists and already references orders with differing blocking fields.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -775,9 +767,9 @@ class OrderManagementApi:
 
     @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
+        """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
+        Create orders, and blocks if they don't already exist.  This will fail if the block exists and already references orders with differing blocking fields.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -903,7 +895,7 @@ class OrderManagementApi:
 
     @validate_arguments
     def get_order_history(self, scope : Annotated[StrictStr, Field(..., description="The scope of the order.")], code : Annotated[StrictStr, Field(..., description="The code of the order.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the history of the order and related entities. Defaults              to return the latest version if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfChangeIntervalWithOrderManagementDetail, Awaitable[ResourceListOfChangeIntervalWithOrderManagementDetail]]:  # noqa: E501
-        """[EXPERIMENTAL] GetOrderHistory: Get the history of an order and related entity changes  # noqa: E501
+        """GetOrderHistory: Get the history of an order and related entity changes  # noqa: E501
 
         Get the changes that have happened to an order and related entities.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -938,7 +930,7 @@ class OrderManagementApi:
 
     @validate_arguments
     def get_order_history_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the order.")], code : Annotated[StrictStr, Field(..., description="The code of the order.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the history of the order and related entities. Defaults              to return the latest version if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] GetOrderHistory: Get the history of an order and related entity changes  # noqa: E501
+        """GetOrderHistory: Get the history of an order and related entity changes  # noqa: E501
 
         Get the changes that have happened to an order and related entities.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1384,25 +1376,25 @@ class OrderManagementApi:
 
 
     @overload
-    async def run_allocation_service(self, resource_id : Annotated[conlist(ResourceId), Field(..., description="The List of Placement IDs for which you wish to allocate executions.")], allocation_algorithm : Annotated[Optional[StrictStr], 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
+    async def run_allocation_service(self, resource_id : Annotated[conlist(ResourceId), Field(..., description="The List of Placement IDs for which you wish to allocate Executions.")], allocation_algorithm : Annotated[Optional[StrictStr], 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), Field(..., description="The List of Placement IDs for which you wish to allocate executions.")], allocation_algorithm : Annotated[Optional[StrictStr], 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
+    def run_allocation_service(self, resource_id : Annotated[conlist(ResourceId), Field(..., description="The List of Placement IDs for which you wish to allocate Executions.")], allocation_algorithm : Annotated[Optional[StrictStr], 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), Field(..., description="The List of Placement IDs for which you wish to allocate executions.")], allocation_algorithm : Annotated[Optional[StrictStr], 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
+    def run_allocation_service(self, resource_id : Annotated[conlist(ResourceId), Field(..., description="The List of Placement IDs for which you wish to allocate Executions.")], allocation_algorithm : Annotated[Optional[StrictStr], 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
+        """RunAllocationService: Runs the Allocation Service  # noqa: E501
 
-        This will allocate executions for a given list of placements back to their originating orders.  # noqa: E501
+        Allocates Executions for a given list of placements back to their originating orders using one of the LUSID algorithms, creating Allocations to record the 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.run_allocation_service(resource_id, allocation_algorithm, async_req=True)
         >>> result = thread.get()
 
-        :param resource_id: The List of Placement IDs for which you wish to allocate executions. (required)
+        :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
@@ -1425,17 +1417,17 @@ class OrderManagementApi:
         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), Field(..., description="The List of Placement IDs for which you wish to allocate executions.")], allocation_algorithm : Annotated[Optional[StrictStr], 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
+    def run_allocation_service_with_http_info(self, resource_id : Annotated[conlist(ResourceId), Field(..., description="The List of Placement IDs for which you wish to allocate Executions.")], allocation_algorithm : Annotated[Optional[StrictStr], 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
+        """RunAllocationService: Runs the Allocation Service  # noqa: E501
 
-        This will allocate executions for a given list of placements back to their originating orders.  # noqa: E501
+        Allocates Executions for a given list of placements back to their originating orders using one of the LUSID algorithms, creating Allocations to record the 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.run_allocation_service_with_http_info(resource_id, allocation_algorithm, async_req=True)
         >>> result = thread.get()
 
-        :param resource_id: The List of Placement IDs for which you wish to allocate executions. (required)
+        :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

lusid/api/workspace_api.py

@@ -27,6 +27,7 @@ from pydantic.v1 import Field, StrictStr, conint, conlist, constr, validator
 from typing import Optional
 
 from lusid.models.deleted_entity_response import DeletedEntityResponse
+from lusid.models.paged_resource_list_of_item_and_workspace import PagedResourceListOfItemAndWorkspace
 from lusid.models.paged_resource_list_of_workspace import PagedResourceListOfWorkspace
 from lusid.models.paged_resource_list_of_workspace_item import PagedResourceListOfWorkspaceItem
 from lusid.models.workspace import Workspace
@@ -1498,6 +1499,202 @@ class WorkspaceApi:
             _request_auth=_params.get('_request_auth'))
 
 
+    @overload
+    async def search_items(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> PagedResourceListOfItemAndWorkspace:  # noqa: E501
+        ...
+
+    @overload
+    def search_items(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfItemAndWorkspace:  # noqa: E501
+        ...
+
+    @validate_arguments
+    def search_items(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfItemAndWorkspace, Awaitable[PagedResourceListOfItemAndWorkspace]]:  # noqa: E501
+        """[EXPERIMENTAL] SearchItems: List items across all workspaces.  # noqa: E501
+
+        List items across all workspaces.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.search_items(visibility, as_at, page, sort_by, limit, filter, async_req=True)
+        >>> result = thread.get()
+
+        :param visibility: The visibility for the containing workspace. Must be `shared` or `personal`; case is important. (required)
+        :type visibility: str
+        :param as_at: The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.
+        :type as_at: datetime
+        :param page: The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.
+        :type page: str
+        :param sort_by: A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".
+        :type sort_by: List[str]
+        :param limit: When paginating, limit the number of returned results to this many.
+        :type limit: int
+        :param filter: Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.
+        :type filter: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: PagedResourceListOfItemAndWorkspace
+        """
+        kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the search_items_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.search_items_with_http_info(visibility, as_at, page, sort_by, limit, filter, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def search_items_with_http_info(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+        """[EXPERIMENTAL] SearchItems: List items across all workspaces.  # noqa: E501
+
+        List items across all workspaces.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.search_items_with_http_info(visibility, as_at, page, sort_by, limit, filter, async_req=True)
+        >>> result = thread.get()
+
+        :param visibility: The visibility for the containing workspace. Must be `shared` or `personal`; case is important. (required)
+        :type visibility: str
+        :param as_at: The asAt datetime at which to retrieve workspace items. Defaults to 'latest' if not specified.
+        :type as_at: datetime
+        :param page: The pagination token to use to continue listing workspaces items from a previous call to list workspaces items.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.
+        :type page: str
+        :param sort_by: A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".
+        :type sort_by: List[str]
+        :param limit: When paginating, limit the number of returned results to this many.
+        :type limit: int
+        :param filter: Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.
+        :type filter: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :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. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, 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
+        :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: tuple(PagedResourceListOfItemAndWorkspace, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = [
+            'visibility',
+            'as_at',
+            'page',
+            'sort_by',
+            'limit',
+            'filter'
+        ]
+        _all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout',
+                '_request_auth',
+                '_content_type',
+                '_headers',
+                'opts'
+            ]
+        )
+
+        # 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 search_items" % _key
+                )
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params['visibility']:
+            _path_params['visibility'] = _params['visibility']
+
+
+        # process the query parameters
+        _query_params = []
+        if _params.get('as_at') is not None:  # noqa: E501
+            if isinstance(_params['as_at'], datetime):
+                _query_params.append(('asAt', _params['as_at'].strftime(self.api_client.configuration.datetime_format)))
+            else:
+                _query_params.append(('asAt', _params['as_at']))
+
+        if _params.get('page') is not None:  # noqa: E501
+            _query_params.append(('page', _params['page']))
+
+        if _params.get('sort_by') is not None:  # noqa: E501
+            _query_params.append(('sortBy', _params['sort_by']))
+            _collection_formats['sortBy'] = 'multi'
+
+        if _params.get('limit') is not None:  # noqa: E501
+            _query_params.append(('limit', _params['limit']))
+
+        if _params.get('filter') is not None:  # noqa: E501
+            _query_params.append(('filter', _params['filter']))
+
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
+
+        _response_types_map = {
+            '200': "PagedResourceListOfItemAndWorkspace",
+            '400': "LusidValidationProblemDetails",
+        }
+
+        return self.api_client.call_api(
+            '/api/workspaces/{visibility}/items', 'GET',
+            _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'),
+            opts=_params.get('opts'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
+
     @overload
     async def update_item(self, visibility : Annotated[StrictStr, Field(..., description="The visibility for the containing workspace. Must be `shared` or `personal`; case is important.")], workspace_name : Annotated[StrictStr, Field(..., description="The workspace name.")], group_name : Annotated[StrictStr, Field(..., description="The group containing the item.")], item_name : Annotated[StrictStr, Field(..., description="The item name.")], workspace_item_update_request : Annotated[Optional[WorkspaceItemUpdateRequest], Field(description="The new item details.")] = None, **kwargs) -> WorkspaceItem:  # noqa: E501
         ...