lusid-sdk 1.1.131__py3-none-any.whl → 2.1.683__py3-none-any.whl

lusid/api/structured_result_data_api.py

@@ -5,50 +5,410 @@
 
     FINBOURNE Technology  # noqa: E501
 
-    The version of the OpenAPI document: 1.1.131
     Contact: info@finbourne.com
-    Generated by: https://openapi-generator.tech
-"""
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
 
+    Do not edit the class manually.
+"""
 
-from __future__ import absolute_import
 
 import re  # noqa: F401
+import io
+import warnings
+
+from pydantic.v1 import validate_arguments, ValidationError
+from typing import overload, Optional, Union, Awaitable
 
-# python 2 and python 3 compatibility library
-import six
+from typing_extensions import Annotated
+from datetime import datetime
+
+from pydantic.v1 import Field, StrictStr, conint, constr, validator
+
+from typing import Dict, Optional
+
+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
+from lusid.models.get_data_map_response import GetDataMapResponse
+from lusid.models.get_structured_result_data_response import GetStructuredResultDataResponse
+from lusid.models.get_virtual_document_response import GetVirtualDocumentResponse
+from lusid.models.paged_resource_list_of_virtual_row import PagedResourceListOfVirtualRow
+from lusid.models.resource_list_of_address_key_definition import ResourceListOfAddressKeyDefinition
+from lusid.models.structured_result_data_id import StructuredResultDataId
+from lusid.models.upsert_result_values_data_request import UpsertResultValuesDataRequest
+from lusid.models.upsert_structured_data_response import UpsertStructuredDataResponse
+from lusid.models.upsert_structured_result_data_request import UpsertStructuredResultDataRequest
 
 from lusid.api_client import ApiClient
+from lusid.api_response import ApiResponse
 from lusid.exceptions import (  # noqa: F401
     ApiTypeError,
     ApiValueError
 )
-from lusid.models.lusid_problem_details import LusidProblemDetails
-from lusid.models.lusid_validation_problem_details import LusidValidationProblemDetails
-from lusid.models.paged_resource_list_of_virtual_row import PagedResourceListOfVirtualRow
-from lusid.models.resource_list_of_address_key_definition import ResourceListOfAddressKeyDefinition
+from lusid.extensions.configuration_options import ConfigurationOptions
 
 
-class StructuredResultDataApi(object):
+class StructuredResultDataApi:
     """NOTE: This class is auto generated by OpenAPI Generator
     Ref: https://openapi-generator.tech
 
     Do not edit the class manually.
     """
 
-    def __init__(self, api_client=None):
+    def __init__(self, api_client=None) -> None:
         if api_client is None:
-            api_client = ApiClient()
+            api_client = ApiClient.get_default()
         self.api_client = api_client
 
-    def get_address_key_definitions_for_document(self, scope, code, source, result_type, **kwargs):  # noqa: E501
+    @overload
+    async def create_data_map(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), 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[constr(strict=True, max_length=64, min_length=1), 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[constr(strict=True, max_length=64, min_length=1), 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
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.create_data_map(scope, request_body, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope in which to create or update data maps. (required)
+        :type scope: str
+        :param request_body: Individual data map creation requests. (required)
+        :type request_body: Dict[str, CreateDataMapRequest]
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: UpsertStructuredDataResponse
+        """
+        kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the create_data_map_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
+        return self.create_data_map_with_http_info(scope, request_body, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def create_data_map_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), 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
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.create_data_map_with_http_info(scope, request_body, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope in which to create or update data maps. (required)
+        :type scope: str
+        :param request_body: Individual data map creation requests. (required)
+        :type request_body: Dict[str, CreateDataMapRequest]
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
+        :type _preload_content: bool, optional
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(UpsertStructuredDataResponse, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = [
+            'scope',
+            'request_body'
+        ]
+        _all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout',
+                '_request_auth',
+                '_content_type',
+                '_headers',
+                'opts'
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method create_data_map" % _key
+                )
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params['scope']:
+            _path_params['scope'] = _params['scope']
+
+
+        # process the query parameters
+        _query_params = []
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params['request_body'] is not None:
+            _body_params = _params['request_body']
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get('_content_type',
+            self.api_client.select_header_content_type(
+                ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json']))
+        if _content_types_list:
+                _header_params['Content-Type'] = _content_types_list
+
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
+
+        _response_types_map = {
+            '200': "UpsertStructuredDataResponse",
+            '400': "LusidValidationProblemDetails",
+        }
+
+        return self.api_client.call_api(
+            '/api/unitresults/datamap/{scope}', 'POST',
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            opts=_params.get('opts'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
+    @overload
+    async def delete_structured_result_data(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), 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[constr(strict=True, max_length=64, min_length=1), 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[constr(strict=True, max_length=64, min_length=1), 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
+        """[EXPERIMENTAL] 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
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.delete_structured_result_data(scope, request_body, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope from which to delete data items. (required)
+        :type scope: str
+        :param request_body: The data IDs to delete, each keyed by a unique, ephemeral correlation ID. (required)
+        :type request_body: Dict[str, StructuredResultDataId]
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: AnnulStructuredDataResponse
+        """
+        kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the delete_structured_result_data_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
+        return self.delete_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[constr(strict=True, max_length=64, min_length=1), 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
+        """[EXPERIMENTAL] 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
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.delete_structured_result_data_with_http_info(scope, request_body, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope from which to delete data items. (required)
+        :type scope: str
+        :param request_body: The data IDs to delete, each keyed by a unique, ephemeral correlation ID. (required)
+        :type request_body: Dict[str, StructuredResultDataId]
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
+        :type _preload_content: bool, optional
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(AnnulStructuredDataResponse, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = [
+            'scope',
+            'request_body'
+        ]
+        _all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout',
+                '_request_auth',
+                '_content_type',
+                '_headers',
+                'opts'
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method delete_structured_result_data" % _key
+                )
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params['scope']:
+            _path_params['scope'] = _params['scope']
+
+
+        # process the query parameters
+        _query_params = []
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params['request_body'] is not None:
+            _body_params = _params['request_body']
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get('_content_type',
+            self.api_client.select_header_content_type(
+                ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json']))
+        if _content_types_list:
+                _header_params['Content-Type'] = _content_types_list
+
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
+
+        _response_types_map = {
+            '200': "AnnulStructuredDataResponse",
+            '400': "LusidValidationProblemDetails",
+        }
+
+        return self.api_client.call_api(
+            '/api/unitresults/{scope}/$delete', 'POST',
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            opts=_params.get('opts'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
+    @overload
+    async def get_address_key_definitions_for_document(self, scope : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The scope of the document for which address key definitions are retrieved.")], code : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The code of the document for which address key definitions are retrieved.")], source : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The source of the document for which address key definitions are retrieved.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the document for which address key definitions are retrieved.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime to query the document for which the address key definitions are retrieved.              Defaults to querying the latest version if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime to query the document for which the address key definitions are retrieved.              Defaults to querying the latest version if not specified.")] = None, **kwargs) -> ResourceListOfAddressKeyDefinition:  # noqa: E501
+        ...
+
+    @overload
+    def get_address_key_definitions_for_document(self, scope : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The scope of the document for which address key definitions are retrieved.")], code : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The code of the document for which address key definitions are retrieved.")], source : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The source of the document for which address key definitions are retrieved.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the document for which address key definitions are retrieved.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime to query the document for which the address key definitions are retrieved.              Defaults to querying the latest version if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime to query the document for which the address key definitions are retrieved.              Defaults to querying the latest version if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfAddressKeyDefinition:  # noqa: E501
+        ...
+
+    @validate_arguments
+    def get_address_key_definitions_for_document(self, scope : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The scope of the document for which address key definitions are retrieved.")], code : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The code of the document for which address key definitions are retrieved.")], source : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The source of the document for which address key definitions are retrieved.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the document for which address key definitions are retrieved.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime to query the document for which the address key definitions are retrieved.              Defaults to querying the latest version if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime to query the document for which the address key definitions are retrieved.              Defaults to querying the latest version if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfAddressKeyDefinition, Awaitable[ResourceListOfAddressKeyDefinition]]:  # noqa: E501
         """[EARLY ACCESS] GetAddressKeyDefinitionsForDocument: Get AddressKeyDefinitions for a virtual document.  # noqa: E501
 
         For a given virtual document retrieve all the address key definitions that are in use.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.get_address_key_definitions_for_document(scope, code, source, result_type, async_req=True)
+        >>> thread = api.get_address_key_definitions_for_document(scope, code, source, result_type, effective_at, as_at, async_req=True)
         >>> result = thread.get()
 
         :param scope: The scope of the document for which address key definitions are retrieved. (required)
@@ -65,30 +425,31 @@ class StructuredResultDataApi(object):
         :type as_at: datetime
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :type _preload_content: bool, optional
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
         :rtype: ResourceListOfAddressKeyDefinition
         """
         kwargs['_return_http_data_only'] = True
-        return self.get_address_key_definitions_for_document_with_http_info(scope, code, source, result_type, **kwargs)  # noqa: E501
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the get_address_key_definitions_for_document_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
+        return self.get_address_key_definitions_for_document_with_http_info(scope, code, source, result_type, effective_at, as_at, **kwargs)  # noqa: E501
 
-    def get_address_key_definitions_for_document_with_http_info(self, scope, code, source, result_type, **kwargs):  # noqa: E501
+    @validate_arguments
+    def get_address_key_definitions_for_document_with_http_info(self, scope : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The scope of the document for which address key definitions are retrieved.")], code : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The code of the document for which address key definitions are retrieved.")], source : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The source of the document for which address key definitions are retrieved.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the document for which address key definitions are retrieved.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime to query the document for which the address key definitions are retrieved.              Defaults to querying the latest version if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime to query the document for which the address key definitions are retrieved.              Defaults to querying the latest version if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] GetAddressKeyDefinitionsForDocument: Get AddressKeyDefinitions for a virtual document.  # noqa: E501
 
         For a given virtual document retrieve all the address key definitions that are in use.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.get_address_key_definitions_for_document_with_http_info(scope, code, source, result_type, async_req=True)
+        >>> thread = api.get_address_key_definitions_for_document_with_http_info(scope, code, source, result_type, effective_at, as_at, async_req=True)
         >>> result = thread.get()
 
         :param scope: The scope of the document for which address key definitions are retrieved. (required)
@@ -105,30 +466,31 @@ class StructuredResultDataApi(object):
         :type as_at: datetime
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :type _return_http_data_only: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
         :type _preload_content: bool, optional
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
         :param _request_auth: set to override the auth_settings for an a single
                               request; this effectively ignores the authentication
                               in the spec for a single request.
         :type _request_auth: dict, optional
-        :return: Returns the result object, the HTTP status code, and the headers.
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: (ResourceListOfAddressKeyDefinition, int, HTTPHeaderDict)
+        :rtype: tuple(ResourceListOfAddressKeyDefinition, status_code(int), headers(HTTPHeaderDict))
         """
 
-        local_var_params = locals()
+        _params = locals()
 
-        all_params = [
+        _all_params = [
             'scope',
             'code',
             'source',
@@ -136,134 +498,639 @@ class StructuredResultDataApi(object):
             'effective_at',
             'as_at'
         ]
-        all_params.extend(
+        _all_params.extend(
             [
                 'async_req',
                 '_return_http_data_only',
                 '_preload_content',
                 '_request_timeout',
                 '_request_auth',
-                '_headers'
+                '_content_type',
+                '_headers',
+                'opts'
             ]
         )
 
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_address_key_definitions_for_document" % key
+                    " to method get_address_key_definitions_for_document" % _key
                 )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'scope' is set
-        if self.api_client.client_side_validation and ('scope' not in local_var_params or  # noqa: E501
-                                                        local_var_params['scope'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `scope` when calling `get_address_key_definitions_for_document`")  # noqa: E501
-        # verify the required parameter 'code' is set
-        if self.api_client.client_side_validation and ('code' not in local_var_params or  # noqa: E501
-                                                        local_var_params['code'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `code` when calling `get_address_key_definitions_for_document`")  # noqa: E501
-        # verify the required parameter 'source' is set
-        if self.api_client.client_side_validation and ('source' not in local_var_params or  # noqa: E501
-                                                        local_var_params['source'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `source` when calling `get_address_key_definitions_for_document`")  # noqa: E501
-        # verify the required parameter 'result_type' is set
-        if self.api_client.client_side_validation and ('result_type' not in local_var_params or  # noqa: E501
-                                                        local_var_params['result_type'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `result_type` when calling `get_address_key_definitions_for_document`")  # noqa: E501
-
-        if self.api_client.client_side_validation and ('scope' in local_var_params and  # noqa: E501
-                                                        len(local_var_params['scope']) > 256):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `scope` when calling `get_address_key_definitions_for_document`, length must be less than or equal to `256`")  # noqa: E501
-        if self.api_client.client_side_validation and ('scope' in local_var_params and  # noqa: E501
-                                                        len(local_var_params['scope']) < 1):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `scope` when calling `get_address_key_definitions_for_document`, length must be greater than or equal to `1`")  # noqa: E501
-        if self.api_client.client_side_validation and 'scope' in local_var_params and not re.search(r'^[a-zA-Z0-9\-_]+$', local_var_params['scope']):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `scope` when calling `get_address_key_definitions_for_document`, must conform to the pattern `/^[a-zA-Z0-9\-_]+$/`")  # noqa: E501
-        if self.api_client.client_side_validation and ('code' in local_var_params and  # noqa: E501
-                                                        len(local_var_params['code']) > 256):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `code` when calling `get_address_key_definitions_for_document`, length must be less than or equal to `256`")  # noqa: E501
-        if self.api_client.client_side_validation and ('code' in local_var_params and  # noqa: E501
-                                                        len(local_var_params['code']) < 1):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `code` when calling `get_address_key_definitions_for_document`, length must be greater than or equal to `1`")  # noqa: E501
-        if self.api_client.client_side_validation and 'code' in local_var_params and not re.search(r'^[a-zA-Z0-9\-_]+$', local_var_params['code']):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `code` when calling `get_address_key_definitions_for_document`, must conform to the pattern `/^[a-zA-Z0-9\-_]+$/`")  # noqa: E501
-        if self.api_client.client_side_validation and ('source' in local_var_params and  # noqa: E501
-                                                        len(local_var_params['source']) > 256):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `source` when calling `get_address_key_definitions_for_document`, length must be less than or equal to `256`")  # noqa: E501
-        if self.api_client.client_side_validation and ('source' in local_var_params and  # noqa: E501
-                                                        len(local_var_params['source']) < 1):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `source` when calling `get_address_key_definitions_for_document`, length must be greater than or equal to `1`")  # noqa: E501
-        if self.api_client.client_side_validation and 'source' in local_var_params and not re.search(r'^[a-zA-Z0-9\-_]+$', local_var_params['source']):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `source` when calling `get_address_key_definitions_for_document`, must conform to the pattern `/^[a-zA-Z0-9\-_]+$/`")  # noqa: E501
-        collection_formats = {}
-
-        path_params = {}
-        if 'scope' in local_var_params:
-            path_params['scope'] = local_var_params['scope']  # noqa: E501
-        if 'code' in local_var_params:
-            path_params['code'] = local_var_params['code']  # noqa: E501
-        if 'source' in local_var_params:
-            path_params['source'] = local_var_params['source']  # noqa: E501
-        if 'result_type' in local_var_params:
-            path_params['resultType'] = local_var_params['result_type']  # noqa: E501
-
-        query_params = []
-        if 'effective_at' in local_var_params and local_var_params['effective_at'] is not None:  # noqa: E501
-            query_params.append(('effectiveAt', local_var_params['effective_at']))  # noqa: E501
-        if 'as_at' in local_var_params and local_var_params['as_at'] is not None:  # noqa: E501
-            query_params.append(('asAt', local_var_params['as_at']))  # noqa: E501
-
-        header_params = dict(local_var_params.get('_headers', {}))
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
-            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params['scope']:
+            _path_params['scope'] = _params['scope']
+
+        if _params['code']:
+            _path_params['code'] = _params['code']
 
-        header_params['Accept-Encoding'] = "gzip, deflate, br"
+        if _params['source']:
+            _path_params['source'] = _params['source']
 
+        if _params['result_type']:
+            _path_params['resultType'] = _params['result_type']
 
-        # set the LUSID header
-        header_params['X-LUSID-SDK-Language'] = 'Python'
-        header_params['X-LUSID-SDK-Version'] = '1.1.131'
 
-        # Authentication setting
-        auth_settings = ['oauth2']  # noqa: E501
+        # process the query parameters
+        _query_params = []
+        if _params.get('effective_at') is not None:  # noqa: E501
+            _query_params.append(('effectiveAt', _params['effective_at']))
 
-        response_types_map = {
-            200: "ResourceListOfAddressKeyDefinition",
-            400: "LusidValidationProblemDetails",
+        if _params.get('as_at') is not None:  # noqa: E501
+            if isinstance(_params['as_at'], datetime):
+                _query_params.append(('asAt', _params['as_at'].strftime(self.api_client.configuration.datetime_format)))
+            else:
+                _query_params.append(('asAt', _params['as_at']))
+
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
+
+        _response_types_map = {
+            '200': "ResourceListOfAddressKeyDefinition",
+            '400': "LusidValidationProblemDetails",
         }
 
         return self.api_client.call_api(
             '/api/unitresults/virtualdocument/{scope}/{code}/{source}/{resultType}/addresskeydefinitions', 'GET',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_types_map=response_types_map,
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats,
-            _request_auth=local_var_params.get('_request_auth'))
-
-    def get_virtual_document_rows(self, scope, code, source, result_type, effective_at, **kwargs):  # noqa: E501
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            opts=_params.get('opts'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
+    @overload
+    async def get_data_map(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), 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[constr(strict=True, max_length=64, min_length=1), 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[constr(strict=True, max_length=64, min_length=1), 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
+        """[EXPERIMENTAL] 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
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_data_map(scope, request_body, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope from which to retrieve data maps. (required)
+        :type scope: str
+        :param request_body: The data map keys to look up, each keyed by a unique, ephemeral correlation ID. (required)
+        :type request_body: Dict[str, DataMapKey]
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: GetDataMapResponse
+        """
+        kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the get_data_map_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
+        return self.get_data_map_with_http_info(scope, request_body, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def get_data_map_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), 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
+        """[EXPERIMENTAL] 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
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_data_map_with_http_info(scope, request_body, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope from which to retrieve data maps. (required)
+        :type scope: str
+        :param request_body: The data map keys to look up, each keyed by a unique, ephemeral correlation ID. (required)
+        :type request_body: Dict[str, DataMapKey]
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
+        :type _preload_content: bool, optional
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(GetDataMapResponse, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = [
+            'scope',
+            'request_body'
+        ]
+        _all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout',
+                '_request_auth',
+                '_content_type',
+                '_headers',
+                'opts'
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_data_map" % _key
+                )
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params['scope']:
+            _path_params['scope'] = _params['scope']
+
+
+        # process the query parameters
+        _query_params = []
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params['request_body'] is not None:
+            _body_params = _params['request_body']
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get('_content_type',
+            self.api_client.select_header_content_type(
+                ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json']))
+        if _content_types_list:
+                _header_params['Content-Type'] = _content_types_list
+
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
+
+        _response_types_map = {
+            '200': "GetDataMapResponse",
+            '400': "LusidValidationProblemDetails",
+        }
+
+        return self.api_client.call_api(
+            '/api/unitresults/datamap/{scope}/$get', 'POST',
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            opts=_params.get('opts'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
+    @overload
+    async def get_structured_result_data(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), 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[constr(strict=True, max_length=64, min_length=1), 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[constr(strict=True, max_length=64, min_length=1), 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
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_structured_result_data(scope, request_body, as_at, max_age, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope from which to retrieve data items. (required)
+        :type scope: str
+        :param request_body: The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID. (required)
+        :type request_body: Dict[str, StructuredResultDataId]
+        :param as_at: The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.
+        :type as_at: datetime
+        :param max_age: 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.
+        :type max_age: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: GetStructuredResultDataResponse
+        """
+        kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the get_structured_result_data_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
+        return self.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[constr(strict=True, max_length=64, min_length=1), 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
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_structured_result_data_with_http_info(scope, request_body, as_at, max_age, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope from which to retrieve data items. (required)
+        :type scope: str
+        :param request_body: The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID. (required)
+        :type request_body: Dict[str, StructuredResultDataId]
+        :param as_at: The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.
+        :type as_at: datetime
+        :param max_age: 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.
+        :type max_age: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
+        :type _preload_content: bool, optional
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(GetStructuredResultDataResponse, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = [
+            'scope',
+            'request_body',
+            'as_at',
+            'max_age'
+        ]
+        _all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout',
+                '_request_auth',
+                '_content_type',
+                '_headers',
+                'opts'
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_structured_result_data" % _key
+                )
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params['scope']:
+            _path_params['scope'] = _params['scope']
+
+
+        # process the query parameters
+        _query_params = []
+        if _params.get('as_at') is not None:  # noqa: E501
+            if isinstance(_params['as_at'], datetime):
+                _query_params.append(('asAt', _params['as_at'].strftime(self.api_client.configuration.datetime_format)))
+            else:
+                _query_params.append(('asAt', _params['as_at']))
+
+        if _params.get('max_age') is not None:  # noqa: E501
+            _query_params.append(('maxAge', _params['max_age']))
+
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params['request_body'] is not None:
+            _body_params = _params['request_body']
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get('_content_type',
+            self.api_client.select_header_content_type(
+                ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json']))
+        if _content_types_list:
+                _header_params['Content-Type'] = _content_types_list
+
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
+
+        _response_types_map = {
+            '200': "GetStructuredResultDataResponse",
+            '400': "LusidValidationProblemDetails",
+        }
+
+        return self.api_client.call_api(
+            '/api/unitresults/{scope}/$get', 'POST',
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            opts=_params.get('opts'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
+    @overload
+    async def get_virtual_document(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), 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[constr(strict=True, max_length=64, min_length=1), 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[constr(strict=True, max_length=64, min_length=1), 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
+        """[EXPERIMENTAL] 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
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_virtual_document(scope, request_body, as_at, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope in which to construct the virtual documents. (required)
+        :type scope: str
+        :param request_body: The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID. (required)
+        :type request_body: Dict[str, StructuredResultDataId]
+        :param as_at: The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.
+        :type as_at: datetime
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: GetVirtualDocumentResponse
+        """
+        kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the get_virtual_document_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
+        return self.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[constr(strict=True, max_length=64, min_length=1), 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
+        """[EXPERIMENTAL] 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
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_virtual_document_with_http_info(scope, request_body, as_at, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope in which to construct the virtual documents. (required)
+        :type scope: str
+        :param request_body: The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID. (required)
+        :type request_body: Dict[str, StructuredResultDataId]
+        :param as_at: The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.
+        :type as_at: datetime
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
+        :type _preload_content: bool, optional
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(GetVirtualDocumentResponse, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = [
+            'scope',
+            'request_body',
+            'as_at'
+        ]
+        _all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout',
+                '_request_auth',
+                '_content_type',
+                '_headers',
+                'opts'
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_virtual_document" % _key
+                )
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params['scope']:
+            _path_params['scope'] = _params['scope']
+
+
+        # process the query parameters
+        _query_params = []
+        if _params.get('as_at') is not None:  # noqa: E501
+            if isinstance(_params['as_at'], datetime):
+                _query_params.append(('asAt', _params['as_at'].strftime(self.api_client.configuration.datetime_format)))
+            else:
+                _query_params.append(('asAt', _params['as_at']))
+
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params['request_body'] is not None:
+            _body_params = _params['request_body']
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get('_content_type',
+            self.api_client.select_header_content_type(
+                ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json']))
+        if _content_types_list:
+                _header_params['Content-Type'] = _content_types_list
+
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
+
+        _response_types_map = {
+            '200': "GetVirtualDocumentResponse",
+            '400': "LusidValidationProblemDetails",
+        }
+
+        return self.api_client.call_api(
+            '/api/unitresults/virtualdocument/{scope}/$get', 'POST',
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            opts=_params.get('opts'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
+    @overload
+    async def get_virtual_document_rows(self, scope : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[constr(strict=True, max_length=256, min_length=1), 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[constr(strict=True, max_length=500, min_length=1)], 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, le=5000, ge=1)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], 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[constr(strict=True, max_length=256, min_length=1), Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[constr(strict=True, max_length=256, min_length=1), 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[constr(strict=True, max_length=500, min_length=1)], 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, le=5000, ge=1)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], 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[constr(strict=True, max_length=256, min_length=1), Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[constr(strict=True, max_length=256, min_length=1), 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[constr(strict=True, max_length=500, min_length=1)], 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, le=5000, ge=1)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], 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
         """[EARLY ACCESS] 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
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.get_virtual_document_rows(scope, code, source, result_type, effective_at, async_req=True)
+        >>> thread = api.get_virtual_document_rows(scope, code, source, result_type, effective_at, as_at, page, limit, filter, async_req=True)
         >>> result = thread.get()
 
         :param scope: The scope in which to retrieve the virtual document. (required)
@@ -286,30 +1153,31 @@ class StructuredResultDataApi(object):
         :type filter: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :type _preload_content: bool, optional
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
         :rtype: PagedResourceListOfVirtualRow
         """
         kwargs['_return_http_data_only'] = True
-        return self.get_virtual_document_rows_with_http_info(scope, code, source, result_type, effective_at, **kwargs)  # noqa: E501
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the get_virtual_document_rows_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
+        return self.get_virtual_document_rows_with_http_info(scope, code, source, result_type, effective_at, as_at, page, limit, filter, **kwargs)  # noqa: E501
 
-    def get_virtual_document_rows_with_http_info(self, scope, code, source, result_type, effective_at, **kwargs):  # noqa: E501
+    @validate_arguments
+    def get_virtual_document_rows_with_http_info(self, scope : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[constr(strict=True, max_length=256, min_length=1), 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[constr(strict=True, max_length=500, min_length=1)], 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, le=5000, ge=1)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], 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
         """[EARLY ACCESS] 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
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.get_virtual_document_rows_with_http_info(scope, code, source, result_type, effective_at, async_req=True)
+        >>> thread = api.get_virtual_document_rows_with_http_info(scope, code, source, result_type, effective_at, as_at, page, limit, filter, async_req=True)
         >>> result = thread.get()
 
         :param scope: The scope in which to retrieve the virtual document. (required)
@@ -332,30 +1200,31 @@ class StructuredResultDataApi(object):
         :type filter: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :type _return_http_data_only: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
         :type _preload_content: bool, optional
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
         :param _request_auth: set to override the auth_settings for an a single
                               request; this effectively ignores the authentication
                               in the spec for a single request.
         :type _request_auth: dict, optional
-        :return: Returns the result object, the HTTP status code, and the headers.
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: (PagedResourceListOfVirtualRow, int, HTTPHeaderDict)
+        :rtype: tuple(PagedResourceListOfVirtualRow, status_code(int), headers(HTTPHeaderDict))
         """
 
-        local_var_params = locals()
+        _params = locals()
 
-        all_params = [
+        _all_params = [
             'scope',
             'code',
             'source',
@@ -366,152 +1235,431 @@ class StructuredResultDataApi(object):
             'limit',
             'filter'
         ]
-        all_params.extend(
+        _all_params.extend(
             [
                 'async_req',
                 '_return_http_data_only',
                 '_preload_content',
                 '_request_timeout',
                 '_request_auth',
-                '_headers'
+                '_content_type',
+                '_headers',
+                'opts'
             ]
         )
 
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_virtual_document_rows" % key
+                    " to method get_virtual_document_rows" % _key
                 )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'scope' is set
-        if self.api_client.client_side_validation and ('scope' not in local_var_params or  # noqa: E501
-                                                        local_var_params['scope'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `scope` when calling `get_virtual_document_rows`")  # noqa: E501
-        # verify the required parameter 'code' is set
-        if self.api_client.client_side_validation and ('code' not in local_var_params or  # noqa: E501
-                                                        local_var_params['code'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `code` when calling `get_virtual_document_rows`")  # noqa: E501
-        # verify the required parameter 'source' is set
-        if self.api_client.client_side_validation and ('source' not in local_var_params or  # noqa: E501
-                                                        local_var_params['source'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `source` when calling `get_virtual_document_rows`")  # noqa: E501
-        # verify the required parameter 'result_type' is set
-        if self.api_client.client_side_validation and ('result_type' not in local_var_params or  # noqa: E501
-                                                        local_var_params['result_type'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `result_type` when calling `get_virtual_document_rows`")  # noqa: E501
-        # verify the required parameter 'effective_at' is set
-        if self.api_client.client_side_validation and ('effective_at' not in local_var_params or  # noqa: E501
-                                                        local_var_params['effective_at'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `effective_at` when calling `get_virtual_document_rows`")  # noqa: E501
-
-        if self.api_client.client_side_validation and ('scope' in local_var_params and  # noqa: E501
-                                                        len(local_var_params['scope']) > 256):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `scope` when calling `get_virtual_document_rows`, length must be less than or equal to `256`")  # noqa: E501
-        if self.api_client.client_side_validation and ('scope' in local_var_params and  # noqa: E501
-                                                        len(local_var_params['scope']) < 1):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `scope` when calling `get_virtual_document_rows`, length must be greater than or equal to `1`")  # noqa: E501
-        if self.api_client.client_side_validation and 'scope' in local_var_params and not re.search(r'^[a-zA-Z0-9\-_]+$', local_var_params['scope']):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `scope` when calling `get_virtual_document_rows`, must conform to the pattern `/^[a-zA-Z0-9\-_]+$/`")  # noqa: E501
-        if self.api_client.client_side_validation and ('code' in local_var_params and  # noqa: E501
-                                                        len(local_var_params['code']) > 256):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `code` when calling `get_virtual_document_rows`, length must be less than or equal to `256`")  # noqa: E501
-        if self.api_client.client_side_validation and ('code' in local_var_params and  # noqa: E501
-                                                        len(local_var_params['code']) < 1):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `code` when calling `get_virtual_document_rows`, length must be greater than or equal to `1`")  # noqa: E501
-        if self.api_client.client_side_validation and 'code' in local_var_params and not re.search(r'^[a-zA-Z0-9\-_]+$', local_var_params['code']):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `code` when calling `get_virtual_document_rows`, must conform to the pattern `/^[a-zA-Z0-9\-_]+$/`")  # noqa: E501
-        if self.api_client.client_side_validation and ('source' in local_var_params and  # noqa: E501
-                                                        len(local_var_params['source']) > 256):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `source` when calling `get_virtual_document_rows`, length must be less than or equal to `256`")  # noqa: E501
-        if self.api_client.client_side_validation and ('source' in local_var_params and  # noqa: E501
-                                                        len(local_var_params['source']) < 1):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `source` when calling `get_virtual_document_rows`, length must be greater than or equal to `1`")  # noqa: E501
-        if self.api_client.client_side_validation and 'source' in local_var_params and not re.search(r'^[a-zA-Z0-9\-_]+$', local_var_params['source']):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `source` when calling `get_virtual_document_rows`, must conform to the pattern `/^[a-zA-Z0-9\-_]+$/`")  # noqa: E501
-        if self.api_client.client_side_validation and ('page' in local_var_params and  # noqa: E501
-                                                        len(local_var_params['page']) > 500):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `page` when calling `get_virtual_document_rows`, length must be less than or equal to `500`")  # noqa: E501
-        if self.api_client.client_side_validation and ('page' in local_var_params and  # noqa: E501
-                                                        len(local_var_params['page']) < 1):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `page` when calling `get_virtual_document_rows`, length must be greater than or equal to `1`")  # noqa: E501
-        if self.api_client.client_side_validation and 'page' in local_var_params and not re.search(r'^[a-zA-Z0-9\+\/]*={0,3}$', local_var_params['page']):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `page` when calling `get_virtual_document_rows`, must conform to the pattern `/^[a-zA-Z0-9\+\/]*={0,3}$/`")  # noqa: E501
-        if self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params['limit'] > 5000:  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `limit` when calling `get_virtual_document_rows`, must be a value less than or equal to `5000`")  # noqa: E501
-        if self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params['limit'] < 1:  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `limit` when calling `get_virtual_document_rows`, must be a value greater than or equal to `1`")  # noqa: E501
-        if self.api_client.client_side_validation and ('filter' in local_var_params and  # noqa: E501
-                                                        len(local_var_params['filter']) > 16384):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `filter` when calling `get_virtual_document_rows`, length must be less than or equal to `16384`")  # noqa: E501
-        if self.api_client.client_side_validation and ('filter' in local_var_params and  # noqa: E501
-                                                        len(local_var_params['filter']) < 0):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `filter` when calling `get_virtual_document_rows`, length must be greater than or equal to `0`")  # noqa: E501
-        if self.api_client.client_side_validation and 'filter' in local_var_params and not re.search(r'^[\s\S]*$', local_var_params['filter']):  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `filter` when calling `get_virtual_document_rows`, must conform to the pattern `/^[\s\S]*$/`")  # noqa: E501
-        collection_formats = {}
-
-        path_params = {}
-        if 'scope' in local_var_params:
-            path_params['scope'] = local_var_params['scope']  # noqa: E501
-        if 'code' in local_var_params:
-            path_params['code'] = local_var_params['code']  # noqa: E501
-        if 'source' in local_var_params:
-            path_params['source'] = local_var_params['source']  # noqa: E501
-        if 'result_type' in local_var_params:
-            path_params['resultType'] = local_var_params['result_type']  # noqa: E501
-
-        query_params = []
-        if 'effective_at' in local_var_params and local_var_params['effective_at'] is not None:  # noqa: E501
-            query_params.append(('effectiveAt', local_var_params['effective_at']))  # noqa: E501
-        if 'as_at' in local_var_params and local_var_params['as_at'] is not None:  # noqa: E501
-            query_params.append(('asAt', local_var_params['as_at']))  # noqa: E501
-        if 'page' in local_var_params and local_var_params['page'] is not None:  # noqa: E501
-            query_params.append(('page', local_var_params['page']))  # noqa: E501
-        if 'limit' in local_var_params and local_var_params['limit'] is not None:  # noqa: E501
-            query_params.append(('limit', local_var_params['limit']))  # noqa: E501
-        if 'filter' in local_var_params and local_var_params['filter'] is not None:  # noqa: E501
-            query_params.append(('filter', local_var_params['filter']))  # noqa: E501
-
-        header_params = dict(local_var_params.get('_headers', {}))
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
-            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params['scope']:
+            _path_params['scope'] = _params['scope']
+
+        if _params['code']:
+            _path_params['code'] = _params['code']
+
+        if _params['source']:
+            _path_params['source'] = _params['source']
+
+        if _params['result_type']:
+            _path_params['resultType'] = _params['result_type']
+
+
+        # process the query parameters
+        _query_params = []
+        if _params.get('effective_at') is not None:  # noqa: E501
+            _query_params.append(('effectiveAt', _params['effective_at']))
 
-        header_params['Accept-Encoding'] = "gzip, deflate, br"
+        if _params.get('as_at') is not None:  # noqa: E501
+            if isinstance(_params['as_at'], datetime):
+                _query_params.append(('asAt', _params['as_at'].strftime(self.api_client.configuration.datetime_format)))
+            else:
+                _query_params.append(('asAt', _params['as_at']))
 
+        if _params.get('page') is not None:  # noqa: E501
+            _query_params.append(('page', _params['page']))
 
-        # set the LUSID header
-        header_params['X-LUSID-SDK-Language'] = 'Python'
-        header_params['X-LUSID-SDK-Version'] = '1.1.131'
+        if _params.get('limit') is not None:  # noqa: E501
+            _query_params.append(('limit', _params['limit']))
 
-        # Authentication setting
-        auth_settings = ['oauth2']  # noqa: E501
+        if _params.get('filter') is not None:  # noqa: E501
+            _query_params.append(('filter', _params['filter']))
 
-        response_types_map = {
-            200: "PagedResourceListOfVirtualRow",
-            400: "LusidValidationProblemDetails",
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
+
+        _response_types_map = {
+            '200': "PagedResourceListOfVirtualRow",
+            '400': "LusidValidationProblemDetails",
         }
 
         return self.api_client.call_api(
             '/api/unitresults/virtualdocument/{scope}/{code}/{source}/{resultType}', 'GET',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_types_map=response_types_map,
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats,
-            _request_auth=local_var_params.get('_request_auth'))
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            opts=_params.get('opts'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
+    @overload
+    async def upsert_result_value(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), 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[constr(strict=True, max_length=64, min_length=1), 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[constr(strict=True, max_length=64, min_length=1), 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
+        """[EXPERIMENTAL] 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
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.upsert_result_value(scope, request_body, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope in which to construct the virtual documents. (required)
+        :type scope: str
+        :param request_body: The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID. (required)
+        :type request_body: Dict[str, UpsertResultValuesDataRequest]
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: UpsertStructuredDataResponse
+        """
+        kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the upsert_result_value_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
+        return self.upsert_result_value_with_http_info(scope, request_body, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def upsert_result_value_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), 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
+        """[EXPERIMENTAL] 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
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.upsert_result_value_with_http_info(scope, request_body, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope in which to construct the virtual documents. (required)
+        :type scope: str
+        :param request_body: The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID. (required)
+        :type request_body: Dict[str, UpsertResultValuesDataRequest]
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
+        :type _preload_content: bool, optional
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(UpsertStructuredDataResponse, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = [
+            'scope',
+            'request_body'
+        ]
+        _all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout',
+                '_request_auth',
+                '_content_type',
+                '_headers',
+                'opts'
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method upsert_result_value" % _key
+                )
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params['scope']:
+            _path_params['scope'] = _params['scope']
+
+
+        # process the query parameters
+        _query_params = []
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params['request_body'] is not None:
+            _body_params = _params['request_body']
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get('_content_type',
+            self.api_client.select_header_content_type(
+                ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json']))
+        if _content_types_list:
+                _header_params['Content-Type'] = _content_types_list
+
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
+
+        _response_types_map = {
+            '200': "UpsertStructuredDataResponse",
+            '400': "LusidValidationProblemDetails",
+        }
+
+        return self.api_client.call_api(
+            '/api/unitresults/resultvalue/{scope}', 'POST',
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            opts=_params.get('opts'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
+    @overload
+    async def upsert_structured_result_data(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), 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[constr(strict=True, max_length=64, min_length=1), 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[constr(strict=True, max_length=64, min_length=1), 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
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.upsert_structured_result_data(scope, request_body, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope in which to create or update data items. (required)
+        :type scope: str
+        :param request_body: The set of data items to create or update, keyed by a unique, ephemeral correlation ID. (required)
+        :type request_body: Dict[str, UpsertStructuredResultDataRequest]
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: UpsertStructuredDataResponse
+        """
+        kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the upsert_structured_result_data_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
+        return self.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[constr(strict=True, max_length=64, min_length=1), 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
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.upsert_structured_result_data_with_http_info(scope, request_body, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope in which to create or update data items. (required)
+        :type scope: str
+        :param request_body: The set of data items to create or update, keyed by a unique, ephemeral correlation ID. (required)
+        :type request_body: Dict[str, UpsertStructuredResultDataRequest]
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
+        :type _preload_content: bool, optional
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(UpsertStructuredDataResponse, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = [
+            'scope',
+            'request_body'
+        ]
+        _all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout',
+                '_request_auth',
+                '_content_type',
+                '_headers',
+                'opts'
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method upsert_structured_result_data" % _key
+                )
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params['scope']:
+            _path_params['scope'] = _params['scope']
+
+
+        # process the query parameters
+        _query_params = []
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params['request_body'] is not None:
+            _body_params = _params['request_body']
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get('_content_type',
+            self.api_client.select_header_content_type(
+                ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json']))
+        if _content_types_list:
+                _header_params['Content-Type'] = _content_types_list
+
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
+
+        _response_types_map = {
+            '200': "UpsertStructuredDataResponse",
+            '400': "LusidValidationProblemDetails",
+        }
+
+        return self.api_client.call_api(
+            '/api/unitresults/{scope}', 'POST',
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            opts=_params.get('opts'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))