lusid-sdk 2.1.912__py3-none-any.whl → 2.1.914__py3-none-any.whl

lusid/api/order_graph_api.py

@@ -67,7 +67,7 @@ class OrderGraphApi:
     def list_order_graph_blocks(self, as_at : Annotated[Optional[datetime], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01832/")] = None, pagination_token : Annotated[Optional[StrictStr], Field( description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, filter : Annotated[Optional[StrictStr], Field( description="See https://support.lusid.com/knowledgebase/article/KA-01914/")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="Must be block-level properties. See https://support.lusid.com/knowledgebase/article/KA-01855/")] = None, use_compliance_v2 : Annotated[Optional[StrictBool], Field(description="Whether to use the V2 compliance engine when deriving compliance statuses for orders. (default: false)")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfOrderGraphBlock, Awaitable[PagedResourceListOfOrderGraphBlock]]:  # noqa: E501
         """ListOrderGraphBlocks: Lists blocks that pass the filter provided, and builds a summary picture of the state of their associated order entities.  # noqa: E501
 
-        Lists all blocks of orders, subject to the filter, along with the IDs of orders, placements, allocations and executions in the block, the total quantities of each, and a simple text field describing the overall state.  # noqa: E501
+        Lists all blocks of orders, subject to the filter, along with the IDs of orders, placements, allocations and  executions in the block, the total quantities of each, and a simple text field describing the overall state.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -110,7 +110,7 @@ class OrderGraphApi:
     def list_order_graph_blocks_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01832/")] = None, pagination_token : Annotated[Optional[StrictStr], Field( description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, filter : Annotated[Optional[StrictStr], Field( description="See https://support.lusid.com/knowledgebase/article/KA-01914/")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="Must be block-level properties. See https://support.lusid.com/knowledgebase/article/KA-01855/")] = None, use_compliance_v2 : Annotated[Optional[StrictBool], Field(description="Whether to use the V2 compliance engine when deriving compliance statuses for orders. (default: false)")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """ListOrderGraphBlocks: Lists blocks that pass the filter provided, and builds a summary picture of the state of their associated order entities.  # noqa: E501
 
-        Lists all blocks of orders, subject to the filter, along with the IDs of orders, placements, allocations and executions in the block, the total quantities of each, and a simple text field describing the overall state.  # noqa: E501
+        Lists all blocks of orders, subject to the filter, along with the IDs of orders, placements, allocations and  executions in the block, the total quantities of each, and a simple text field describing the overall state.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -272,7 +272,7 @@ class OrderGraphApi:
     def list_order_graph_placement_children(self, scope : Annotated[StrictStr, Field(..., description="The parent placement's scope")], code : Annotated[StrictStr, Field(..., description="The parent placement's code")], as_at : Annotated[Optional[datetime], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01832/")] = None, pagination_token : Annotated[Optional[StrictStr], Field( description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="Order the results by these fields. Use use the '-' sign to denote descending order e.g. -MyFieldName.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="Must be placement properties. See https://support.lusid.com/knowledgebase/article/KA-01855/")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfOrderGraphPlacement, Awaitable[PagedResourceListOfOrderGraphPlacement]]:  # noqa: E501
         """[EARLY ACCESS] ListOrderGraphPlacementChildren: Lists all placements for the parent placement specified by the scope and code, and builds a summary picture of the state of their associated order entities.  # noqa: E501
 
-        Lists all child order placements, for the specified parent placement, along with the IDs of the block and order that the placement is for, each placement's quantity, the IDs of all allocations and executions in the placement and the total quantities of those, and a simple text field describing the overall state of the placement.  # noqa: E501
+        Lists all child order placements, for the specified parent placement, along with the IDs of the block and order that the  placement is for, each placement's quantity, the IDs of all allocations and executions in the placement  and the total quantities of those, and a simple text field describing the overall state of the placement.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -315,7 +315,7 @@ class OrderGraphApi:
     def list_order_graph_placement_children_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The parent placement's scope")], code : Annotated[StrictStr, Field(..., description="The parent placement's code")], as_at : Annotated[Optional[datetime], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01832/")] = None, pagination_token : Annotated[Optional[StrictStr], Field( description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="Order the results by these fields. Use use the '-' sign to denote descending order e.g. -MyFieldName.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="Must be placement properties. See https://support.lusid.com/knowledgebase/article/KA-01855/")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] ListOrderGraphPlacementChildren: Lists all placements for the parent placement specified by the scope and code, and builds a summary picture of the state of their associated order entities.  # noqa: E501
 
-        Lists all child order placements, for the specified parent placement, along with the IDs of the block and order that the placement is for, each placement's quantity, the IDs of all allocations and executions in the placement and the total quantities of those, and a simple text field describing the overall state of the placement.  # noqa: E501
+        Lists all child order placements, for the specified parent placement, along with the IDs of the block and order that the  placement is for, each placement's quantity, the IDs of all allocations and executions in the placement  and the total quantities of those, and a simple text field describing the overall state of the placement.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -477,7 +477,7 @@ class OrderGraphApi:
     def list_order_graph_placements(self, as_at : Annotated[Optional[datetime], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01832/")] = None, pagination_token : Annotated[Optional[StrictStr], Field( description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, filter : Annotated[Optional[StrictStr], Field( description="See https://support.lusid.com/knowledgebase/article/KA-01914/")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="Must be placement properties. See https://support.lusid.com/knowledgebase/article/KA-01855/")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfOrderGraphPlacement, Awaitable[PagedResourceListOfOrderGraphPlacement]]:  # noqa: E501
         """ListOrderGraphPlacements: Lists placements that pass the filter provided, and builds a summary picture of the state of their associated order entities.  # noqa: E501
 
-        Lists all order placements, subject to the filter, along with the IDs of the block and order that the placement is for, each placement's quantity, the IDs of all allocations and executions in the placement and the total quantities of those, and a simple text field describing the overall state of the placement.  # noqa: E501
+        Lists all order placements, subject to the filter, along with the IDs of the block and order that the  placement is for, each placement's quantity, the IDs of all allocations and executions in the placement  and the total quantities of those, and a simple text field describing the overall state of the placement.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -518,7 +518,7 @@ class OrderGraphApi:
     def list_order_graph_placements_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01832/")] = None, pagination_token : Annotated[Optional[StrictStr], Field( description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, filter : Annotated[Optional[StrictStr], Field( description="See https://support.lusid.com/knowledgebase/article/KA-01914/")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="Must be placement properties. See https://support.lusid.com/knowledgebase/article/KA-01855/")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """ListOrderGraphPlacements: Lists placements that pass the filter provided, and builds a summary picture of the state of their associated order entities.  # noqa: E501
 
-        Lists all order placements, subject to the filter, along with the IDs of the block and order that the placement is for, each placement's quantity, the IDs of all allocations and executions in the placement and the total quantities of those, and a simple text field describing the overall state of the placement.  # noqa: E501
+        Lists all order placements, subject to the filter, along with the IDs of the block and order that the  placement is for, each placement's quantity, the IDs of all allocations and executions in the placement  and the total quantities of those, and a simple text field describing the overall state of the placement.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 

lusid/api/order_instructions_api.py

@@ -70,7 +70,7 @@ class OrderInstructionsApi:
     def delete_order_instruction(self, scope : Annotated[StrictStr, Field(..., description="The orderInstruction scope.")], code : Annotated[StrictStr, Field(..., description="The orderInstruction's code. This, together with the scope uniquely identifies the orderInstruction to delete.")], async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
         """DeleteOrderInstruction: Delete orderInstruction  # noqa: E501
 
-        Delete an orderInstruction. Deletion will be valid from the orderInstruction's creation datetime. This means that the orderInstruction will no longer exist at any effective datetime from the asAt datetime of deletion.  # noqa: E501
+        Delete an orderInstruction. Deletion will be valid from the orderInstruction's creation datetime.  This means that the orderInstruction 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
 
@@ -103,7 +103,7 @@ class OrderInstructionsApi:
     def delete_order_instruction_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The orderInstruction scope.")], code : Annotated[StrictStr, Field(..., description="The orderInstruction's code. This, together with the scope uniquely identifies the orderInstruction to delete.")], **kwargs) -> ApiResponse:  # noqa: E501
         """DeleteOrderInstruction: Delete orderInstruction  # noqa: E501
 
-        Delete an orderInstruction. Deletion will be valid from the orderInstruction's creation datetime. This means that the orderInstruction will no longer exist at any effective datetime from the asAt datetime of deletion.  # noqa: E501
+        Delete an orderInstruction. Deletion will be valid from the orderInstruction's creation datetime.  This means that the orderInstruction 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
 
@@ -219,15 +219,15 @@ class OrderInstructionsApi:
 
 
     @overload
-    async def get_order_instruction(self, scope : Annotated[StrictStr, Field(..., description="The scope to which the orderInstruction belongs.")], code : Annotated[StrictStr, Field(..., description="The orderInstruction's unique identifier.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"OrderInstruction\" domain to decorate onto the orderInstruction.             These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".")] = None, **kwargs) -> OrderInstruction:  # noqa: E501
+    async def get_order_instruction(self, scope : Annotated[StrictStr, Field(..., description="The scope to which the orderInstruction belongs.")], code : Annotated[StrictStr, Field(..., description="The orderInstruction's unique identifier.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"OrderInstruction\" domain to decorate onto the orderInstruction.              These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".")] = None, **kwargs) -> OrderInstruction:  # noqa: E501
         ...
 
     @overload
-    def get_order_instruction(self, scope : Annotated[StrictStr, Field(..., description="The scope to which the orderInstruction belongs.")], code : Annotated[StrictStr, Field(..., description="The orderInstruction's unique identifier.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"OrderInstruction\" domain to decorate onto the orderInstruction.             These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".")] = None, async_req: Optional[bool]=True, **kwargs) -> OrderInstruction:  # noqa: E501
+    def get_order_instruction(self, scope : Annotated[StrictStr, Field(..., description="The scope to which the orderInstruction belongs.")], code : Annotated[StrictStr, Field(..., description="The orderInstruction's unique identifier.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"OrderInstruction\" domain to decorate onto the orderInstruction.              These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".")] = None, async_req: Optional[bool]=True, **kwargs) -> OrderInstruction:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_order_instruction(self, scope : Annotated[StrictStr, Field(..., description="The scope to which the orderInstruction belongs.")], code : Annotated[StrictStr, Field(..., description="The orderInstruction's unique identifier.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"OrderInstruction\" domain to decorate onto the orderInstruction.             These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[OrderInstruction, Awaitable[OrderInstruction]]:  # noqa: E501
+    def get_order_instruction(self, scope : Annotated[StrictStr, Field(..., description="The scope to which the orderInstruction belongs.")], code : Annotated[StrictStr, Field(..., description="The orderInstruction's unique identifier.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"OrderInstruction\" domain to decorate onto the orderInstruction.              These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[OrderInstruction, Awaitable[OrderInstruction]]:  # noqa: E501
         """GetOrderInstruction: Get OrderInstruction  # noqa: E501
 
         Fetch a OrderInstruction that matches the specified identifier  # noqa: E501
@@ -243,7 +243,7 @@ class OrderInstructionsApi:
         :type code: str
         :param as_at: The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.
         :type as_at: datetime
-        :param property_keys: A list of property keys from the \"OrderInstruction\" domain to decorate onto the orderInstruction.             These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".
+        :param property_keys: A list of property keys from the \"OrderInstruction\" domain to decorate onto the orderInstruction.              These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".
         :type property_keys: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -264,7 +264,7 @@ class OrderInstructionsApi:
         return self.get_order_instruction_with_http_info(scope, code, as_at, property_keys, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_order_instruction_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope to which the orderInstruction belongs.")], code : Annotated[StrictStr, Field(..., description="The orderInstruction's unique identifier.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"OrderInstruction\" domain to decorate onto the orderInstruction.             These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_order_instruction_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope to which the orderInstruction belongs.")], code : Annotated[StrictStr, Field(..., description="The orderInstruction's unique identifier.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"OrderInstruction\" domain to decorate onto the orderInstruction.              These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """GetOrderInstruction: Get OrderInstruction  # noqa: E501
 
         Fetch a OrderInstruction that matches the specified identifier  # noqa: E501
@@ -280,7 +280,7 @@ class OrderInstructionsApi:
         :type code: str
         :param as_at: The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.
         :type as_at: datetime
-        :param property_keys: A list of property keys from the \"OrderInstruction\" domain to decorate onto the orderInstruction.             These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".
+        :param property_keys: A list of property keys from the \"OrderInstruction\" domain to decorate onto the orderInstruction.              These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".
         :type property_keys: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -399,15 +399,15 @@ class OrderInstructionsApi:
 
 
     @overload
-    async def list_order_instructions(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing orderInstructions from a previous call to list orderInstructions.             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 or properties 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"OrderInstruction\" domain to decorate onto each orderInstruction.                 These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".                 All properties, except derived properties, are returned by default, without specifying here.")] = None, **kwargs) -> PagedResourceListOfOrderInstruction:  # noqa: E501
+    async def list_order_instructions(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing orderInstructions from a previous call to list orderInstructions.              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 or properties 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"OrderInstruction\" domain to decorate onto each orderInstruction.                  These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".                  All properties, except derived properties, are returned by default, without specifying here.")] = None, **kwargs) -> PagedResourceListOfOrderInstruction:  # noqa: E501
         ...
 
     @overload
-    def list_order_instructions(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing orderInstructions from a previous call to list orderInstructions.             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 or properties 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"OrderInstruction\" domain to decorate onto each orderInstruction.                 These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".                 All properties, except derived properties, are returned by default, without specifying here.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfOrderInstruction:  # noqa: E501
+    def list_order_instructions(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing orderInstructions from a previous call to list orderInstructions.              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 or properties 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"OrderInstruction\" domain to decorate onto each orderInstruction.                  These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".                  All properties, except derived properties, are returned by default, without specifying here.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfOrderInstruction:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_order_instructions(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing orderInstructions from a previous call to list orderInstructions.             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 or properties 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"OrderInstruction\" domain to decorate onto each orderInstruction.                 These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".                 All properties, except derived properties, are returned by default, without specifying here.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfOrderInstruction, Awaitable[PagedResourceListOfOrderInstruction]]:  # noqa: E501
+    def list_order_instructions(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing orderInstructions from a previous call to list orderInstructions.              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 or properties 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"OrderInstruction\" domain to decorate onto each orderInstruction.                  These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".                  All properties, except derived properties, are returned by default, without specifying here.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfOrderInstruction, Awaitable[PagedResourceListOfOrderInstruction]]:  # noqa: E501
         """ListOrderInstructions: List OrderInstructions  # noqa: E501
 
         Fetch the last pre-AsAt date version of each orderInstruction in scope (does not fetch the entire history).  # noqa: E501
@@ -419,15 +419,15 @@ class OrderInstructionsApi:
 
         :param as_at: The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.
         :type as_at: datetime
-        :param page: The pagination token to use to continue listing orderInstructions from a previous call to list orderInstructions.             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.
+        :param page: The pagination token to use to continue listing orderInstructions from a previous call to list orderInstructions.              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 or properties 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.
+        :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 property_keys: A list of property keys from the \"OrderInstruction\" domain to decorate onto each orderInstruction.                 These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".                 All properties, except derived properties, are returned by default, without specifying here.
+        :param property_keys: A list of property keys from the \"OrderInstruction\" domain to decorate onto each orderInstruction.                  These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".                  All properties, except derived properties, are returned by default, without specifying here.
         :type property_keys: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -448,7 +448,7 @@ class OrderInstructionsApi:
         return self.list_order_instructions_with_http_info(as_at, page, sort_by, limit, filter, property_keys, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_order_instructions_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing orderInstructions from a previous call to list orderInstructions.             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 or properties 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"OrderInstruction\" domain to decorate onto each orderInstruction.                 These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".                 All properties, except derived properties, are returned by default, without specifying here.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_order_instructions_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing orderInstructions from a previous call to list orderInstructions.              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 or properties 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"OrderInstruction\" domain to decorate onto each orderInstruction.                  These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".                  All properties, except derived properties, are returned by default, without specifying here.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """ListOrderInstructions: List OrderInstructions  # noqa: E501
 
         Fetch the last pre-AsAt date version of each orderInstruction in scope (does not fetch the entire history).  # noqa: E501
@@ -460,15 +460,15 @@ class OrderInstructionsApi:
 
         :param as_at: The asAt datetime at which to retrieve the orderInstruction. Defaults to return the latest version of the orderInstruction if not specified.
         :type as_at: datetime
-        :param page: The pagination token to use to continue listing orderInstructions from a previous call to list orderInstructions.             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.
+        :param page: The pagination token to use to continue listing orderInstructions from a previous call to list orderInstructions.              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 or properties 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.
+        :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 property_keys: A list of property keys from the \"OrderInstruction\" domain to decorate onto each orderInstruction.                 These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".                 All properties, except derived properties, are returned by default, without specifying here.
+        :param property_keys: A list of property keys from the \"OrderInstruction\" domain to decorate onto each orderInstruction.                  These take the format {domain}/{scope}/{code} e.g. \"OrderInstruction/system/Name\".                  All properties, except derived properties, are returned by default, without specifying here.
         :type property_keys: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional

lusid/api/order_management_api.py

@@ -261,7 +261,7 @@ class OrderManagementApi:
     def cancel_orders(self, request_body : Annotated[Dict[str, ResourceId], Field(..., description="The request containing the ids of the orders to be cancelled.")], async_req: Optional[bool]=None, **kwargs) -> Union[CancelOrdersResponse, Awaitable[CancelOrdersResponse]]:  # 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
+        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
 
@@ -292,7 +292,7 @@ class OrderManagementApi:
     def cancel_orders_with_http_info(self, request_body : Annotated[Dict[str, ResourceId], Field(..., description="The request containing the ids of the orders to be cancelled.")], **kwargs) -> ApiResponse:  # 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
+        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
 
@@ -420,7 +420,7 @@ class OrderManagementApi:
     def cancel_orders_and_move_remaining(self, request_body : Annotated[Dict[str, CancelOrdersAndMoveRemainingRequest], Field(..., description="The request containing the orders to be cancelled, and the destinations of remaining quantities.")], async_req: Optional[bool]=None, **kwargs) -> Union[CancelOrdersAndMoveRemainingResponse, Awaitable[CancelOrdersAndMoveRemainingResponse]]:  # 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
+        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
 
@@ -451,7 +451,7 @@ class OrderManagementApi:
     def cancel_orders_and_move_remaining_with_http_info(self, request_body : Annotated[Dict[str, CancelOrdersAndMoveRemainingRequest], Field(..., description="The request containing the orders to be cancelled, and the destinations of remaining quantities.")], **kwargs) -> ApiResponse:  # 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
+        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
 
@@ -579,7 +579,7 @@ class OrderManagementApi:
     def cancel_placements(self, request_body : Annotated[Dict[str, ResourceId], Field(..., description="The request containing the ids of the placements to be cancelled.")], async_req: Optional[bool]=None, **kwargs) -> Union[CancelPlacementsResponse, Awaitable[CancelPlacementsResponse]]:  # 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
+        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
 
@@ -610,7 +610,7 @@ class OrderManagementApi:
     def cancel_placements_with_http_info(self, request_body : Annotated[Dict[str, ResourceId], Field(..., description="The request containing the ids of the placements to be cancelled.")], **kwargs) -> ApiResponse:  # 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
+        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
 
@@ -738,7 +738,7 @@ class OrderManagementApi:
     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
         """CreateOrders: Upsert a Block and associated orders  # 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
+        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
 
@@ -769,7 +769,7 @@ class OrderManagementApi:
     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
         """CreateOrders: Upsert a Block and associated orders  # 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
+        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
 
@@ -886,15 +886,15 @@ class OrderManagementApi:
 
 
     @overload
-    async 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, **kwargs) -> ResourceListOfChangeIntervalWithOrderManagementDetail:  # noqa: E501
+    async 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, **kwargs) -> ResourceListOfChangeIntervalWithOrderManagementDetail:  # noqa: E501
         ...
 
     @overload
-    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]=True, **kwargs) -> ResourceListOfChangeIntervalWithOrderManagementDetail:  # noqa: E501
+    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]=True, **kwargs) -> ResourceListOfChangeIntervalWithOrderManagementDetail:  # noqa: E501
         ...
 
     @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
+    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
         """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
@@ -908,7 +908,7 @@ class OrderManagementApi:
         :type scope: str
         :param code: The code of the order. (required)
         :type code: str
-        :param as_at: The asAt datetime at which to retrieve the history of the order and related entities. Defaults             to return the latest version if not specified.
+        :param as_at: The asAt datetime at which to retrieve the history of the order and related entities. Defaults              to return the latest version if not specified.
         :type as_at: datetime
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -929,7 +929,7 @@ class OrderManagementApi:
         return self.get_order_history_with_http_info(scope, code, as_at, **kwargs)  # noqa: E501
 
     @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
+    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
         """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
@@ -943,7 +943,7 @@ class OrderManagementApi:
         :type scope: str
         :param code: The code of the order. (required)
         :type code: str
-        :param as_at: The asAt datetime at which to retrieve the history of the order and related entities. Defaults             to return the latest version if not specified.
+        :param as_at: The asAt datetime at which to retrieve the history of the order and related entities. Defaults              to return the latest version if not specified.
         :type as_at: datetime
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -1069,7 +1069,7 @@ class OrderManagementApi:
     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
+        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
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -1100,7 +1100,7 @@ class OrderManagementApi:
     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
+        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
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -1376,15 +1376,15 @@ 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
+    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
 
         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
@@ -1396,7 +1396,7 @@ class OrderManagementApi:
 
         :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\".
+        :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
@@ -1417,7 +1417,7 @@ 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
+    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
 
         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
@@ -1429,7 +1429,7 @@ class OrderManagementApi:
 
         :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\".
+        :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
@@ -1554,7 +1554,7 @@ class OrderManagementApi:
     def sweep_blocks(self, sweep_blocks_request : SweepBlocksRequest, async_req: Optional[bool]=None, **kwargs) -> Union[SweepBlocksResponse, Awaitable[SweepBlocksResponse]]:  # noqa: E501
         """[EXPERIMENTAL] SweepBlocks: Sweeps specified blocks, for each block that meets the requirements. The request may be partially successful.  # noqa: E501
 
-        The requirements are: <list type=\"bullet\"><term>The block exists.</term><term>All orders have state \"Closed\", \"Cancelled\", \"Canceled\" or \"Booked\".</term><term>All placements have state \"Allocated\" or \"Over-allocated\".</term><term>All allocations have state \"Closed\", \"Cancelled\", \"Canceled\" or \"Booked\".</term><term>No execution or allocation has been modified since the passed LatestAllowableModificationTime.</term></list>  # noqa: E501
+        The requirements are:  <list type=\"bullet\"><term>The block exists.</term><term>All orders have state \"Closed\", \"Cancelled\", \"Canceled\" or \"Booked\".</term><term>All placements have state \"Allocated\" or \"Over-allocated\".</term><term>All allocations have state \"Closed\", \"Cancelled\", \"Canceled\" or \"Booked\".</term><term>No execution or allocation has been modified since the passed LatestAllowableModificationTime.</term></list>  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -1585,7 +1585,7 @@ class OrderManagementApi:
     def sweep_blocks_with_http_info(self, sweep_blocks_request : SweepBlocksRequest, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] SweepBlocks: Sweeps specified blocks, for each block that meets the requirements. The request may be partially successful.  # noqa: E501
 
-        The requirements are: <list type=\"bullet\"><term>The block exists.</term><term>All orders have state \"Closed\", \"Cancelled\", \"Canceled\" or \"Booked\".</term><term>All placements have state \"Allocated\" or \"Over-allocated\".</term><term>All allocations have state \"Closed\", \"Cancelled\", \"Canceled\" or \"Booked\".</term><term>No execution or allocation has been modified since the passed LatestAllowableModificationTime.</term></list>  # noqa: E501
+        The requirements are:  <list type=\"bullet\"><term>The block exists.</term><term>All orders have state \"Closed\", \"Cancelled\", \"Canceled\" or \"Booked\".</term><term>All placements have state \"Allocated\" or \"Over-allocated\".</term><term>All allocations have state \"Closed\", \"Cancelled\", \"Canceled\" or \"Booked\".</term><term>No execution or allocation has been modified since the passed LatestAllowableModificationTime.</term></list>  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -1713,7 +1713,7 @@ class OrderManagementApi:
     def update_orders(self, request_body : Annotated[Dict[str, OrderUpdateRequest], Field(..., description="The request containing the orders to be updated.")], async_req: Optional[bool]=None, **kwargs) -> Union[UpdateOrdersResponse, Awaitable[UpdateOrdersResponse]]:  # 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
+        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
 
@@ -1744,7 +1744,7 @@ class OrderManagementApi:
     def update_orders_with_http_info(self, request_body : Annotated[Dict[str, OrderUpdateRequest], Field(..., description="The request containing the orders to be updated.")], **kwargs) -> ApiResponse:  # 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
+        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
 
@@ -1872,7 +1872,7 @@ class OrderManagementApi:
     def update_placements(self, request_body : Annotated[Dict[str, PlacementUpdateRequest], Field(..., description="The request containing the placements to be updated.")], async_req: Optional[bool]=None, **kwargs) -> Union[UpdatePlacementsResponse, Awaitable[UpdatePlacementsResponse]]:  # 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
+        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
 
@@ -1903,7 +1903,7 @@ class OrderManagementApi:
     def update_placements_with_http_info(self, request_body : Annotated[Dict[str, PlacementUpdateRequest], Field(..., description="The request containing the placements to be updated.")], **kwargs) -> ApiResponse:  # 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
+        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