lusid-sdk 2.1.405__py3-none-any.whl → 2.1.423__py3-none-any.whl

lusid/api/instruments_api.py

@@ -78,7 +78,7 @@ class InstrumentsApi:
 
     @validate_arguments
     def batch_upsert_instrument_properties(self, request_body : Annotated[Dict[str, UpsertInstrumentPropertyRequest], Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, identifier_effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime used to resolve each instrument from the provided identifiers. Defaults to the current LUSID system datetime if not specified.")] = None, success_mode : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BatchUpsertInstrumentPropertiesResponse, Awaitable[BatchUpsertInstrumentPropertiesResponse]]:  # noqa: E501
-        """[EARLY ACCESS] BatchUpsertInstrumentProperties: Batch upsert instruments properties  # noqa: E501
+        """BatchUpsertInstrumentProperties: Batch upsert instruments properties  # noqa: E501
 
         Create or update one or more properties for particular instruments.    Each instrument property is updated if it exists and created if it does not. For any failures, a reason  is provided.    Properties have an <i>effectiveFrom</i> datetime from which the property is valid, and an <i>effectiveUntil</i>  datetime until which the property is valid. Not supplying an <i>effectiveUntil</i> datetime results in the property being  valid indefinitely, or until the next <i>effectiveFrom</i> datetime of the property.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -116,7 +116,7 @@ class InstrumentsApi:
 
     @validate_arguments
     def batch_upsert_instrument_properties_with_http_info(self, request_body : Annotated[Dict[str, UpsertInstrumentPropertyRequest], Field(..., description="A list of instruments and associated instrument properties to create or update.")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, identifier_effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime used to resolve each instrument from the provided identifiers. Defaults to the current LUSID system datetime if not specified.")] = None, success_mode : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] BatchUpsertInstrumentProperties: Batch upsert instruments properties  # noqa: E501
+        """BatchUpsertInstrumentProperties: Batch upsert instruments properties  # noqa: E501
 
         Create or update one or more properties for particular instruments.    Each instrument property is updated if it exists and created if it does not. For any failures, a reason  is provided.    Properties have an <i>effectiveFrom</i> datetime from which the property is valid, and an <i>effectiveUntil</i>  datetime until which the property is valid. Not supplying an <i>effectiveUntil</i> datetime results in the property being  valid indefinitely, or until the next <i>effectiveFrom</i> datetime of the property.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1886,7 +1886,7 @@ class InstrumentsApi:
 
     @validate_arguments
     def get_instrument_properties(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to list the instrument's properties.              Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the instrument's properties. Defaults to returning              the latest version of each property if not specified.")] = None, scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[InstrumentProperties, Awaitable[InstrumentProperties]]:  # noqa: E501
-        """[EARLY ACCESS] GetInstrumentProperties: Get instrument properties  # noqa: E501
+        """GetInstrumentProperties: Get instrument properties  # noqa: E501
 
         List all the properties of a particular instrument, as identified by a particular unique identifier.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1926,7 +1926,7 @@ class InstrumentsApi:
 
     @validate_arguments
     def get_instrument_properties_with_http_info(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to list the instrument's properties.              Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the instrument's properties. Defaults to returning              the latest version of each property if not specified.")] = None, scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] GetInstrumentProperties: Get instrument properties  # noqa: E501
+        """GetInstrumentProperties: Get instrument properties  # noqa: E501
 
         List all the properties of a particular instrument, as identified by a particular unique identifier.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -2072,7 +2072,7 @@ class InstrumentsApi:
 
     @validate_arguments
     def get_instrument_property_time_series(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], property_key : Annotated[StrictStr, Field(..., description="The property key of a property from the 'Instrument' domain whose history to retrieve.              This must have the format {domain}/{scope}/{code}, for example 'Instrument/system/Name'.")], identifier_effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime used to resolve the instrument from the identifier.              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 instrument's property history. Defaults to              returning the current datetime if not supplied.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], Field(description="Expression to filter the results. For more information about filtering,              see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, page : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="The pagination token to use to continue listing properties; this value is returned from              the previous call. If a pagination token is provided, the <i>filter</i>, <i>effectiveAt</i> and              <i>asAt</i> fields must not have changed since the original request. For more information, see              https://support.lusid.com/knowledgebase/article/KA-01915.")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="When paginating, limit the results to this number.")] = None, scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfPropertyInterval, Awaitable[ResourceListOfPropertyInterval]]:  # noqa: E501
-        """[EARLY ACCESS] GetInstrumentPropertyTimeSeries: Get instrument property time series  # noqa: E501
+        """GetInstrumentPropertyTimeSeries: Get instrument property time series  # noqa: E501
 
         Retrieve the complete time series (history) for a particular property of an instrument.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -2120,7 +2120,7 @@ class InstrumentsApi:
 
     @validate_arguments
     def get_instrument_property_time_series_with_http_info(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], property_key : Annotated[StrictStr, Field(..., description="The property key of a property from the 'Instrument' domain whose history to retrieve.              This must have the format {domain}/{scope}/{code}, for example 'Instrument/system/Name'.")], identifier_effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime used to resolve the instrument from the identifier.              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 instrument's property history. Defaults to              returning the current datetime if not supplied.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], Field(description="Expression to filter the results. For more information about filtering,              see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, page : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="The pagination token to use to continue listing properties; this value is returned from              the previous call. If a pagination token is provided, the <i>filter</i>, <i>effectiveAt</i> and              <i>asAt</i> fields must not have changed since the original request. For more information, see              https://support.lusid.com/knowledgebase/article/KA-01915.")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="When paginating, limit the results to this number.")] = None, scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] GetInstrumentPropertyTimeSeries: Get instrument property time series  # noqa: E501
+        """GetInstrumentPropertyTimeSeries: Get instrument property time series  # noqa: E501
 
         Retrieve the complete time series (history) for a particular property of an instrument.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/api/legal_entities_api.py

@@ -239,7 +239,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def delete_legal_entity_access_metadata(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the Legal Entity identifier.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the Legal Entity identifier.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the Legal Entity under specified identifier type's scope and code.")], metadata_key : Annotated[constr(strict=True, max_length=100, min_length=1), Field(..., description="Key of the metadata entry to retrieve")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective date to delete at, if this is not supplied, it will delete all data found")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective date until which the delete is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' date of the Access Metadata")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
-        """[EARLY ACCESS] DeleteLegalEntityAccessMetadata: Delete a Legal Entity Access Metadata entry  # noqa: E501
+        """DeleteLegalEntityAccessMetadata: Delete a Legal Entity Access Metadata entry  # noqa: E501
 
         Deletes the Legal Entity Access Metadata entry that exactly matches the provided identifier parts.    It is important to always check to verify success (or failure).  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -281,7 +281,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def delete_legal_entity_access_metadata_with_http_info(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the Legal Entity identifier.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the Legal Entity identifier.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the Legal Entity under specified identifier type's scope and code.")], metadata_key : Annotated[constr(strict=True, max_length=100, min_length=1), Field(..., description="Key of the metadata entry to retrieve")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective date to delete at, if this is not supplied, it will delete all data found")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective date until which the delete is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' date of the Access Metadata")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] DeleteLegalEntityAccessMetadata: Delete a Legal Entity Access Metadata entry  # noqa: E501
+        """DeleteLegalEntityAccessMetadata: Delete a Legal Entity Access Metadata entry  # noqa: E501
 
         Deletes the Legal Entity Access Metadata entry that exactly matches the provided identifier parts.    It is important to always check to verify success (or failure).  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -3332,7 +3332,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def upsert_legal_entity_access_metadata(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the Legal Entity identifier.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the Legal Entity identifier.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the Legal Entity under specified identifier type's scope and code.")], metadata_key : Annotated[constr(strict=True, max_length=100, min_length=1), Field(..., description="Key of the metadata entry to retrieve")], upsert_legal_entity_access_metadata_request : Annotated[UpsertLegalEntityAccessMetadataRequest, Field(..., description="The Legal Entity Access Metadata entry to upsert")], effective_at : Annotated[Optional[StrictStr], Field(description="The effectiveAt datetime at which to upsert the Access Metadata")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfAccessMetadataValueOf, Awaitable[ResourceListOfAccessMetadataValueOf]]:  # noqa: E501
-        """[EARLY ACCESS] UpsertLegalEntityAccessMetadata: Upsert a Legal Entity Access Metadata entry associated with a specific metadataKey. This creates or updates the data in LUSID.  # noqa: E501
+        """UpsertLegalEntityAccessMetadata: Upsert a Legal Entity Access Metadata entry associated with a specific metadataKey. This creates or updates the data in LUSID.  # noqa: E501
 
         Update or insert one Legal Entity Access Metadata entry in a single scope. An item will be updated if it already exists  and inserted if it does not.                The response will return the successfully updated or inserted Legal Entity Access Metadata rule or failure message if unsuccessful.                It is important to always check to verify success (or failure).                Multiple rules for a metadataKey can exist with different effective at dates, when resources are accessed the rule that is active for the current time will be fetched.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -3376,7 +3376,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def upsert_legal_entity_access_metadata_with_http_info(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the Legal Entity identifier.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the Legal Entity identifier.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the Legal Entity under specified identifier type's scope and code.")], metadata_key : Annotated[constr(strict=True, max_length=100, min_length=1), Field(..., description="Key of the metadata entry to retrieve")], upsert_legal_entity_access_metadata_request : Annotated[UpsertLegalEntityAccessMetadataRequest, Field(..., description="The Legal Entity Access Metadata entry to upsert")], effective_at : Annotated[Optional[StrictStr], Field(description="The effectiveAt datetime at which to upsert the Access Metadata")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] UpsertLegalEntityAccessMetadata: Upsert a Legal Entity Access Metadata entry associated with a specific metadataKey. This creates or updates the data in LUSID.  # noqa: E501
+        """UpsertLegalEntityAccessMetadata: Upsert a Legal Entity Access Metadata entry associated with a specific metadataKey. This creates or updates the data in LUSID.  # noqa: E501
 
         Update or insert one Legal Entity Access Metadata entry in a single scope. An item will be updated if it already exists  and inserted if it does not.                The response will return the successfully updated or inserted Legal Entity Access Metadata rule or failure message if unsuccessful.                It is important to always check to verify success (or failure).                Multiple rules for a metadataKey can exist with different effective at dates, when resources are accessed the rule that is active for the current time will be fetched.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/api/order_graph_api.py

@@ -59,7 +59,7 @@ class OrderGraphApi:
 
     @validate_arguments
     def list_order_graph_blocks(self, as_at : Annotated[Optional[datetime], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01832/")] = None, pagination_token : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01914/")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="Must be block-level properties. See https://support.lusid.com/knowledgebase/article/KA-01855/")] = None, use_compliance_v2 : Annotated[Optional[StrictBool], Field(description="Whether to use the V2 compliance engine when deriving compliance statuses for orders. (default: false)")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfOrderGraphBlock, Awaitable[PagedResourceListOfOrderGraphBlock]]:  # noqa: E501
-        """[EARLY ACCESS] ListOrderGraphBlocks: Lists blocks that pass the filter provided, and builds a summary picture of the state of their associated order entities.  # noqa: E501
+        """ListOrderGraphBlocks: Lists blocks that pass the filter provided, and builds a summary picture of the state of their associated order entities.  # noqa: E501
 
         Lists all blocks of orders, subject to the filter, along with the IDs of orders, placements, allocations and  executions in the block, the total quantities of each, and a simple text field describing the overall state.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -103,7 +103,7 @@ class OrderGraphApi:
 
     @validate_arguments
     def list_order_graph_blocks_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01832/")] = None, pagination_token : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01914/")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="Must be block-level properties. See https://support.lusid.com/knowledgebase/article/KA-01855/")] = None, use_compliance_v2 : Annotated[Optional[StrictBool], Field(description="Whether to use the V2 compliance engine when deriving compliance statuses for orders. (default: false)")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] ListOrderGraphBlocks: Lists blocks that pass the filter provided, and builds a summary picture of the state of their associated order entities.  # noqa: E501
+        """ListOrderGraphBlocks: Lists blocks that pass the filter provided, and builds a summary picture of the state of their associated order entities.  # noqa: E501
 
         Lists all blocks of orders, subject to the filter, along with the IDs of orders, placements, allocations and  executions in the block, the total quantities of each, and a simple text field describing the overall state.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -467,7 +467,7 @@ class OrderGraphApi:
 
     @validate_arguments
     def list_order_graph_placements(self, as_at : Annotated[Optional[datetime], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01832/")] = None, pagination_token : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01914/")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="Must be placement properties. See https://support.lusid.com/knowledgebase/article/KA-01855/")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfOrderGraphPlacement, Awaitable[PagedResourceListOfOrderGraphPlacement]]:  # noqa: E501
-        """[EARLY ACCESS] ListOrderGraphPlacements: Lists placements that pass the filter provided, and builds a summary picture of the state of their associated order entities.  # noqa: E501
+        """ListOrderGraphPlacements: Lists placements that pass the filter provided, and builds a summary picture of the state of their associated order entities.  # noqa: E501
 
         Lists all order placements, subject to the filter, along with the IDs of the block and order that the  placement is for, each placement's quantity, the IDs of all allocations and executions in the placement  and the total quantities of those, and a simple text field describing the overall state of the placement.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -509,7 +509,7 @@ class OrderGraphApi:
 
     @validate_arguments
     def list_order_graph_placements_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01832/")] = None, pagination_token : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01915/")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], Field(description="See https://support.lusid.com/knowledgebase/article/KA-01914/")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="Must be placement properties. See https://support.lusid.com/knowledgebase/article/KA-01855/")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] ListOrderGraphPlacements: Lists placements that pass the filter provided, and builds a summary picture of the state of their associated order entities.  # noqa: E501
+        """ListOrderGraphPlacements: Lists placements that pass the filter provided, and builds a summary picture of the state of their associated order entities.  # noqa: E501
 
         Lists all order placements, subject to the filter, along with the IDs of the block and order that the  placement is for, each placement's quantity, the IDs of all allocations and executions in the placement  and the total quantities of those, and a simple text field describing the overall state of the placement.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/api/portfolios_api.py

@@ -80,30 +80,30 @@ class PortfoliosApi:
         self.api_client = api_client
 
     @overload
-    async def batch_upsert_portfolio_access_metadata(self, batch_upsert_portfolio_access_metadata_request : Annotated[BatchUpsertPortfolioAccessMetadataRequest, Field(..., description="The Portfolio Access Metadata Rule to update or insert")], effective_at : Annotated[Optional[StrictStr], Field(description="The date this rule will effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective date until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' date of the Access Metadata")] = None, **kwargs) -> BatchUpsertPortfolioAccessMetadataResponse:  # noqa: E501
+    async def batch_upsert_portfolio_access_metadata(self, request_body : Annotated[Dict[str, BatchUpsertPortfolioAccessMetadataRequest], Field(..., description="The Access Metadata Rules to upsert and the Portfolio identifiers to upsert for")], effective_at : Annotated[Optional[StrictStr], Field(description="The date these rules will be effective from")] = None, effective_until : Annotated[Optional[StrictStr], Field(description="The effective date until which the Access Metadata is valid. If not supplied, this will be valid indefinitely, or until the next 'effectiveAt' date of the Access Metadata")] = None, **kwargs) -> BatchUpsertPortfolioAccessMetadataResponse:  # noqa: E501
         ...
 
     @overload
-    def batch_upsert_portfolio_access_metadata(self, batch_upsert_portfolio_access_metadata_request : Annotated[BatchUpsertPortfolioAccessMetadataRequest, Field(..., description="The Portfolio Access Metadata Rule to update or insert")], effective_at : Annotated[Optional[StrictStr], Field(description="The date this rule will effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective date until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' date of the Access Metadata")] = None, async_req: Optional[bool]=True, **kwargs) -> BatchUpsertPortfolioAccessMetadataResponse:  # noqa: E501
+    def batch_upsert_portfolio_access_metadata(self, request_body : Annotated[Dict[str, BatchUpsertPortfolioAccessMetadataRequest], Field(..., description="The Access Metadata Rules to upsert and the Portfolio identifiers to upsert for")], effective_at : Annotated[Optional[StrictStr], Field(description="The date these rules will be effective from")] = None, effective_until : Annotated[Optional[StrictStr], Field(description="The effective date until which the Access Metadata is valid. If not supplied, this will be valid indefinitely, or until the next 'effectiveAt' date of the Access Metadata")] = None, async_req: Optional[bool]=True, **kwargs) -> BatchUpsertPortfolioAccessMetadataResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def batch_upsert_portfolio_access_metadata(self, batch_upsert_portfolio_access_metadata_request : Annotated[BatchUpsertPortfolioAccessMetadataRequest, Field(..., description="The Portfolio Access Metadata Rule to update or insert")], effective_at : Annotated[Optional[StrictStr], Field(description="The date this rule will effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective date until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' date of the Access Metadata")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BatchUpsertPortfolioAccessMetadataResponse, Awaitable[BatchUpsertPortfolioAccessMetadataResponse]]:  # noqa: E501
-        """[EXPERIMENTAL] BatchUpsertPortfolioAccessMetadata: Upsert multiple portfolio access metadata with different keys to multiple portfolios  # noqa: E501
+    def batch_upsert_portfolio_access_metadata(self, request_body : Annotated[Dict[str, BatchUpsertPortfolioAccessMetadataRequest], Field(..., description="The Access Metadata Rules to upsert and the Portfolio identifiers to upsert for")], effective_at : Annotated[Optional[StrictStr], Field(description="The date these rules will be effective from")] = None, effective_until : Annotated[Optional[StrictStr], Field(description="The effective date until which the Access Metadata is valid. If not supplied, this will be valid indefinitely, or until the next 'effectiveAt' date of the Access Metadata")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BatchUpsertPortfolioAccessMetadataResponse, Awaitable[BatchUpsertPortfolioAccessMetadataResponse]]:  # noqa: E501
+        """[EARLY ACCESS] BatchUpsertPortfolioAccessMetadata: Upsert multiple Portfolio Access Metadata Rules to multiple Portfolios  # noqa: E501
 
-        Update or insert multiple Portfolios Access Metadata Rule in multiple scopes. Items will be updated if it already exists  and inserted if it does not. No other items will be affected    The response will return the successfully updated or inserted Portfolio Access Metadata Rules or failure message if unsuccessful    It is important to always check to verify success (or failure).                Multiple rules for a metadataKey can exist with different effective at dates, when resources are accessed the rule that is active for the current time will be fetched  # noqa: E501
+        Update or insert multiple Access Metadata rules for multiple Portfolios. Items will be updated if they already exist  and inserted if they do not. No other items will be affected    The response will return the successfully updated or inserted Portfolio Access Metadata Rules or a failure message if unsuccessful                Multiple rules for a metadataKey can exist with different effective at dates, when resources are accessed the rule that is active for the current time will be fetched  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.batch_upsert_portfolio_access_metadata(batch_upsert_portfolio_access_metadata_request, effective_at, effective_until, async_req=True)
+        >>> thread = api.batch_upsert_portfolio_access_metadata(request_body, effective_at, effective_until, async_req=True)
         >>> result = thread.get()
 
-        :param batch_upsert_portfolio_access_metadata_request: The Portfolio Access Metadata Rule to update or insert (required)
-        :type batch_upsert_portfolio_access_metadata_request: BatchUpsertPortfolioAccessMetadataRequest
-        :param effective_at: The date this rule will effective from
+        :param request_body: The Access Metadata Rules to upsert and the Portfolio identifiers to upsert for (required)
+        :type request_body: Dict[str, BatchUpsertPortfolioAccessMetadataRequest]
+        :param effective_at: The date these rules will be effective from
         :type effective_at: str
-        :param effective_until: The effective date until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' date of the Access Metadata
-        :type effective_until: datetime
+        :param effective_until: The effective date until which the Access Metadata is valid. If not supplied, this will be valid indefinitely, or until the next 'effectiveAt' date of the Access Metadata
+        :type effective_until: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _request_timeout: timeout setting for this request.
@@ -121,25 +121,25 @@ class PortfoliosApi:
             raise ValueError(message)
         if async_req is not None:
             kwargs['async_req'] = async_req
-        return self.batch_upsert_portfolio_access_metadata_with_http_info(batch_upsert_portfolio_access_metadata_request, effective_at, effective_until, **kwargs)  # noqa: E501
+        return self.batch_upsert_portfolio_access_metadata_with_http_info(request_body, effective_at, effective_until, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def batch_upsert_portfolio_access_metadata_with_http_info(self, batch_upsert_portfolio_access_metadata_request : Annotated[BatchUpsertPortfolioAccessMetadataRequest, Field(..., description="The Portfolio Access Metadata Rule to update or insert")], effective_at : Annotated[Optional[StrictStr], Field(description="The date this rule will effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective date until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' date of the Access Metadata")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] BatchUpsertPortfolioAccessMetadata: Upsert multiple portfolio access metadata with different keys to multiple portfolios  # noqa: E501
+    def batch_upsert_portfolio_access_metadata_with_http_info(self, request_body : Annotated[Dict[str, BatchUpsertPortfolioAccessMetadataRequest], Field(..., description="The Access Metadata Rules to upsert and the Portfolio identifiers to upsert for")], effective_at : Annotated[Optional[StrictStr], Field(description="The date these rules will be effective from")] = None, effective_until : Annotated[Optional[StrictStr], Field(description="The effective date until which the Access Metadata is valid. If not supplied, this will be valid indefinitely, or until the next 'effectiveAt' date of the Access Metadata")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+        """[EARLY ACCESS] BatchUpsertPortfolioAccessMetadata: Upsert multiple Portfolio Access Metadata Rules to multiple Portfolios  # noqa: E501
 
-        Update or insert multiple Portfolios Access Metadata Rule in multiple scopes. Items will be updated if it already exists  and inserted if it does not. No other items will be affected    The response will return the successfully updated or inserted Portfolio Access Metadata Rules or failure message if unsuccessful    It is important to always check to verify success (or failure).                Multiple rules for a metadataKey can exist with different effective at dates, when resources are accessed the rule that is active for the current time will be fetched  # noqa: E501
+        Update or insert multiple Access Metadata rules for multiple Portfolios. Items will be updated if they already exist  and inserted if they do not. No other items will be affected    The response will return the successfully updated or inserted Portfolio Access Metadata Rules or a failure message if unsuccessful                Multiple rules for a metadataKey can exist with different effective at dates, when resources are accessed the rule that is active for the current time will be fetched  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.batch_upsert_portfolio_access_metadata_with_http_info(batch_upsert_portfolio_access_metadata_request, effective_at, effective_until, async_req=True)
+        >>> thread = api.batch_upsert_portfolio_access_metadata_with_http_info(request_body, effective_at, effective_until, async_req=True)
         >>> result = thread.get()
 
-        :param batch_upsert_portfolio_access_metadata_request: The Portfolio Access Metadata Rule to update or insert (required)
-        :type batch_upsert_portfolio_access_metadata_request: BatchUpsertPortfolioAccessMetadataRequest
-        :param effective_at: The date this rule will effective from
+        :param request_body: The Access Metadata Rules to upsert and the Portfolio identifiers to upsert for (required)
+        :type request_body: Dict[str, BatchUpsertPortfolioAccessMetadataRequest]
+        :param effective_at: The date these rules will be effective from
         :type effective_at: str
-        :param effective_until: The effective date until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' date of the Access Metadata
-        :type effective_until: datetime
+        :param effective_until: The effective date until which the Access Metadata is valid. If not supplied, this will be valid indefinitely, or until the next 'effectiveAt' date of the Access Metadata
+        :type effective_until: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -168,7 +168,7 @@ class PortfoliosApi:
         _params = locals()
 
         _all_params = [
-            'batch_upsert_portfolio_access_metadata_request',
+            'request_body',
             'effective_at',
             'effective_until'
         ]
@@ -205,10 +205,7 @@ class PortfoliosApi:
             _query_params.append(('effectiveAt', _params['effective_at']))
 
         if _params.get('effective_until') is not None:  # noqa: E501
-            if isinstance(_params['effective_until'], datetime):
-                _query_params.append(('effectiveUntil', _params['effective_until'].strftime(self.api_client.configuration.datetime_format)))
-            else:
-                _query_params.append(('effectiveUntil', _params['effective_until']))
+            _query_params.append(('effectiveUntil', _params['effective_until']))
 
         # process the header parameters
         _header_params = dict(_params.get('_headers', {}))
@@ -217,8 +214,8 @@ class PortfoliosApi:
         _files = {}
         # process the body parameter
         _body_params = None
-        if _params['batch_upsert_portfolio_access_metadata_request'] is not None:
-            _body_params = _params['batch_upsert_portfolio_access_metadata_request']
+        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(
@@ -5532,7 +5529,7 @@ class PortfoliosApi:
 
     @validate_arguments
     def upsert_portfolio_access_metadata(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope to use when updating or inserting the Portfolio Access Metadata Rule.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Portfolio code")], metadata_key : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="Key of the access metadata to upsert")], upsert_portfolio_access_metadata_request : Annotated[UpsertPortfolioAccessMetadataRequest, Field(..., description="The Portfolio Access Metadata Rule to update or insert")], effective_at : Annotated[Optional[StrictStr], Field(description="The date this rule will effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective date until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' date of the Access Metadata")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfAccessMetadataValueOf, Awaitable[ResourceListOfAccessMetadataValueOf]]:  # noqa: E501
-        """[EARLY ACCESS] UpsertPortfolioAccessMetadata: Upsert a Portfolio Access Metadata Rule associated with specific metadataKey. This creates or updates the data in LUSID.  # noqa: E501
+        """UpsertPortfolioAccessMetadata: Upsert a Portfolio Access Metadata Rule associated with specific metadataKey. This creates or updates the data in LUSID.  # noqa: E501
 
         Update or insert one Portfolio Access Metadata Rule in a single scope. An item will be updated if it already exists  and inserted if it does not.    The response will return the successfully updated or inserted Portfolio Access Metadata Rule or failure message if unsuccessful    It is important to always check to verify success (or failure).                Multiple rules for a metadataKey can exists with different effective at dates, when resources are accessed the rule that is active for the current time will be fetched  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -5574,7 +5571,7 @@ class PortfoliosApi:
 
     @validate_arguments
     def upsert_portfolio_access_metadata_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope to use when updating or inserting the Portfolio Access Metadata Rule.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Portfolio code")], metadata_key : Annotated[constr(strict=True, max_length=256, min_length=1), Field(..., description="Key of the access metadata to upsert")], upsert_portfolio_access_metadata_request : Annotated[UpsertPortfolioAccessMetadataRequest, Field(..., description="The Portfolio Access Metadata Rule to update or insert")], effective_at : Annotated[Optional[StrictStr], Field(description="The date this rule will effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective date until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' date of the Access Metadata")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] UpsertPortfolioAccessMetadata: Upsert a Portfolio Access Metadata Rule associated with specific metadataKey. This creates or updates the data in LUSID.  # noqa: E501
+        """UpsertPortfolioAccessMetadata: Upsert a Portfolio Access Metadata Rule associated with specific metadataKey. This creates or updates the data in LUSID.  # noqa: E501
 
         Update or insert one Portfolio Access Metadata Rule in a single scope. An item will be updated if it already exists  and inserted if it does not.    The response will return the successfully updated or inserted Portfolio Access Metadata Rule or failure message if unsuccessful    It is important to always check to verify success (or failure).                Multiple rules for a metadataKey can exists with different effective at dates, when resources are accessed the rule that is active for the current time will be fetched  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/api/reference_lists_api.py

@@ -220,7 +220,7 @@ class ReferenceListsApi:
 
     @validate_arguments
     def get_reference_list(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope to which the Reference List belongs.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The Reference List's unique identifier.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Reference List. Defaults to return the latest version of the Reference List if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ReferenceListResponse, Awaitable[ReferenceListResponse]]:  # noqa: E501
-        """[EARLY ACCESS] GetReferenceList: Get Reference List  # noqa: E501
+        """GetReferenceList: Get Reference List  # noqa: E501
 
         Retrieve a Reference List instance at a point in AsAt time.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -256,7 +256,7 @@ class ReferenceListsApi:
 
     @validate_arguments
     def get_reference_list_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope to which the Reference List belongs.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The Reference List's unique identifier.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Reference List. Defaults to return the latest version of the Reference List if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] GetReferenceList: Get Reference List  # noqa: E501
+        """GetReferenceList: Get Reference List  # noqa: E501
 
         Retrieve a Reference List instance at a point in AsAt time.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/api/reference_portfolio_api.py

@@ -30,6 +30,8 @@ from lusid.models.create_reference_portfolio_request import CreateReferencePortf
 from lusid.models.get_reference_portfolio_constituents_response import GetReferencePortfolioConstituentsResponse
 from lusid.models.portfolio import Portfolio
 from lusid.models.resource_list_of_constituents_adjustment_header import ResourceListOfConstituentsAdjustmentHeader
+from lusid.models.upsert_reference_portfolio_constituent_properties_request import UpsertReferencePortfolioConstituentPropertiesRequest
+from lusid.models.upsert_reference_portfolio_constituent_properties_response import UpsertReferencePortfolioConstituentPropertiesResponse
 from lusid.models.upsert_reference_portfolio_constituents_request import UpsertReferencePortfolioConstituentsRequest
 from lusid.models.upsert_reference_portfolio_constituents_response import UpsertReferencePortfolioConstituentsResponse
 
@@ -592,6 +594,180 @@ class ReferencePortfolioApi:
             collection_formats=_collection_formats,
             _request_auth=_params.get('_request_auth'))
 
+    @overload
+    async def upsert_reference_portfolio_constituent_properties(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the reference portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituent_properties_request : Annotated[UpsertReferencePortfolioConstituentPropertiesRequest, Field(..., description="The request to modify properties for the constituent.")], **kwargs) -> UpsertReferencePortfolioConstituentPropertiesResponse:  # noqa: E501
+        ...
+
+    @overload
+    def upsert_reference_portfolio_constituent_properties(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the reference portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituent_properties_request : Annotated[UpsertReferencePortfolioConstituentPropertiesRequest, Field(..., description="The request to modify properties for the constituent.")], async_req: Optional[bool]=True, **kwargs) -> UpsertReferencePortfolioConstituentPropertiesResponse:  # noqa: E501
+        ...
+
+    @validate_arguments
+    def upsert_reference_portfolio_constituent_properties(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the reference portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituent_properties_request : Annotated[UpsertReferencePortfolioConstituentPropertiesRequest, Field(..., description="The request to modify properties for the constituent.")], async_req: Optional[bool]=None, **kwargs) -> Union[UpsertReferencePortfolioConstituentPropertiesResponse, Awaitable[UpsertReferencePortfolioConstituentPropertiesResponse]]:  # noqa: E501
+        """[EARLY ACCESS] UpsertReferencePortfolioConstituentProperties: Upsert constituent properties  # noqa: E501
+
+        Create or update one or more constituent properties for a single constituent in the reference portfolio.  Each property will be updated if it already exists, created if it does not and deleted if value is null.  Both constituent and portfolio must exist at the time when properties are created or updated.  # 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_reference_portfolio_constituent_properties(scope, code, upsert_reference_portfolio_constituent_properties_request, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope of the reference portfolio. (required)
+        :type scope: str
+        :param code: The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio. (required)
+        :type code: str
+        :param upsert_reference_portfolio_constituent_properties_request: The request to modify properties for the constituent. (required)
+        :type upsert_reference_portfolio_constituent_properties_request: UpsertReferencePortfolioConstituentPropertiesRequest
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: 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.
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: UpsertReferencePortfolioConstituentPropertiesResponse
+        """
+        kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the upsert_reference_portfolio_constituent_properties_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_reference_portfolio_constituent_properties_with_http_info(scope, code, upsert_reference_portfolio_constituent_properties_request, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def upsert_reference_portfolio_constituent_properties_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the reference portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituent_properties_request : Annotated[UpsertReferencePortfolioConstituentPropertiesRequest, Field(..., description="The request to modify properties for the constituent.")], **kwargs) -> ApiResponse:  # noqa: E501
+        """[EARLY ACCESS] UpsertReferencePortfolioConstituentProperties: Upsert constituent properties  # noqa: E501
+
+        Create or update one or more constituent properties for a single constituent in the reference portfolio.  Each property will be updated if it already exists, created if it does not and deleted if value is null.  Both constituent and portfolio must exist at the time when properties are created or updated.  # 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_reference_portfolio_constituent_properties_with_http_info(scope, code, upsert_reference_portfolio_constituent_properties_request, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope of the reference portfolio. (required)
+        :type scope: str
+        :param code: The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio. (required)
+        :type code: str
+        :param upsert_reference_portfolio_constituent_properties_request: The request to modify properties for the constituent. (required)
+        :type upsert_reference_portfolio_constituent_properties_request: UpsertReferencePortfolioConstituentPropertiesRequest
+        :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 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_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(UpsertReferencePortfolioConstituentPropertiesResponse, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = [
+            'scope',
+            'code',
+            'upsert_reference_portfolio_constituent_properties_request'
+        ]
+        _all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout',
+                '_request_auth',
+                '_content_type',
+                '_headers'
+            ]
+        )
+
+        # 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_reference_portfolio_constituent_properties" % _key
+                )
+            _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']
+
+
+        # 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['upsert_reference_portfolio_constituent_properties_request'] is not None:
+            _body_params = _params['upsert_reference_portfolio_constituent_properties_request']
+
+        # 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': "UpsertReferencePortfolioConstituentPropertiesResponse",
+            '400': "LusidValidationProblemDetails",
+        }
+
+        return self.api_client.call_api(
+            '/api/referenceportfolios/{scope}/{code}/constituents/properties', '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'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
     @overload
     async def upsert_reference_portfolio_constituents(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the reference portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the reference portfolio. Together with the scope this uniquely identifies              the reference portfolio.")], upsert_reference_portfolio_constituents_request : Annotated[UpsertReferencePortfolioConstituentsRequest, Field(..., description="The constituents to upload to the reference portfolio.")], **kwargs) -> UpsertReferencePortfolioConstituentsResponse:  # noqa: E501
         ...

lusid/api/transaction_portfolios_api.py

@@ -4610,7 +4610,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def get_transaction_history(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the transaction portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], transaction_id : Annotated[StrictStr, Field(..., description="The unique ID of the transaction to create or update.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the history of the transaction. Defaults              to return the latest version if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfChangeHistory, Awaitable[ResourceListOfChangeHistory]]:  # noqa: E501
-        """[EARLY ACCESS] GetTransactionHistory: Get the history of a transaction  # noqa: E501
+        """GetTransactionHistory: Get the history of a transaction  # noqa: E501
 
         Get all of the changes that have happened to a transaction.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -4648,7 +4648,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def get_transaction_history_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the transaction portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], transaction_id : Annotated[StrictStr, Field(..., description="The unique ID of the transaction to create or update.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the history of the transaction. Defaults              to return the latest version if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] GetTransactionHistory: Get the history of a transaction  # noqa: E501
+        """GetTransactionHistory: Get the history of a transaction  # noqa: E501
 
         Get all of the changes that have happened to a transaction.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/configuration.py

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