lusid-sdk 2.1.891__py3-none-any.whl → 2.1.893__py3-none-any.whl

lusid/api/investor_records_api.py

@@ -59,30 +59,32 @@ class InvestorRecordsApi:
 
 
     @overload
-    async def delete_investor_record(self, id_type_scope : Annotated[StrictStr, Field(..., description="The scope of the investor record identifier type.")], id_type_code : Annotated[StrictStr, Field(..., description="The code of the investor record identifier type.")], code : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code. This together with defined              identifier type uniquely identifies the investor record to delete.")], **kwargs) -> DeletedEntityResponse:  # noqa: E501
+    async def delete_investor_record(self, identifier_type : Annotated[StrictStr, Field(..., description="Code of the investor record identifier type.")], identifier_value : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code.")], scope : Annotated[StrictStr, Field(..., description="The scope of the investor record entity.")], identifier_scope : Annotated[StrictStr, Field(..., description="Scope of the investor record identifier type.")], **kwargs) -> DeletedEntityResponse:  # noqa: E501
         ...
 
     @overload
-    def delete_investor_record(self, id_type_scope : Annotated[StrictStr, Field(..., description="The scope of the investor record identifier type.")], id_type_code : Annotated[StrictStr, Field(..., description="The code of the investor record identifier type.")], code : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code. This together with defined              identifier type uniquely identifies the investor record to delete.")], async_req: Optional[bool]=True, **kwargs) -> DeletedEntityResponse:  # noqa: E501
+    def delete_investor_record(self, identifier_type : Annotated[StrictStr, Field(..., description="Code of the investor record identifier type.")], identifier_value : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code.")], scope : Annotated[StrictStr, Field(..., description="The scope of the investor record entity.")], identifier_scope : Annotated[StrictStr, Field(..., description="Scope of the investor record identifier type.")], async_req: Optional[bool]=True, **kwargs) -> DeletedEntityResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def delete_investor_record(self, id_type_scope : Annotated[StrictStr, Field(..., description="The scope of the investor record identifier type.")], id_type_code : Annotated[StrictStr, Field(..., description="The code of the investor record identifier type.")], code : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code. This together with defined              identifier type uniquely identifies the investor record to delete.")], async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
+    def delete_investor_record(self, identifier_type : Annotated[StrictStr, Field(..., description="Code of the investor record identifier type.")], identifier_value : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code.")], scope : Annotated[StrictStr, Field(..., description="The scope of the investor record entity.")], identifier_scope : Annotated[StrictStr, Field(..., description="Scope of the investor record identifier type.")], async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
         """[EARLY ACCESS] DeleteInvestorRecord: Delete Investor Record  # noqa: E501
 
         Delete an investor record. Deletion will be valid from the investor record's creation datetime.  This means that the investor record will no longer exist at any effective datetime from the asAt datetime of deletion.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.delete_investor_record(id_type_scope, id_type_code, code, async_req=True)
+        >>> thread = api.delete_investor_record(identifier_type, identifier_value, scope, identifier_scope, async_req=True)
         >>> result = thread.get()
 
-        :param id_type_scope: The scope of the investor record identifier type. (required)
-        :type id_type_scope: str
-        :param id_type_code: The code of the investor record identifier type. (required)
-        :type id_type_code: str
-        :param code: Code of the investor record under specified identifier type's scope and code. This together with defined              identifier type uniquely identifies the investor record to delete. (required)
-        :type code: str
+        :param identifier_type: Code of the investor record identifier type. (required)
+        :type identifier_type: str
+        :param identifier_value: Code of the investor record under specified identifier type's scope and code. (required)
+        :type identifier_value: str
+        :param scope: The scope of the investor record entity. (required)
+        :type scope: str
+        :param identifier_scope: Scope of the investor record identifier type. (required)
+        :type identifier_scope: 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
@@ -99,25 +101,27 @@ class InvestorRecordsApi:
             raise ValueError(message)
         if async_req is not None:
             kwargs['async_req'] = async_req
-        return self.delete_investor_record_with_http_info(id_type_scope, id_type_code, code, **kwargs)  # noqa: E501
+        return self.delete_investor_record_with_http_info(identifier_type, identifier_value, scope, identifier_scope, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def delete_investor_record_with_http_info(self, id_type_scope : Annotated[StrictStr, Field(..., description="The scope of the investor record identifier type.")], id_type_code : Annotated[StrictStr, Field(..., description="The code of the investor record identifier type.")], code : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code. This together with defined              identifier type uniquely identifies the investor record to delete.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def delete_investor_record_with_http_info(self, identifier_type : Annotated[StrictStr, Field(..., description="Code of the investor record identifier type.")], identifier_value : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code.")], scope : Annotated[StrictStr, Field(..., description="The scope of the investor record entity.")], identifier_scope : Annotated[StrictStr, Field(..., description="Scope of the investor record identifier type.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] DeleteInvestorRecord: Delete Investor Record  # noqa: E501
 
         Delete an investor record. Deletion will be valid from the investor record's creation datetime.  This means that the investor record will no longer exist at any effective datetime from the asAt datetime of deletion.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.delete_investor_record_with_http_info(id_type_scope, id_type_code, code, async_req=True)
+        >>> thread = api.delete_investor_record_with_http_info(identifier_type, identifier_value, scope, identifier_scope, async_req=True)
         >>> result = thread.get()
 
-        :param id_type_scope: The scope of the investor record identifier type. (required)
-        :type id_type_scope: str
-        :param id_type_code: The code of the investor record identifier type. (required)
-        :type id_type_code: str
-        :param code: Code of the investor record under specified identifier type's scope and code. This together with defined              identifier type uniquely identifies the investor record to delete. (required)
-        :type code: str
+        :param identifier_type: Code of the investor record identifier type. (required)
+        :type identifier_type: str
+        :param identifier_value: Code of the investor record under specified identifier type's scope and code. (required)
+        :type identifier_value: str
+        :param scope: The scope of the investor record entity. (required)
+        :type scope: str
+        :param identifier_scope: Scope of the investor record identifier type. (required)
+        :type identifier_scope: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -145,9 +149,10 @@ class InvestorRecordsApi:
         _params = locals()
 
         _all_params = [
-            'id_type_scope',
-            'id_type_code',
-            'code'
+            'identifier_type',
+            'identifier_value',
+            'scope',
+            'identifier_scope'
         ]
         _all_params.extend(
             [
@@ -176,18 +181,21 @@ class InvestorRecordsApi:
 
         # process the path parameters
         _path_params = {}
-        if _params['id_type_scope']:
-            _path_params['idTypeScope'] = _params['id_type_scope']
+        if _params['identifier_type']:
+            _path_params['identifierType'] = _params['identifier_type']
 
-        if _params['id_type_code']:
-            _path_params['idTypeCode'] = _params['id_type_code']
-
-        if _params['code']:
-            _path_params['code'] = _params['code']
+        if _params['identifier_value']:
+            _path_params['identifierValue'] = _params['identifier_value']
 
 
         # process the query parameters
         _query_params = []
+        if _params.get('scope') is not None:  # noqa: E501
+            _query_params.append(('scope', _params['scope']))
+
+        if _params.get('identifier_scope') is not None:  # noqa: E501
+            _query_params.append(('identifierScope', _params['identifier_scope']))
+
         # process the header parameters
         _header_params = dict(_params.get('_headers', {}))
         # process the form parameters
@@ -208,7 +216,7 @@ class InvestorRecordsApi:
         }
 
         return self.api_client.call_api(
-            '/api/investorrecords/{idTypeScope}/{idTypeCode}/{code}', 'DELETE',
+            '/api/investorrecords/{identifierType}/{identifierValue}', 'DELETE',
             _path_params,
             _query_params,
             _header_params,
@@ -227,30 +235,32 @@ class InvestorRecordsApi:
 
 
     @overload
-    async def get_investor_record(self, id_type_scope : Annotated[StrictStr, Field(..., description="Scope of the investor record identifier type.")], id_type_code : Annotated[StrictStr, Field(..., description="Code of the investor record identifier type.")], code : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code. This together with stated identifier type uniquely              identifies the investor record.")], property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys or identifier types (as property keys) from the \"InvestorRecord\" domain              to include for found investor record, or from any domain that supports relationships to decorate onto related entities.              These take the format {domain}/{scope}/{code} e.g. \"InvestorRecord/ContactDetails/Address\".")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the investor record. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the investor record. Defaults to return the latest version of the investor record if not specified.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the investor record in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> InvestorRecord:  # noqa: E501
+    async def get_investor_record(self, identifier_type : Annotated[StrictStr, Field(..., description="Code of the investor record identifier type.")], identifier_value : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code.")], scope : Annotated[StrictStr, Field(..., description="The scope of the investor record entity.")], identifier_scope : Annotated[StrictStr, Field(..., description="Scope of the investor record identifier type.")], property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys or identifier types (as property keys) from the \"InvestorRecord\" domain              to include for found investor record, or from any domain that supports relationships to decorate onto related entities.              These take the format {domain}/{scope}/{code} e.g. \"InvestorRecord/ContactDetails/Address\".")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the investor record. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the investor record. Defaults to return the latest version of the investor record if not specified.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the investor record in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> InvestorRecord:  # noqa: E501
         ...
 
     @overload
-    def get_investor_record(self, id_type_scope : Annotated[StrictStr, Field(..., description="Scope of the investor record identifier type.")], id_type_code : Annotated[StrictStr, Field(..., description="Code of the investor record identifier type.")], code : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code. This together with stated identifier type uniquely              identifies the investor record.")], property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys or identifier types (as property keys) from the \"InvestorRecord\" domain              to include for found investor record, or from any domain that supports relationships to decorate onto related entities.              These take the format {domain}/{scope}/{code} e.g. \"InvestorRecord/ContactDetails/Address\".")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the investor record. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the investor record. Defaults to return the latest version of the investor record if not specified.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the investor record in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, async_req: Optional[bool]=True, **kwargs) -> InvestorRecord:  # noqa: E501
+    def get_investor_record(self, identifier_type : Annotated[StrictStr, Field(..., description="Code of the investor record identifier type.")], identifier_value : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code.")], scope : Annotated[StrictStr, Field(..., description="The scope of the investor record entity.")], identifier_scope : Annotated[StrictStr, Field(..., description="Scope of the investor record identifier type.")], property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys or identifier types (as property keys) from the \"InvestorRecord\" domain              to include for found investor record, or from any domain that supports relationships to decorate onto related entities.              These take the format {domain}/{scope}/{code} e.g. \"InvestorRecord/ContactDetails/Address\".")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the investor record. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the investor record. Defaults to return the latest version of the investor record if not specified.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the investor record in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, async_req: Optional[bool]=True, **kwargs) -> InvestorRecord:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_investor_record(self, id_type_scope : Annotated[StrictStr, Field(..., description="Scope of the investor record identifier type.")], id_type_code : Annotated[StrictStr, Field(..., description="Code of the investor record identifier type.")], code : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code. This together with stated identifier type uniquely              identifies the investor record.")], property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys or identifier types (as property keys) from the \"InvestorRecord\" domain              to include for found investor record, or from any domain that supports relationships to decorate onto related entities.              These take the format {domain}/{scope}/{code} e.g. \"InvestorRecord/ContactDetails/Address\".")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the investor record. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the investor record. Defaults to return the latest version of the investor record if not specified.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the investor record in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[InvestorRecord, Awaitable[InvestorRecord]]:  # noqa: E501
+    def get_investor_record(self, identifier_type : Annotated[StrictStr, Field(..., description="Code of the investor record identifier type.")], identifier_value : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code.")], scope : Annotated[StrictStr, Field(..., description="The scope of the investor record entity.")], identifier_scope : Annotated[StrictStr, Field(..., description="Scope of the investor record identifier type.")], property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys or identifier types (as property keys) from the \"InvestorRecord\" domain              to include for found investor record, or from any domain that supports relationships to decorate onto related entities.              These take the format {domain}/{scope}/{code} e.g. \"InvestorRecord/ContactDetails/Address\".")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the investor record. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the investor record. Defaults to return the latest version of the investor record if not specified.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the investor record in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[InvestorRecord, Awaitable[InvestorRecord]]:  # noqa: E501
         """[EARLY ACCESS] GetInvestorRecord: Get Investor Record  # noqa: E501
 
         Retrieve the definition of a investor record.  # 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_investor_record(id_type_scope, id_type_code, code, property_keys, effective_at, as_at, relationship_definition_ids, async_req=True)
+        >>> thread = api.get_investor_record(identifier_type, identifier_value, scope, identifier_scope, property_keys, effective_at, as_at, relationship_definition_ids, async_req=True)
         >>> result = thread.get()
 
-        :param id_type_scope: Scope of the investor record identifier type. (required)
-        :type id_type_scope: str
-        :param id_type_code: Code of the investor record identifier type. (required)
-        :type id_type_code: str
-        :param code: Code of the investor record under specified identifier type's scope and code. This together with stated identifier type uniquely              identifies the investor record. (required)
-        :type code: str
+        :param identifier_type: Code of the investor record identifier type. (required)
+        :type identifier_type: str
+        :param identifier_value: Code of the investor record under specified identifier type's scope and code. (required)
+        :type identifier_value: str
+        :param scope: The scope of the investor record entity. (required)
+        :type scope: str
+        :param identifier_scope: Scope of the investor record identifier type. (required)
+        :type identifier_scope: str
         :param property_keys: A list of property keys or identifier types (as property keys) from the \"InvestorRecord\" domain              to include for found investor record, or from any domain that supports relationships to decorate onto related entities.              These take the format {domain}/{scope}/{code} e.g. \"InvestorRecord/ContactDetails/Address\".
         :type property_keys: List[str]
         :param effective_at: The effective datetime or cut label at which to retrieve the investor record. Defaults to the current LUSID system datetime if not specified.
@@ -275,25 +285,27 @@ class InvestorRecordsApi:
             raise ValueError(message)
         if async_req is not None:
             kwargs['async_req'] = async_req
-        return self.get_investor_record_with_http_info(id_type_scope, id_type_code, code, property_keys, effective_at, as_at, relationship_definition_ids, **kwargs)  # noqa: E501
+        return self.get_investor_record_with_http_info(identifier_type, identifier_value, scope, identifier_scope, property_keys, effective_at, as_at, relationship_definition_ids, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_investor_record_with_http_info(self, id_type_scope : Annotated[StrictStr, Field(..., description="Scope of the investor record identifier type.")], id_type_code : Annotated[StrictStr, Field(..., description="Code of the investor record identifier type.")], code : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code. This together with stated identifier type uniquely              identifies the investor record.")], property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys or identifier types (as property keys) from the \"InvestorRecord\" domain              to include for found investor record, or from any domain that supports relationships to decorate onto related entities.              These take the format {domain}/{scope}/{code} e.g. \"InvestorRecord/ContactDetails/Address\".")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the investor record. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the investor record. Defaults to return the latest version of the investor record if not specified.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the investor record in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_investor_record_with_http_info(self, identifier_type : Annotated[StrictStr, Field(..., description="Code of the investor record identifier type.")], identifier_value : Annotated[StrictStr, Field(..., description="Code of the investor record under specified identifier type's scope and code.")], scope : Annotated[StrictStr, Field(..., description="The scope of the investor record entity.")], identifier_scope : Annotated[StrictStr, Field(..., description="Scope of the investor record identifier type.")], property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys or identifier types (as property keys) from the \"InvestorRecord\" domain              to include for found investor record, or from any domain that supports relationships to decorate onto related entities.              These take the format {domain}/{scope}/{code} e.g. \"InvestorRecord/ContactDetails/Address\".")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the investor record. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the investor record. Defaults to return the latest version of the investor record if not specified.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the investor record in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] GetInvestorRecord: Get Investor Record  # noqa: E501
 
         Retrieve the definition of a investor record.  # 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_investor_record_with_http_info(id_type_scope, id_type_code, code, property_keys, effective_at, as_at, relationship_definition_ids, async_req=True)
+        >>> thread = api.get_investor_record_with_http_info(identifier_type, identifier_value, scope, identifier_scope, property_keys, effective_at, as_at, relationship_definition_ids, async_req=True)
         >>> result = thread.get()
 
-        :param id_type_scope: Scope of the investor record identifier type. (required)
-        :type id_type_scope: str
-        :param id_type_code: Code of the investor record identifier type. (required)
-        :type id_type_code: str
-        :param code: Code of the investor record under specified identifier type's scope and code. This together with stated identifier type uniquely              identifies the investor record. (required)
-        :type code: str
+        :param identifier_type: Code of the investor record identifier type. (required)
+        :type identifier_type: str
+        :param identifier_value: Code of the investor record under specified identifier type's scope and code. (required)
+        :type identifier_value: str
+        :param scope: The scope of the investor record entity. (required)
+        :type scope: str
+        :param identifier_scope: Scope of the investor record identifier type. (required)
+        :type identifier_scope: str
         :param property_keys: A list of property keys or identifier types (as property keys) from the \"InvestorRecord\" domain              to include for found investor record, or from any domain that supports relationships to decorate onto related entities.              These take the format {domain}/{scope}/{code} e.g. \"InvestorRecord/ContactDetails/Address\".
         :type property_keys: List[str]
         :param effective_at: The effective datetime or cut label at which to retrieve the investor record. Defaults to the current LUSID system datetime if not specified.
@@ -329,9 +341,10 @@ class InvestorRecordsApi:
         _params = locals()
 
         _all_params = [
-            'id_type_scope',
-            'id_type_code',
-            'code',
+            'identifier_type',
+            'identifier_value',
+            'scope',
+            'identifier_scope',
             'property_keys',
             'effective_at',
             'as_at',
@@ -364,18 +377,21 @@ class InvestorRecordsApi:
 
         # process the path parameters
         _path_params = {}
-        if _params['id_type_scope']:
-            _path_params['idTypeScope'] = _params['id_type_scope']
+        if _params['identifier_type']:
+            _path_params['identifierType'] = _params['identifier_type']
 
-        if _params['id_type_code']:
-            _path_params['idTypeCode'] = _params['id_type_code']
-
-        if _params['code']:
-            _path_params['code'] = _params['code']
+        if _params['identifier_value']:
+            _path_params['identifierValue'] = _params['identifier_value']
 
 
         # process the query parameters
         _query_params = []
+        if _params.get('scope') is not None:  # noqa: E501
+            _query_params.append(('scope', _params['scope']))
+
+        if _params.get('identifier_scope') is not None:  # noqa: E501
+            _query_params.append(('identifierScope', _params['identifier_scope']))
+
         if _params.get('property_keys') is not None:  # noqa: E501
             _query_params.append(('propertyKeys', _params['property_keys']))
             _collection_formats['propertyKeys'] = 'multi'
@@ -413,7 +429,7 @@ class InvestorRecordsApi:
         }
 
         return self.api_client.call_api(
-            '/api/investorrecords/{idTypeScope}/{idTypeCode}/{code}', 'GET',
+            '/api/investorrecords/{identifierType}/{identifierValue}', 'GET',
             _path_params,
             _query_params,
             _header_params,

lusid/api/orders_api.py

@@ -399,15 +399,15 @@ class OrdersApi:
 
 
     @overload
-    async def list_orders(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the order. Defaults to return the latest version of the order if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing orders from a previous call to list orders.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Orders\" domain to decorate onto each order.                  These take the format {domain}/{scope}/{code} e.g. \"Orders/system/Name\".                  All properties, except derived properties, are returned by default, without specifying here.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Custom Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Custom Data Model to use")] = None, membership_type : Annotated[Optional[StrictStr], Field( description="The membership types of the specified Custom Data Model to return. Allowable values are Member, Candidate and All.")] = None, **kwargs) -> PagedResourceListOfOrder:  # noqa: E501
+    async def list_orders(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the order. Defaults to return the latest version of the order if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing orders from a previous call to list orders.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Orders\" domain to decorate onto each order.                  These take the format {domain}/{scope}/{code} e.g. \"Orders/system/Name\".                  All properties, except derived properties, are returned by default, without specifying here.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Custom Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Custom Data Model to use")] = None, membership_type : Annotated[Optional[StrictStr], Field( description="The membership types of the specified Custom Data Model to return. Allowable values are Member, Candidate and All. Defaults to Member.")] = None, **kwargs) -> PagedResourceListOfOrder:  # noqa: E501
         ...
 
     @overload
-    def list_orders(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the order. Defaults to return the latest version of the order if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing orders from a previous call to list orders.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Orders\" domain to decorate onto each order.                  These take the format {domain}/{scope}/{code} e.g. \"Orders/system/Name\".                  All properties, except derived properties, are returned by default, without specifying here.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Custom Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Custom Data Model to use")] = None, membership_type : Annotated[Optional[StrictStr], Field( description="The membership types of the specified Custom Data Model to return. Allowable values are Member, Candidate and All.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfOrder:  # noqa: E501
+    def list_orders(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the order. Defaults to return the latest version of the order if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing orders from a previous call to list orders.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Orders\" domain to decorate onto each order.                  These take the format {domain}/{scope}/{code} e.g. \"Orders/system/Name\".                  All properties, except derived properties, are returned by default, without specifying here.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Custom Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Custom Data Model to use")] = None, membership_type : Annotated[Optional[StrictStr], Field( description="The membership types of the specified Custom Data Model to return. Allowable values are Member, Candidate and All. Defaults to Member.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfOrder:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_orders(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the order. Defaults to return the latest version of the order if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing orders from a previous call to list orders.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Orders\" domain to decorate onto each order.                  These take the format {domain}/{scope}/{code} e.g. \"Orders/system/Name\".                  All properties, except derived properties, are returned by default, without specifying here.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Custom Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Custom Data Model to use")] = None, membership_type : Annotated[Optional[StrictStr], Field( description="The membership types of the specified Custom Data Model to return. Allowable values are Member, Candidate and All.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfOrder, Awaitable[PagedResourceListOfOrder]]:  # noqa: E501
+    def list_orders(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the order. Defaults to return the latest version of the order if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing orders from a previous call to list orders.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Orders\" domain to decorate onto each order.                  These take the format {domain}/{scope}/{code} e.g. \"Orders/system/Name\".                  All properties, except derived properties, are returned by default, without specifying here.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Custom Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Custom Data Model to use")] = None, membership_type : Annotated[Optional[StrictStr], Field( description="The membership types of the specified Custom Data Model to return. Allowable values are Member, Candidate and All. Defaults to Member.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfOrder, Awaitable[PagedResourceListOfOrder]]:  # noqa: E501
         """ListOrders: List Orders  # noqa: E501
 
         Fetch the last pre-AsAt date version of each order with optional filtering (does not fetch the entire history).  # noqa: E501
@@ -433,7 +433,7 @@ class OrdersApi:
         :type data_model_scope: str
         :param data_model_code: The optional code of a Custom Data Model to use
         :type data_model_code: str
-        :param membership_type: The membership types of the specified Custom Data Model to return. Allowable values are Member, Candidate and All.
+        :param membership_type: The membership types of the specified Custom Data Model to return. Allowable values are Member, Candidate and All. Defaults to Member.
         :type membership_type: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -454,7 +454,7 @@ class OrdersApi:
         return self.list_orders_with_http_info(as_at, page, sort_by, limit, filter, property_keys, data_model_scope, data_model_code, membership_type, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_orders_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the order. Defaults to return the latest version of the order if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing orders from a previous call to list orders.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Orders\" domain to decorate onto each order.                  These take the format {domain}/{scope}/{code} e.g. \"Orders/system/Name\".                  All properties, except derived properties, are returned by default, without specifying here.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Custom Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Custom Data Model to use")] = None, membership_type : Annotated[Optional[StrictStr], Field( description="The membership types of the specified Custom Data Model to return. Allowable values are Member, Candidate and All.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_orders_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the order. Defaults to return the latest version of the order if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing orders from a previous call to list orders.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Orders\" domain to decorate onto each order.                  These take the format {domain}/{scope}/{code} e.g. \"Orders/system/Name\".                  All properties, except derived properties, are returned by default, without specifying here.")] = None, data_model_scope : Annotated[Optional[StrictStr], Field( description="The optional scope of a Custom Data Model to use")] = None, data_model_code : Annotated[Optional[StrictStr], Field( description="The optional code of a Custom Data Model to use")] = None, membership_type : Annotated[Optional[StrictStr], Field( description="The membership types of the specified Custom Data Model to return. Allowable values are Member, Candidate and All. Defaults to Member.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """ListOrders: List Orders  # noqa: E501
 
         Fetch the last pre-AsAt date version of each order with optional filtering (does not fetch the entire history).  # noqa: E501
@@ -480,7 +480,7 @@ class OrdersApi:
         :type data_model_scope: str
         :param data_model_code: The optional code of a Custom Data Model to use
         :type data_model_code: str
-        :param membership_type: The membership types of the specified Custom Data Model to return. Allowable values are Member, Candidate and All.
+        :param membership_type: The membership types of the specified Custom Data Model to return. Allowable values are Member, Candidate and All. Defaults to Member.
         :type membership_type: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional

lusid/configuration.py

@@ -445,7 +445,7 @@ class Configuration:
         return "Python SDK Debug Report:\n"\
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
-               "Version of the API: 0.11.8111\n"\
+               "Version of the API: 0.11.8121\n"\
                "SDK Package Version: {package_version}".\
                format(env=sys.platform, pyversion=sys.version, package_version=package_version)
 

lusid/models/account_holder.py

@@ -28,10 +28,11 @@ class AccountHolder(BaseModel):
     An Account Holder of an Investment Account.  # noqa: E501
     """
     key:  Optional[StrictStr] = Field(None,alias="key", description="A client-defined key used to identify the Account Holder, unique within the Investment Account") 
+    scope:  Optional[StrictStr] = Field(None,alias="scope", description="The scope in which the Investor Record lies.") 
     identifiers: Optional[Dict[str, ModelProperty]] = Field(None, description="Single Account Holder identifier that should target the desired Investor Record.")
     entity_unique_id:  Optional[StrictStr] = Field(None,alias="entityUniqueId", description="The unique InvestorRecord entity identifier") 
     investor_record: Optional[InvestorRecord] = Field(None, alias="investorRecord")
-    __properties = ["key", "identifiers", "entityUniqueId", "investorRecord"]
+    __properties = ["key", "scope", "identifiers", "entityUniqueId", "investorRecord"]
 
     class Config:
         """Pydantic configuration"""
@@ -80,6 +81,11 @@ class AccountHolder(BaseModel):
         if self.key is None and "key" in self.__fields_set__:
             _dict['key'] = None
 
+        # set to None if scope (nullable) is None
+        # and __fields_set__ contains the field
+        if self.scope is None and "scope" in self.__fields_set__:
+            _dict['scope'] = None
+
         # set to None if identifiers (nullable) is None
         # and __fields_set__ contains the field
         if self.identifiers is None and "identifiers" in self.__fields_set__:
@@ -103,6 +109,7 @@ class AccountHolder(BaseModel):
 
         _obj = AccountHolder.parse_obj({
             "key": obj.get("key"),
+            "scope": obj.get("scope"),
             "identifiers": dict(
                 (_k, ModelProperty.from_dict(_v))
                 for _k, _v in obj.get("identifiers").items()

lusid/models/account_holder_identifier.py

@@ -27,8 +27,9 @@ class AccountHolderIdentifier(BaseModel):
     AccountHolderIdentifier
     """
     key:  StrictStr = Field(...,alias="key", description="A client-defined key used to identify the Account Holder, unique within the Investment Account") 
+    scope:  StrictStr = Field(...,alias="scope", description="The scope in which the Investor Record lies.") 
     identifiers: Dict[str, ModelProperty] = Field(..., description="Single Account Holder identifier that should target the desired Investor Record.")
-    __properties = ["key", "identifiers"]
+    __properties = ["key", "scope", "identifiers"]
 
     class Config:
         """Pydantic configuration"""
@@ -82,6 +83,7 @@ class AccountHolderIdentifier(BaseModel):
 
         _obj = AccountHolderIdentifier.parse_obj({
             "key": obj.get("key"),
+            "scope": obj.get("scope"),
             "identifiers": dict(
                 (_k, ModelProperty.from_dict(_v))
                 for _k, _v in obj.get("identifiers").items()

lusid/models/investment_account.py

@@ -31,19 +31,20 @@ class InvestmentAccount(BaseModel):
     """
     Representation of an Investment Account on the LUSID API  # noqa: E501
     """
-    lusid_investment_account_id:  Optional[StrictStr] = Field(None,alias="lusidInvestmentAccountId", description="The unique LUSID Investment Account Identifier of the Investment Account.") 
+    scope:  Optional[StrictStr] = Field(None,alias="scope", description="The scope in which the Investment Account lies.") 
+    identifiers: Optional[Dict[str, ModelProperty]] = Field(None, description="Unique client-defined identifiers of the Investment Account.")
     display_name:  Optional[StrictStr] = Field(None,alias="displayName", description="The display name of the Investment Account") 
     description:  Optional[StrictStr] = Field(None,alias="description", description="The description of the Investment Account") 
-    identifiers: Optional[Dict[str, ModelProperty]] = Field(None, description="Unique client-defined identifiers of the Investment Account.")
     account_type:  Optional[StrictStr] = Field(None,alias="accountType", description="The type of the of the Investment Account.") 
     account_holders: Optional[conlist(AccountHolder)] = Field(None, alias="accountHolders", description="The Account Holders of the Investment Account.")
     investment_portfolios: Optional[conlist(InvestmentPortfolio)] = Field(None, alias="investmentPortfolios", description="The Investment Portfolios of the Investment Account.")
+    lusid_investment_account_id:  Optional[StrictStr] = Field(None,alias="lusidInvestmentAccountId", description="The unique LUSID Investment Account Identifier of the Investment Account.") 
     properties: Optional[Dict[str, ModelProperty]] = Field(None, description="A set of properties associated to the Investment Account.")
     relationships: Optional[conlist(Relationship)] = Field(None, description="A set of relationships associated to the Investment Account.")
     href:  Optional[StrictStr] = Field(None,alias="href", description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.") 
     version: Optional[Version] = None
     links: Optional[conlist(Link)] = None
-    __properties = ["lusidInvestmentAccountId", "displayName", "description", "identifiers", "accountType", "accountHolders", "investmentPortfolios", "properties", "relationships", "href", "version", "links"]
+    __properties = ["scope", "identifiers", "displayName", "description", "accountType", "accountHolders", "investmentPortfolios", "lusidInvestmentAccountId", "properties", "relationships", "href", "version", "links"]
 
     class Config:
         """Pydantic configuration"""
@@ -122,10 +123,15 @@ class InvestmentAccount(BaseModel):
                 if _item:
                     _items.append(_item.to_dict())
             _dict['links'] = _items
-        # set to None if lusid_investment_account_id (nullable) is None
+        # set to None if scope (nullable) is None
         # and __fields_set__ contains the field
-        if self.lusid_investment_account_id is None and "lusid_investment_account_id" in self.__fields_set__:
-            _dict['lusidInvestmentAccountId'] = None
+        if self.scope is None and "scope" in self.__fields_set__:
+            _dict['scope'] = None
+
+        # set to None if identifiers (nullable) is None
+        # and __fields_set__ contains the field
+        if self.identifiers is None and "identifiers" in self.__fields_set__:
+            _dict['identifiers'] = None
 
         # set to None if display_name (nullable) is None
         # and __fields_set__ contains the field
@@ -137,11 +143,6 @@ class InvestmentAccount(BaseModel):
         if self.description is None and "description" in self.__fields_set__:
             _dict['description'] = None
 
-        # set to None if identifiers (nullable) is None
-        # and __fields_set__ contains the field
-        if self.identifiers is None and "identifiers" in self.__fields_set__:
-            _dict['identifiers'] = None
-
         # set to None if account_type (nullable) is None
         # and __fields_set__ contains the field
         if self.account_type is None and "account_type" in self.__fields_set__:
@@ -157,6 +158,11 @@ class InvestmentAccount(BaseModel):
         if self.investment_portfolios is None and "investment_portfolios" in self.__fields_set__:
             _dict['investmentPortfolios'] = None
 
+        # set to None if lusid_investment_account_id (nullable) is None
+        # and __fields_set__ contains the field
+        if self.lusid_investment_account_id is None and "lusid_investment_account_id" in self.__fields_set__:
+            _dict['lusidInvestmentAccountId'] = None
+
         # set to None if properties (nullable) is None
         # and __fields_set__ contains the field
         if self.properties is None and "properties" in self.__fields_set__:
@@ -189,18 +195,19 @@ class InvestmentAccount(BaseModel):
             return InvestmentAccount.parse_obj(obj)
 
         _obj = InvestmentAccount.parse_obj({
-            "lusid_investment_account_id": obj.get("lusidInvestmentAccountId"),
-            "display_name": obj.get("displayName"),
-            "description": obj.get("description"),
+            "scope": obj.get("scope"),
             "identifiers": dict(
                 (_k, ModelProperty.from_dict(_v))
                 for _k, _v in obj.get("identifiers").items()
             )
             if obj.get("identifiers") is not None
             else None,
+            "display_name": obj.get("displayName"),
+            "description": obj.get("description"),
             "account_type": obj.get("accountType"),
             "account_holders": [AccountHolder.from_dict(_item) for _item in obj.get("accountHolders")] if obj.get("accountHolders") is not None else None,
             "investment_portfolios": [InvestmentPortfolio.from_dict(_item) for _item in obj.get("investmentPortfolios")] if obj.get("investmentPortfolios") is not None else None,
+            "lusid_investment_account_id": obj.get("lusidInvestmentAccountId"),
             "properties": dict(
                 (_k, ModelProperty.from_dict(_v))
                 for _k, _v in obj.get("properties").items()