lusid-sdk 2.1.990__py3-none-any.whl → 2.2.1__py3-none-any.whl

lusid/api/structured_result_data_api.py

@@ -19,13 +19,10 @@ import warnings
 from pydantic.v1 import validate_arguments, ValidationError
 from typing import overload, Optional, Union, Awaitable
 
-from typing_extensions import Annotated
 from datetime import datetime
-
-from pydantic.v1 import Field, StrictStr, conint, constr, validator
-
+from pydantic.v1 import Field, StrictInt, StrictStr
 from typing import Dict, Optional
-
+from typing_extensions import Annotated
 from lusid.models.annul_structured_data_response import AnnulStructuredDataResponse
 from lusid.models.create_data_map_request import CreateDataMapRequest
 from lusid.models.data_map_key import DataMapKey
@@ -66,15 +63,15 @@ class StructuredResultDataApi:
 
 
     @overload
-    async def create_data_map(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create or update data maps.")], request_body : Annotated[Dict[str, CreateDataMapRequest], Field(..., description="Individual data map creation requests.")], **kwargs) -> UpsertStructuredDataResponse:  # noqa: E501
+    async def create_data_map(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create or update data maps.")], request_body : Annotated[Dict[str, CreateDataMapRequest], Field(description="Individual data map creation requests.")], **kwargs) -> UpsertStructuredDataResponse:  # noqa: E501
         ...
 
     @overload
-    def create_data_map(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create or update data maps.")], request_body : Annotated[Dict[str, CreateDataMapRequest], Field(..., description="Individual data map creation requests.")], async_req: Optional[bool]=True, **kwargs) -> UpsertStructuredDataResponse:  # noqa: E501
+    def create_data_map(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create or update data maps.")], request_body : Annotated[Dict[str, CreateDataMapRequest], Field(description="Individual data map creation requests.")], async_req: Optional[bool]=True, **kwargs) -> UpsertStructuredDataResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def create_data_map(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create or update data maps.")], request_body : Annotated[Dict[str, CreateDataMapRequest], Field(..., description="Individual data map creation requests.")], async_req: Optional[bool]=None, **kwargs) -> Union[UpsertStructuredDataResponse, Awaitable[UpsertStructuredDataResponse]]:  # noqa: E501
+    def create_data_map(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create or update data maps.")], request_body : Annotated[Dict[str, CreateDataMapRequest], Field(description="Individual data map creation requests.")], async_req: Optional[bool]=None, **kwargs) -> Union[UpsertStructuredDataResponse, Awaitable[UpsertStructuredDataResponse]]:  # noqa: E501
         """CreateDataMap: Create data map  # noqa: E501
 
         Create or update one or more structured result store address definition data maps in a particular scope. Note these are immutable and cannot be changed once created.                In the request, each data map must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data map object in the response.                The response returns both the collection of successfully created or updated data maps, as well as those that failed.  For each failure, a reason is provided.                It is important to check the failed set for any unsuccessful results.  # noqa: E501
@@ -107,7 +104,7 @@ class StructuredResultDataApi:
         return self.create_data_map_with_http_info(scope, request_body, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def create_data_map_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create or update data maps.")], request_body : Annotated[Dict[str, CreateDataMapRequest], Field(..., description="Individual data map creation requests.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def create_data_map_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create or update data maps.")], request_body : Annotated[Dict[str, CreateDataMapRequest], Field(description="Individual data map creation requests.")], **kwargs) -> ApiResponse:  # noqa: E501
         """CreateDataMap: Create data map  # noqa: E501
 
         Create or update one or more structured result store address definition data maps in a particular scope. Note these are immutable and cannot be changed once created.                In the request, each data map must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data map object in the response.                The response returns both the collection of successfully created or updated data maps, as well as those that failed.  For each failure, a reason is provided.                It is important to check the failed set for any unsuccessful results.  # noqa: E501
@@ -233,15 +230,15 @@ class StructuredResultDataApi:
 
 
     @overload
-    async def delete_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to delete data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(..., description="The data IDs to delete, each keyed by a unique, ephemeral correlation ID.")], **kwargs) -> AnnulStructuredDataResponse:  # noqa: E501
+    async def delete_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to delete data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(description="The data IDs to delete, each keyed by a unique, ephemeral correlation ID.")], **kwargs) -> AnnulStructuredDataResponse:  # noqa: E501
         ...
 
     @overload
-    def delete_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to delete data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(..., description="The data IDs to delete, each keyed by a unique, ephemeral correlation ID.")], async_req: Optional[bool]=True, **kwargs) -> AnnulStructuredDataResponse:  # noqa: E501
+    def delete_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to delete data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(description="The data IDs to delete, each keyed by a unique, ephemeral correlation ID.")], async_req: Optional[bool]=True, **kwargs) -> AnnulStructuredDataResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def delete_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to delete data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(..., description="The data IDs to delete, each keyed by a unique, ephemeral correlation ID.")], async_req: Optional[bool]=None, **kwargs) -> Union[AnnulStructuredDataResponse, Awaitable[AnnulStructuredDataResponse]]:  # noqa: E501
+    def delete_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to delete data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(description="The data IDs to delete, each keyed by a unique, ephemeral correlation ID.")], async_req: Optional[bool]=None, **kwargs) -> Union[AnnulStructuredDataResponse, Awaitable[AnnulStructuredDataResponse]]:  # noqa: E501
         """DeleteStructuredResultData: Delete structured result data  # noqa: E501
 
         Delete one or more structured result data items from a particular scope. Each item is identified by a unique ID which includes  information about its type as well as the exact effective datetime (to the microsecond) at which it entered the system (became valid).                In the request, each data item must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data item in the response.                The response returns both the collection of successfully deleted data items, as well as those that failed.  For each failure, a reason is provided.                It is important to check the failed set for any unsuccessful results.  # noqa: E501
@@ -274,7 +271,7 @@ class StructuredResultDataApi:
         return self.delete_structured_result_data_with_http_info(scope, request_body, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def delete_structured_result_data_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to delete data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(..., description="The data IDs to delete, each keyed by a unique, ephemeral correlation ID.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def delete_structured_result_data_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to delete data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(description="The data IDs to delete, each keyed by a unique, ephemeral correlation ID.")], **kwargs) -> ApiResponse:  # noqa: E501
         """DeleteStructuredResultData: Delete structured result data  # noqa: E501
 
         Delete one or more structured result data items from a particular scope. Each item is identified by a unique ID which includes  information about its type as well as the exact effective datetime (to the microsecond) at which it entered the system (became valid).                In the request, each data item must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data item in the response.                The response returns both the collection of successfully deleted data items, as well as those that failed.  For each failure, a reason is provided.                It is important to check the failed set for any unsuccessful results.  # noqa: E501
@@ -595,15 +592,15 @@ class StructuredResultDataApi:
 
 
     @overload
-    async def get_data_map(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to retrieve data maps.")], request_body : Annotated[Dict[str, DataMapKey], Field(..., description="The data map keys to look up, each keyed by a unique, ephemeral correlation ID.")], **kwargs) -> GetDataMapResponse:  # noqa: E501
+    async def get_data_map(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to retrieve data maps.")], request_body : Annotated[Dict[str, DataMapKey], Field(description="The data map keys to look up, each keyed by a unique, ephemeral correlation ID.")], **kwargs) -> GetDataMapResponse:  # noqa: E501
         ...
 
     @overload
-    def get_data_map(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to retrieve data maps.")], request_body : Annotated[Dict[str, DataMapKey], Field(..., description="The data map keys to look up, each keyed by a unique, ephemeral correlation ID.")], async_req: Optional[bool]=True, **kwargs) -> GetDataMapResponse:  # noqa: E501
+    def get_data_map(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to retrieve data maps.")], request_body : Annotated[Dict[str, DataMapKey], Field(description="The data map keys to look up, each keyed by a unique, ephemeral correlation ID.")], async_req: Optional[bool]=True, **kwargs) -> GetDataMapResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_data_map(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to retrieve data maps.")], request_body : Annotated[Dict[str, DataMapKey], Field(..., description="The data map keys to look up, each keyed by a unique, ephemeral correlation ID.")], async_req: Optional[bool]=None, **kwargs) -> Union[GetDataMapResponse, Awaitable[GetDataMapResponse]]:  # noqa: E501
+    def get_data_map(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to retrieve data maps.")], request_body : Annotated[Dict[str, DataMapKey], Field(description="The data map keys to look up, each keyed by a unique, ephemeral correlation ID.")], async_req: Optional[bool]=None, **kwargs) -> Union[GetDataMapResponse, Awaitable[GetDataMapResponse]]:  # noqa: E501
         """GetDataMap: Get data map  # noqa: E501
 
         Retrieve one or more structured result store address definition data maps from a particular scope.                Each data map can be identified by its invariant key, which can be thought of as a permanent URL.  For each ID, LUSID returns the most recently matched item.                In the request, each data map must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data map in the response.                The response returns three collections. The first contains successfully retrieved data maps. The second contains those with a  valid identifier but that could not be found. The third contains those that failed because LUSID could not construct a valid identifier from the request.                For the IDs that failed to resolve or could not be found, a reason is provided.                It is important to check the failed sets for any unsuccessful results.  # noqa: E501
@@ -636,7 +633,7 @@ class StructuredResultDataApi:
         return self.get_data_map_with_http_info(scope, request_body, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_data_map_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to retrieve data maps.")], request_body : Annotated[Dict[str, DataMapKey], Field(..., description="The data map keys to look up, each keyed by a unique, ephemeral correlation ID.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def get_data_map_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to retrieve data maps.")], request_body : Annotated[Dict[str, DataMapKey], Field(description="The data map keys to look up, each keyed by a unique, ephemeral correlation ID.")], **kwargs) -> ApiResponse:  # noqa: E501
         """GetDataMap: Get data map  # noqa: E501
 
         Retrieve one or more structured result store address definition data maps from a particular scope.                Each data map can be identified by its invariant key, which can be thought of as a permanent URL.  For each ID, LUSID returns the most recently matched item.                In the request, each data map must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data map in the response.                The response returns three collections. The first contains successfully retrieved data maps. The second contains those with a  valid identifier but that could not be found. The third contains those that failed because LUSID could not construct a valid identifier from the request.                For the IDs that failed to resolve or could not be found, a reason is provided.                It is important to check the failed sets for any unsuccessful results.  # noqa: E501
@@ -762,15 +759,15 @@ class StructuredResultDataApi:
 
 
     @overload
-    async def get_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to retrieve data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(..., description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, max_age : Annotated[Optional[StrictStr], Field( description="The duration of the look-back window in ISO8601 time interval format, for example 'P1Y2M3DT4H30M' (1 year, 2 months, 3 days, 4 hours and 30 minutes).               This is subtracted from the provided effectiveAt datetime to generate a effective datetime window inside which a data item must exist to be retrieved.")] = None, **kwargs) -> GetStructuredResultDataResponse:  # noqa: E501
+    async def get_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to retrieve data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, max_age : Annotated[Optional[StrictStr], Field( description="The duration of the look-back window in ISO8601 time interval format, for example 'P1Y2M3DT4H30M' (1 year, 2 months, 3 days, 4 hours and 30 minutes).               This is subtracted from the provided effectiveAt datetime to generate a effective datetime window inside which a data item must exist to be retrieved.")] = None, **kwargs) -> GetStructuredResultDataResponse:  # noqa: E501
         ...
 
     @overload
-    def get_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to retrieve data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(..., description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, max_age : Annotated[Optional[StrictStr], Field( description="The duration of the look-back window in ISO8601 time interval format, for example 'P1Y2M3DT4H30M' (1 year, 2 months, 3 days, 4 hours and 30 minutes).               This is subtracted from the provided effectiveAt datetime to generate a effective datetime window inside which a data item must exist to be retrieved.")] = None, async_req: Optional[bool]=True, **kwargs) -> GetStructuredResultDataResponse:  # noqa: E501
+    def get_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to retrieve data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, max_age : Annotated[Optional[StrictStr], Field( description="The duration of the look-back window in ISO8601 time interval format, for example 'P1Y2M3DT4H30M' (1 year, 2 months, 3 days, 4 hours and 30 minutes).               This is subtracted from the provided effectiveAt datetime to generate a effective datetime window inside which a data item must exist to be retrieved.")] = None, async_req: Optional[bool]=True, **kwargs) -> GetStructuredResultDataResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to retrieve data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(..., description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, max_age : Annotated[Optional[StrictStr], Field( description="The duration of the look-back window in ISO8601 time interval format, for example 'P1Y2M3DT4H30M' (1 year, 2 months, 3 days, 4 hours and 30 minutes).               This is subtracted from the provided effectiveAt datetime to generate a effective datetime window inside which a data item must exist to be retrieved.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[GetStructuredResultDataResponse, Awaitable[GetStructuredResultDataResponse]]:  # noqa: E501
+    def get_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to retrieve data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, max_age : Annotated[Optional[StrictStr], Field( description="The duration of the look-back window in ISO8601 time interval format, for example 'P1Y2M3DT4H30M' (1 year, 2 months, 3 days, 4 hours and 30 minutes).               This is subtracted from the provided effectiveAt datetime to generate a effective datetime window inside which a data item must exist to be retrieved.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[GetStructuredResultDataResponse, Awaitable[GetStructuredResultDataResponse]]:  # noqa: E501
         """GetStructuredResultData: Get structured result data  # noqa: E501
 
         Retrieve one or more structured result data items from a particular scope.                Each item can be identified by its time invariant structured result data identifier. For each ID, LUSID  returns the most recently matched item with respect to the provided (or default) effective datetime.                 An optional maximum age range window can be specified to control how far back to look from the specified  effective datetime. LUSID returns the most recent item within this window.                In the request, each data item must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data item in the response.    The response returns three collections. The first contains successfully retrieved data items. The second contains those with a  valid identifier but that could not be found. The third contains those that failed because LUSID could not construct a valid identifier from the request.    For the IDs that failed to resolve or could not be found, a reason is provided.                It is important to check the failed sets for any unsuccessful results.  # noqa: E501
@@ -807,7 +804,7 @@ class StructuredResultDataApi:
         return self.get_structured_result_data_with_http_info(scope, request_body, as_at, max_age, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_structured_result_data_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to retrieve data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(..., description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, max_age : Annotated[Optional[StrictStr], Field( description="The duration of the look-back window in ISO8601 time interval format, for example 'P1Y2M3DT4H30M' (1 year, 2 months, 3 days, 4 hours and 30 minutes).               This is subtracted from the provided effectiveAt datetime to generate a effective datetime window inside which a data item must exist to be retrieved.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_structured_result_data_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope from which to retrieve data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, max_age : Annotated[Optional[StrictStr], Field( description="The duration of the look-back window in ISO8601 time interval format, for example 'P1Y2M3DT4H30M' (1 year, 2 months, 3 days, 4 hours and 30 minutes).               This is subtracted from the provided effectiveAt datetime to generate a effective datetime window inside which a data item must exist to be retrieved.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """GetStructuredResultData: Get structured result data  # noqa: E501
 
         Retrieve one or more structured result data items from a particular scope.                Each item can be identified by its time invariant structured result data identifier. For each ID, LUSID  returns the most recently matched item with respect to the provided (or default) effective datetime.                 An optional maximum age range window can be specified to control how far back to look from the specified  effective datetime. LUSID returns the most recent item within this window.                In the request, each data item must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data item in the response.    The response returns three collections. The first contains successfully retrieved data items. The second contains those with a  valid identifier but that could not be found. The third contains those that failed because LUSID could not construct a valid identifier from the request.    For the IDs that failed to resolve or could not be found, a reason is provided.                It is important to check the failed sets for any unsuccessful results.  # noqa: E501
@@ -948,15 +945,15 @@ class StructuredResultDataApi:
 
 
     @overload
-    async def get_virtual_document(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to construct the virtual documents.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(..., description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, **kwargs) -> GetVirtualDocumentResponse:  # noqa: E501
+    async def get_virtual_document(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to construct the virtual documents.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, **kwargs) -> GetVirtualDocumentResponse:  # noqa: E501
         ...
 
     @overload
-    def get_virtual_document(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to construct the virtual documents.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(..., description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> GetVirtualDocumentResponse:  # noqa: E501
+    def get_virtual_document(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to construct the virtual documents.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> GetVirtualDocumentResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_virtual_document(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to construct the virtual documents.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(..., description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[GetVirtualDocumentResponse, Awaitable[GetVirtualDocumentResponse]]:  # noqa: E501
+    def get_virtual_document(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to construct the virtual documents.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[GetVirtualDocumentResponse, Awaitable[GetVirtualDocumentResponse]]:  # noqa: E501
         """GetVirtualDocument: Get Virtual Documents  # noqa: E501
 
         Retrieve one or more virtual documents from a particular scope.                Each item can be identified by its time invariant structured result data identifier. For each ID, LUSID  returns the most recently matched item with respect to the provided effective datetime.                In the request, each data item must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data item in the response.                The response returns two collections. The first contains successfully retrieved data items. The second contains those with a  valid identifier but that could not be found, or those that failed because LUSID could not construct a valid identifier from the request.                For the IDs that failed to resolve or could not be found, a reason is provided.                It is important to check the failed sets for any unsuccessful results.  # noqa: E501
@@ -991,7 +988,7 @@ class StructuredResultDataApi:
         return self.get_virtual_document_with_http_info(scope, request_body, as_at, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_virtual_document_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to construct the virtual documents.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(..., description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_virtual_document_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to construct the virtual documents.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """GetVirtualDocument: Get Virtual Documents  # noqa: E501
 
         Retrieve one or more virtual documents from a particular scope.                Each item can be identified by its time invariant structured result data identifier. For each ID, LUSID  returns the most recently matched item with respect to the provided effective datetime.                In the request, each data item must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data item in the response.                The response returns two collections. The first contains successfully retrieved data items. The second contains those with a  valid identifier but that could not be found, or those that failed because LUSID could not construct a valid identifier from the request.                For the IDs that failed to resolve or could not be found, a reason is provided.                It is important to check the failed sets for any unsuccessful results.  # noqa: E501
@@ -1126,15 +1123,15 @@ class StructuredResultDataApi:
 
 
     @overload
-    async def get_virtual_document_rows(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[StrictStr, Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[StrictStr, Field(..., description="The source of the virtual document to retrieve.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the virtual document to retrieve.")], effective_at : Annotated[StrictStr, Field(..., description="The effectiveAt datetime at which to retrieve the virtual document.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the virtual document. Defaults to returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing virtual document rows from a previous               call to list virtual document rows. This value is returned from the previous call. If a pagination token is               provided the filter, effectiveAt, and asAt fields must not have changed since the original request.")] = 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) -> PagedResourceListOfVirtualRow:  # noqa: E501
+    async def get_virtual_document_rows(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[StrictStr, Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[StrictStr, Field(..., description="The source of the virtual document to retrieve.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the virtual document to retrieve.")], effective_at : Annotated[StrictStr, Field(..., description="The effectiveAt datetime at which to retrieve the virtual document.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the virtual document. Defaults to returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing virtual document rows from a previous               call to list virtual document rows. This value is returned from the previous call. If a pagination token is               provided the filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], 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) -> PagedResourceListOfVirtualRow:  # noqa: E501
         ...
 
     @overload
-    def get_virtual_document_rows(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[StrictStr, Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[StrictStr, Field(..., description="The source of the virtual document to retrieve.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the virtual document to retrieve.")], effective_at : Annotated[StrictStr, Field(..., description="The effectiveAt datetime at which to retrieve the virtual document.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the virtual document. Defaults to returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing virtual document rows from a previous               call to list virtual document rows. This value is returned from the previous call. If a pagination token is               provided the filter, effectiveAt, and asAt fields must not have changed since the original request.")] = 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) -> PagedResourceListOfVirtualRow:  # noqa: E501
+    def get_virtual_document_rows(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[StrictStr, Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[StrictStr, Field(..., description="The source of the virtual document to retrieve.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the virtual document to retrieve.")], effective_at : Annotated[StrictStr, Field(..., description="The effectiveAt datetime at which to retrieve the virtual document.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the virtual document. Defaults to returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing virtual document rows from a previous               call to list virtual document rows. This value is returned from the previous call. If a pagination token is               provided the filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], 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) -> PagedResourceListOfVirtualRow:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_virtual_document_rows(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[StrictStr, Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[StrictStr, Field(..., description="The source of the virtual document to retrieve.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the virtual document to retrieve.")], effective_at : Annotated[StrictStr, Field(..., description="The effectiveAt datetime at which to retrieve the virtual document.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the virtual document. Defaults to returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing virtual document rows from a previous               call to list virtual document rows. This value is returned from the previous call. If a pagination token is               provided the filter, effectiveAt, and asAt fields must not have changed since the original request.")] = 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[PagedResourceListOfVirtualRow, Awaitable[PagedResourceListOfVirtualRow]]:  # noqa: E501
+    def get_virtual_document_rows(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[StrictStr, Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[StrictStr, Field(..., description="The source of the virtual document to retrieve.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the virtual document to retrieve.")], effective_at : Annotated[StrictStr, Field(..., description="The effectiveAt datetime at which to retrieve the virtual document.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the virtual document. Defaults to returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing virtual document rows from a previous               call to list virtual document rows. This value is returned from the previous call. If a pagination token is               provided the filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], 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[PagedResourceListOfVirtualRow, Awaitable[PagedResourceListOfVirtualRow]]:  # noqa: E501
         """GetVirtualDocumentRows: Get Virtual Document Rows  # noqa: E501
 
         Retrieve the rows of the virtual document with the specified identifiers and the given effectiveAt date time.    Get virtual document rows merges multiple StructuredResultData items upserted with UpsertStructuredResultData  for a single StructuredResultDataId.                Since an item of StructuredResultData is always upserted with a StructuredResultDataId, of which  effectiveAt is a part, then merging across the asAt dimension is supported but not merging across the  effectiveAt dimension.  # noqa: E501
@@ -1181,7 +1178,7 @@ class StructuredResultDataApi:
         return self.get_virtual_document_rows_with_http_info(scope, code, source, result_type, effective_at, as_at, page, limit, filter, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_virtual_document_rows_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[StrictStr, Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[StrictStr, Field(..., description="The source of the virtual document to retrieve.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the virtual document to retrieve.")], effective_at : Annotated[StrictStr, Field(..., description="The effectiveAt datetime at which to retrieve the virtual document.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the virtual document. Defaults to returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing virtual document rows from a previous               call to list virtual document rows. This value is returned from the previous call. If a pagination token is               provided the filter, effectiveAt, and asAt fields must not have changed since the original request.")] = 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
+    def get_virtual_document_rows_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[StrictStr, Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[StrictStr, Field(..., description="The source of the virtual document to retrieve.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the virtual document to retrieve.")], effective_at : Annotated[StrictStr, Field(..., description="The effectiveAt datetime at which to retrieve the virtual document.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the virtual document. Defaults to returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing virtual document rows from a previous               call to list virtual document rows. This value is returned from the previous call. If a pagination token is               provided the filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], 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
         """GetVirtualDocumentRows: Get Virtual Document Rows  # noqa: E501
 
         Retrieve the rows of the virtual document with the specified identifiers and the given effectiveAt date time.    Get virtual document rows merges multiple StructuredResultData items upserted with UpsertStructuredResultData  for a single StructuredResultDataId.                Since an item of StructuredResultData is always upserted with a StructuredResultDataId, of which  effectiveAt is a part, then merging across the asAt dimension is supported but not merging across the  effectiveAt dimension.  # noqa: E501
@@ -1345,15 +1342,15 @@ class StructuredResultDataApi:
 
 
     @overload
-    async def upsert_result_value(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to construct the virtual documents.")], request_body : Annotated[Dict[str, UpsertResultValuesDataRequest], Field(..., description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], **kwargs) -> UpsertStructuredDataResponse:  # noqa: E501
+    async def upsert_result_value(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to construct the virtual documents.")], request_body : Annotated[Dict[str, UpsertResultValuesDataRequest], Field(description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], **kwargs) -> UpsertStructuredDataResponse:  # noqa: E501
         ...
 
     @overload
-    def upsert_result_value(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to construct the virtual documents.")], request_body : Annotated[Dict[str, UpsertResultValuesDataRequest], Field(..., description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], async_req: Optional[bool]=True, **kwargs) -> UpsertStructuredDataResponse:  # noqa: E501
+    def upsert_result_value(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to construct the virtual documents.")], request_body : Annotated[Dict[str, UpsertResultValuesDataRequest], Field(description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], async_req: Optional[bool]=True, **kwargs) -> UpsertStructuredDataResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def upsert_result_value(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to construct the virtual documents.")], request_body : Annotated[Dict[str, UpsertResultValuesDataRequest], Field(..., description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], async_req: Optional[bool]=None, **kwargs) -> Union[UpsertStructuredDataResponse, Awaitable[UpsertStructuredDataResponse]]:  # noqa: E501
+    def upsert_result_value(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to construct the virtual documents.")], request_body : Annotated[Dict[str, UpsertResultValuesDataRequest], Field(description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], async_req: Optional[bool]=None, **kwargs) -> Union[UpsertStructuredDataResponse, Awaitable[UpsertStructuredDataResponse]]:  # noqa: E501
         """UpsertResultValue: Upsert result value  # noqa: E501
 
         Create or update one or more Upsert one or more result values in a particular scope. An item is updated if it already exists  and created if it does not.                In the request, each data item must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data item in the response.                The response returns both the collection of successfully created or updated data items, as well as those that failed.  For each failure, a reason is provided.                It is important to check the failed set for any unsuccessful results.  # noqa: E501
@@ -1386,7 +1383,7 @@ class StructuredResultDataApi:
         return self.upsert_result_value_with_http_info(scope, request_body, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def upsert_result_value_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to construct the virtual documents.")], request_body : Annotated[Dict[str, UpsertResultValuesDataRequest], Field(..., description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def upsert_result_value_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to construct the virtual documents.")], request_body : Annotated[Dict[str, UpsertResultValuesDataRequest], Field(description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], **kwargs) -> ApiResponse:  # noqa: E501
         """UpsertResultValue: Upsert result value  # noqa: E501
 
         Create or update one or more Upsert one or more result values in a particular scope. An item is updated if it already exists  and created if it does not.                In the request, each data item must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data item in the response.                The response returns both the collection of successfully created or updated data items, as well as those that failed.  For each failure, a reason is provided.                It is important to check the failed set for any unsuccessful results.  # noqa: E501
@@ -1512,15 +1509,15 @@ class StructuredResultDataApi:
 
 
     @overload
-    async def upsert_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create or update data items.")], request_body : Annotated[Dict[str, UpsertStructuredResultDataRequest], Field(..., description="The set of data items to create or update, keyed by a unique, ephemeral correlation ID.")], **kwargs) -> UpsertStructuredDataResponse:  # noqa: E501
+    async def upsert_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create or update data items.")], request_body : Annotated[Dict[str, UpsertStructuredResultDataRequest], Field(description="The set of data items to create or update, keyed by a unique, ephemeral correlation ID.")], **kwargs) -> UpsertStructuredDataResponse:  # noqa: E501
         ...
 
     @overload
-    def upsert_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create or update data items.")], request_body : Annotated[Dict[str, UpsertStructuredResultDataRequest], Field(..., description="The set of data items to create or update, keyed by a unique, ephemeral correlation ID.")], async_req: Optional[bool]=True, **kwargs) -> UpsertStructuredDataResponse:  # noqa: E501
+    def upsert_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create or update data items.")], request_body : Annotated[Dict[str, UpsertStructuredResultDataRequest], Field(description="The set of data items to create or update, keyed by a unique, ephemeral correlation ID.")], async_req: Optional[bool]=True, **kwargs) -> UpsertStructuredDataResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def upsert_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create or update data items.")], request_body : Annotated[Dict[str, UpsertStructuredResultDataRequest], Field(..., description="The set of data items to create or update, keyed by a unique, ephemeral correlation ID.")], async_req: Optional[bool]=None, **kwargs) -> Union[UpsertStructuredDataResponse, Awaitable[UpsertStructuredDataResponse]]:  # noqa: E501
+    def upsert_structured_result_data(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create or update data items.")], request_body : Annotated[Dict[str, UpsertStructuredResultDataRequest], Field(description="The set of data items to create or update, keyed by a unique, ephemeral correlation ID.")], async_req: Optional[bool]=None, **kwargs) -> Union[UpsertStructuredDataResponse, Awaitable[UpsertStructuredDataResponse]]:  # noqa: E501
         """UpsertStructuredResultData: Upsert structured result data  # noqa: E501
 
         Create or update one or more structured result data items in a particular scope. An item is updated if it already exists  and created if it does not.                In the request, each data item must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data item in the response.                The response returns both the collection of successfully created or updated data items, as well as those that failed.  For each failure, a reason is provided.                It is important to check the failed set for any unsuccessful results.  # noqa: E501
@@ -1553,7 +1550,7 @@ class StructuredResultDataApi:
         return self.upsert_structured_result_data_with_http_info(scope, request_body, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def upsert_structured_result_data_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create or update data items.")], request_body : Annotated[Dict[str, UpsertStructuredResultDataRequest], Field(..., description="The set of data items to create or update, keyed by a unique, ephemeral correlation ID.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def upsert_structured_result_data_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create or update data items.")], request_body : Annotated[Dict[str, UpsertStructuredResultDataRequest], Field(description="The set of data items to create or update, keyed by a unique, ephemeral correlation ID.")], **kwargs) -> ApiResponse:  # noqa: E501
         """UpsertStructuredResultData: Upsert structured result data  # noqa: E501
 
         Create or update one or more structured result data items in a particular scope. An item is updated if it already exists  and created if it does not.                In the request, each data item must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data item in the response.                The response returns both the collection of successfully created or updated data items, as well as those that failed.  For each failure, a reason is provided.                It is important to check the failed set for any unsuccessful results.  # noqa: E501

lusid/api/system_configuration_api.py

@@ -19,13 +19,10 @@ import warnings
 from pydantic.v1 import validate_arguments, ValidationError
 from typing import overload, Optional, Union, Awaitable
 
-from typing_extensions import Annotated
 from datetime import datetime
-
-from pydantic.v1 import Field, conlist, constr, validator
-
-from typing import Optional
-
+from pydantic.v1 import Field
+from typing import List, Optional
+from typing_extensions import Annotated
 from lusid.models.deleted_entity_response import DeletedEntityResponse
 from lusid.models.set_transaction_configuration_source_request import SetTransactionConfigurationSourceRequest
 from lusid.models.side_configuration_data_request import SideConfigurationDataRequest
@@ -1007,15 +1004,15 @@ class SystemConfigurationApi:
 
 
     @overload
-    async def set_transaction_configuration_source(self, source : Annotated[StrictStr, Field(..., description="The source to set the transaction configurations for")], set_transaction_configuration_source_request : Annotated[conlist(SetTransactionConfigurationSourceRequest), Field(..., description="The set of transaction configurations")], **kwargs) -> TransactionSetConfigurationData:  # noqa: E501
+    async def set_transaction_configuration_source(self, source : Annotated[StrictStr, Field(..., description="The source to set the transaction configurations for")], set_transaction_configuration_source_request : Annotated[List[SetTransactionConfigurationSourceRequest], Field(description="The set of transaction configurations")], **kwargs) -> TransactionSetConfigurationData:  # noqa: E501
         ...
 
     @overload
-    def set_transaction_configuration_source(self, source : Annotated[StrictStr, Field(..., description="The source to set the transaction configurations for")], set_transaction_configuration_source_request : Annotated[conlist(SetTransactionConfigurationSourceRequest), Field(..., description="The set of transaction configurations")], async_req: Optional[bool]=True, **kwargs) -> TransactionSetConfigurationData:  # noqa: E501
+    def set_transaction_configuration_source(self, source : Annotated[StrictStr, Field(..., description="The source to set the transaction configurations for")], set_transaction_configuration_source_request : Annotated[List[SetTransactionConfigurationSourceRequest], Field(description="The set of transaction configurations")], async_req: Optional[bool]=True, **kwargs) -> TransactionSetConfigurationData:  # noqa: E501
         ...
 
     @validate_arguments
-    def set_transaction_configuration_source(self, source : Annotated[StrictStr, Field(..., description="The source to set the transaction configurations for")], set_transaction_configuration_source_request : Annotated[conlist(SetTransactionConfigurationSourceRequest), Field(..., description="The set of transaction configurations")], async_req: Optional[bool]=None, **kwargs) -> Union[TransactionSetConfigurationData, Awaitable[TransactionSetConfigurationData]]:  # noqa: E501
+    def set_transaction_configuration_source(self, source : Annotated[StrictStr, Field(..., description="The source to set the transaction configurations for")], set_transaction_configuration_source_request : Annotated[List[SetTransactionConfigurationSourceRequest], Field(description="The set of transaction configurations")], async_req: Optional[bool]=None, **kwargs) -> Union[TransactionSetConfigurationData, Awaitable[TransactionSetConfigurationData]]:  # noqa: E501
         """[EXPERIMENTAL] SetTransactionConfigurationSource: Set transaction types for a source  # noqa: E501
 
         This will replace all the existing transaction configurations for the given source                WARNING! Changing existing transaction types has a material impact on how data, new and old, is processed and aggregated by LUSID, and will affect your whole organisation. Only call this API if you are fully aware of the implications of the change.  # noqa: E501
@@ -1048,7 +1045,7 @@ class SystemConfigurationApi:
         return self.set_transaction_configuration_source_with_http_info(source, set_transaction_configuration_source_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def set_transaction_configuration_source_with_http_info(self, source : Annotated[StrictStr, Field(..., description="The source to set the transaction configurations for")], set_transaction_configuration_source_request : Annotated[conlist(SetTransactionConfigurationSourceRequest), Field(..., description="The set of transaction configurations")], **kwargs) -> ApiResponse:  # noqa: E501
+    def set_transaction_configuration_source_with_http_info(self, source : Annotated[StrictStr, Field(..., description="The source to set the transaction configurations for")], set_transaction_configuration_source_request : Annotated[List[SetTransactionConfigurationSourceRequest], Field(description="The set of transaction configurations")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] SetTransactionConfigurationSource: Set transaction types for a source  # noqa: E501
 
         This will replace all the existing transaction configurations for the given source                WARNING! Changing existing transaction types has a material impact on how data, new and old, is processed and aggregated by LUSID, and will affect your whole organisation. Only call this API if you are fully aware of the implications of the change.  # noqa: E501

lusid/api/tax_rule_sets_api.py

@@ -19,13 +19,10 @@ import warnings
 from pydantic.v1 import validate_arguments, ValidationError
 from typing import overload, Optional, Union, Awaitable
 
-from typing_extensions import Annotated
 from datetime import datetime
-
-from pydantic.v1 import Field, StrictStr, constr, validator
-
+from pydantic.v1 import Field, StrictStr
 from typing import Optional
-
+from typing_extensions import Annotated
 from lusid.models.create_tax_rule_set_request import CreateTaxRuleSetRequest
 from lusid.models.deleted_entity_response import DeletedEntityResponse
 from lusid.models.resource_list_of_tax_rule_set import ResourceListOfTaxRuleSet
@@ -59,15 +56,15 @@ class TaxRuleSetsApi:
 
 
     @overload
-    async def create_tax_rule_set(self, create_tax_rule_set_request : Annotated[CreateTaxRuleSetRequest, Field(..., description="The contents of the rule set.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule set will take effect.  Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> TaxRuleSet:  # noqa: E501
+    async def create_tax_rule_set(self, create_tax_rule_set_request : Annotated[CreateTaxRuleSetRequest, Field(description="The contents of the rule set.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule set will take effect.  Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> TaxRuleSet:  # noqa: E501
         ...
 
     @overload
-    def create_tax_rule_set(self, create_tax_rule_set_request : Annotated[CreateTaxRuleSetRequest, Field(..., description="The contents of the rule set.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule set will take effect.  Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> TaxRuleSet:  # noqa: E501
+    def create_tax_rule_set(self, create_tax_rule_set_request : Annotated[CreateTaxRuleSetRequest, Field(description="The contents of the rule set.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule set will take effect.  Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> TaxRuleSet:  # noqa: E501
         ...
 
     @validate_arguments
-    def create_tax_rule_set(self, create_tax_rule_set_request : Annotated[CreateTaxRuleSetRequest, Field(..., description="The contents of the rule set.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule set will take effect.  Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[TaxRuleSet, Awaitable[TaxRuleSet]]:  # noqa: E501
+    def create_tax_rule_set(self, create_tax_rule_set_request : Annotated[CreateTaxRuleSetRequest, Field(description="The contents of the rule set.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule set will take effect.  Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[TaxRuleSet, Awaitable[TaxRuleSet]]:  # noqa: E501
         """[EXPERIMENTAL] CreateTaxRuleSet: Create a tax rule set.  # noqa: E501
 
         Creates a tax rule set definition at the given effective time.  The user must be entitled to read any properties specified in each rule.  # noqa: E501
@@ -100,7 +97,7 @@ class TaxRuleSetsApi:
         return self.create_tax_rule_set_with_http_info(create_tax_rule_set_request, effective_at, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def create_tax_rule_set_with_http_info(self, create_tax_rule_set_request : Annotated[CreateTaxRuleSetRequest, Field(..., description="The contents of the rule set.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule set will take effect.  Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def create_tax_rule_set_with_http_info(self, create_tax_rule_set_request : Annotated[CreateTaxRuleSetRequest, Field(description="The contents of the rule set.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule set will take effect.  Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] CreateTaxRuleSet: Create a tax rule set.  # noqa: E501
 
         Creates a tax rule set definition at the given effective time.  The user must be entitled to read any properties specified in each rule.  # noqa: E501
@@ -728,15 +725,15 @@ class TaxRuleSetsApi:
 
 
     @overload
-    async def update_tax_rule_set(self, scope : Annotated[StrictStr, Field(..., description="The rule set scope.")], code : Annotated[StrictStr, Field(..., description="The rule set code.")], update_tax_rule_set_request : Annotated[UpdateTaxRuleSetRequest, Field(..., description="The contents of the rule set.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule set will take effect.  Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> TaxRuleSet:  # noqa: E501
+    async def update_tax_rule_set(self, scope : Annotated[StrictStr, Field(..., description="The rule set scope.")], code : Annotated[StrictStr, Field(..., description="The rule set code.")], update_tax_rule_set_request : Annotated[UpdateTaxRuleSetRequest, Field(description="The contents of the rule set.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule set will take effect.  Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> TaxRuleSet:  # noqa: E501
         ...
 
     @overload
-    def update_tax_rule_set(self, scope : Annotated[StrictStr, Field(..., description="The rule set scope.")], code : Annotated[StrictStr, Field(..., description="The rule set code.")], update_tax_rule_set_request : Annotated[UpdateTaxRuleSetRequest, Field(..., description="The contents of the rule set.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule set will take effect.  Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> TaxRuleSet:  # noqa: E501
+    def update_tax_rule_set(self, scope : Annotated[StrictStr, Field(..., description="The rule set scope.")], code : Annotated[StrictStr, Field(..., description="The rule set code.")], update_tax_rule_set_request : Annotated[UpdateTaxRuleSetRequest, Field(description="The contents of the rule set.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule set will take effect.  Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> TaxRuleSet:  # noqa: E501
         ...
 
     @validate_arguments
-    def update_tax_rule_set(self, scope : Annotated[StrictStr, Field(..., description="The rule set scope.")], code : Annotated[StrictStr, Field(..., description="The rule set code.")], update_tax_rule_set_request : Annotated[UpdateTaxRuleSetRequest, Field(..., description="The contents of the rule set.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule set will take effect.  Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[TaxRuleSet, Awaitable[TaxRuleSet]]:  # noqa: E501
+    def update_tax_rule_set(self, scope : Annotated[StrictStr, Field(..., description="The rule set scope.")], code : Annotated[StrictStr, Field(..., description="The rule set code.")], update_tax_rule_set_request : Annotated[UpdateTaxRuleSetRequest, Field(description="The contents of the rule set.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule set will take effect.  Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[TaxRuleSet, Awaitable[TaxRuleSet]]:  # noqa: E501
         """[EXPERIMENTAL] UpdateTaxRuleSet: Update a tax rule set.  # noqa: E501
 
         Updates the tax rule set definition at the given effective time.  The changes will take place from this effective time until the next effective time that the rule has been updated at.  For example, consider a rule that has been created or updated effective at the first day of the coming month.  An upsert effective from the current day will only change the definition until that day.  An additional upsert at the same time (first day of the month) is required if the newly-updated definition is to supersede the future definition.  The user must be entitled to read any properties specified in each rule.  # noqa: E501
@@ -773,7 +770,7 @@ class TaxRuleSetsApi:
         return self.update_tax_rule_set_with_http_info(scope, code, update_tax_rule_set_request, effective_at, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def update_tax_rule_set_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The rule set scope.")], code : Annotated[StrictStr, Field(..., description="The rule set code.")], update_tax_rule_set_request : Annotated[UpdateTaxRuleSetRequest, Field(..., description="The contents of the rule set.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule set will take effect.  Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def update_tax_rule_set_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The rule set scope.")], code : Annotated[StrictStr, Field(..., description="The rule set code.")], update_tax_rule_set_request : Annotated[UpdateTaxRuleSetRequest, Field(description="The contents of the rule set.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule set will take effect.  Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] UpdateTaxRuleSet: Update a tax rule set.  # noqa: E501
 
         Updates the tax rule set definition at the given effective time.  The changes will take place from this effective time until the next effective time that the rule has been updated at.  For example, consider a rule that has been created or updated effective at the first day of the coming month.  An upsert effective from the current day will only change the definition until that day.  An additional upsert at the same time (first day of the month) is required if the newly-updated definition is to supersede the future definition.  The user must be entitled to read any properties specified in each rule.  # noqa: E501