lusid-sdk 2.1.741__py3-none-any.whl → 2.1.743__py3-none-any.whl

lusid/api/transaction_portfolios_api.py

@@ -300,7 +300,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def batch_adjust_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies               the transaction portfolio.")], success_mode : Annotated[StrictStr, Field(..., description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial")], request_body : Annotated[Dict[str, AdjustHoldingForDateRequest], Field(..., description="The selected set of holdings to adjust to the provided targets for the               transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BatchAdjustHoldingsResponse, Awaitable[BatchAdjustHoldingsResponse]]:  # noqa: E501
-        """[EARLY ACCESS] BatchAdjustHoldings: Batch adjust holdings  # noqa: E501
+        """BatchAdjustHoldings: Batch adjust holdings  # noqa: E501
 
         Adjust one or more holdings of the specified transaction portfolio to the provided targets. LUSID will  automatically construct adjustment transactions to ensure that the holdings which have been adjusted are  always set to the provided targets for the specified effective datetime in each request.                Each request must be keyed by a unique correlation id. This id is ephemeral and is not stored by LUSID.  It serves only as a way to easily identify each adjustment in the response.    Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -339,7 +339,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def batch_adjust_holdings_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies               the transaction portfolio.")], success_mode : Annotated[StrictStr, Field(..., description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial")], request_body : Annotated[Dict[str, AdjustHoldingForDateRequest], Field(..., description="The selected set of holdings to adjust to the provided targets for the               transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] BatchAdjustHoldings: Batch adjust holdings  # noqa: E501
+        """BatchAdjustHoldings: Batch adjust holdings  # noqa: E501
 
         Adjust one or more holdings of the specified transaction portfolio to the provided targets. LUSID will  automatically construct adjustment transactions to ensure that the holdings which have been adjusted are  always set to the provided targets for the specified effective datetime in each request.                Each request must be keyed by a unique correlation id. This id is ephemeral and is not stored by LUSID.  It serves only as a way to easily identify each adjustment in the response.    Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -492,7 +492,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def batch_create_trade_tickets(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], lusid_trade_ticket : Annotated[conlist(LusidTradeTicket), Field(..., description="the trade tickets to create")], async_req: Optional[bool]=None, **kwargs) -> Union[CreateTradeTicketsResponse, Awaitable[CreateTradeTicketsResponse]]:  # noqa: E501
-        """[EARLY ACCESS] BatchCreateTradeTickets: Batch Create Trade Tickets  # noqa: E501
+        """BatchCreateTradeTickets: Batch Create Trade Tickets  # noqa: E501
 
         Batch create trade tickets. Each ticket is broadly equivalent to a singular call to upsert an instrument, then a counterparty and finally  a transaction that makes use of the two.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -527,7 +527,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def batch_create_trade_tickets_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], lusid_trade_ticket : Annotated[conlist(LusidTradeTicket), Field(..., description="the trade tickets to create")], **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] BatchCreateTradeTickets: Batch Create Trade Tickets  # noqa: E501
+        """BatchCreateTradeTickets: Batch Create Trade Tickets  # noqa: E501
 
         Batch create trade tickets. Each ticket is broadly equivalent to a singular call to upsert an instrument, then a counterparty and finally  a transaction that makes use of the two.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -667,7 +667,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def batch_set_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies               the transaction portfolio.")], success_mode : Annotated[StrictStr, Field(..., description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial")], request_body : Annotated[Dict[str, AdjustHoldingForDateRequest], Field(..., description="The selected set of holdings to adjust to the provided targets for the               transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BatchAdjustHoldingsResponse, Awaitable[BatchAdjustHoldingsResponse]]:  # noqa: E501
-        """[EARLY ACCESS] BatchSetHoldings: Batch set holdings  # noqa: E501
+        """BatchSetHoldings: Batch set holdings  # noqa: E501
 
         Set the holdings of the specified transaction portfolio to the provided targets. LUSID will automatically  construct adjustment transactions to ensure that the entire set of holdings for the transaction portfolio  are always set to the provided targets for the specified effective datetime. Read more about the difference between  adjusting and setting holdings here https://support.lusid.com/docs/how-do-i-manually-adjust-or-set-holdings.                Each request must be keyed by a unique correlation id. This id is ephemeral and is not stored by LUSID.  It serves only as a way to easily identify each adjustment in the response.    Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -706,7 +706,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def batch_set_holdings_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies               the transaction portfolio.")], success_mode : Annotated[StrictStr, Field(..., description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial")], request_body : Annotated[Dict[str, AdjustHoldingForDateRequest], Field(..., description="The selected set of holdings to adjust to the provided targets for the               transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] BatchSetHoldings: Batch set holdings  # noqa: E501
+        """BatchSetHoldings: Batch set holdings  # noqa: E501
 
         Set the holdings of the specified transaction portfolio to the provided targets. LUSID will automatically  construct adjustment transactions to ensure that the entire set of holdings for the transaction portfolio  are always set to the provided targets for the specified effective datetime. Read more about the difference between  adjusting and setting holdings here https://support.lusid.com/docs/how-do-i-manually-adjust-or-set-holdings.                Each request must be keyed by a unique correlation id. This id is ephemeral and is not stored by LUSID.  It serves only as a way to easily identify each adjustment in the response.    Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -859,7 +859,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def batch_upsert_transactions(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], success_mode : Annotated[StrictStr, Field(..., description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")], request_body : Annotated[Dict[str, TransactionRequest], Field(..., description="The payload describing the transactions to be created or updated.")], preserve_properties : Annotated[Optional[StrictBool], Field(description="If set to false, the entire property set will be overwritten by the provided properties. If not specified or set to true, only the properties provided will be updated.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BatchUpsertPortfolioTransactionsResponse, Awaitable[BatchUpsertPortfolioTransactionsResponse]]:  # noqa: E501
-        """[EARLY ACCESS] BatchUpsertTransactions: Batch upsert transactions  # noqa: E501
+        """BatchUpsertTransactions: Batch upsert transactions  # noqa: E501
 
         Create or update transactions in the transaction portfolio. A transaction will be updated  if it already exists and created if it does not.    Each request must be keyed by a unique correlation id. This id is ephemeral and is not stored by LUSID.  It serves only as a way to easily identify each transaction in the response.    Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -898,7 +898,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def batch_upsert_transactions_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], success_mode : Annotated[StrictStr, Field(..., description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")], request_body : Annotated[Dict[str, TransactionRequest], Field(..., description="The payload describing the transactions to be created or updated.")], preserve_properties : Annotated[Optional[StrictBool], Field(description="If set to false, the entire property set will be overwritten by the provided properties. If not specified or set to true, only the properties provided will be updated.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] BatchUpsertTransactions: Batch upsert transactions  # noqa: E501
+        """BatchUpsertTransactions: Batch upsert transactions  # noqa: E501
 
         Create or update transactions in the transaction portfolio. A transaction will be updated  if it already exists and created if it does not.    Each request must be keyed by a unique correlation id. This id is ephemeral and is not stored by LUSID.  It serves only as a way to easily identify each transaction in the response.    Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1437,7 +1437,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def cancel_single_adjust_holding(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the previous adjustment was made.")], cancel_single_holding_adjustment_request : Annotated[CancelSingleHoldingAdjustmentRequest, Field(..., description="The selected holding adjustment to be canceled.")], async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
-        """[EARLY ACCESS] CancelSingleAdjustHolding: Cancel single holding adjustment.  # noqa: E501
+        """CancelSingleAdjustHolding: Cancel single holding adjustment.  # noqa: E501
 
         Cancel one previously sent holding adjustment without affecting the rest of the adjustment in the previous request on the specified effective datetime.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1474,7 +1474,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def cancel_single_adjust_holding_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the previous adjustment was made.")], cancel_single_holding_adjustment_request : Annotated[CancelSingleHoldingAdjustmentRequest, Field(..., description="The selected holding adjustment to be canceled.")], **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] CancelSingleAdjustHolding: Cancel single holding adjustment.  # noqa: E501
+        """CancelSingleAdjustHolding: Cancel single holding adjustment.  # noqa: E501
 
         Cancel one previously sent holding adjustment without affecting the rest of the adjustment in the previous request on the specified effective datetime.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1956,7 +1956,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def create_trade_ticket(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], lusid_trade_ticket : Annotated[Optional[LusidTradeTicket], Field(description="the trade ticket to upsert")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[LusidTradeTicket, Awaitable[LusidTradeTicket]]:  # noqa: E501
-        """[EARLY ACCESS] CreateTradeTicket: Create Trade Ticket  # noqa: E501
+        """CreateTradeTicket: Create Trade Ticket  # noqa: E501
 
         Upsert a trade ticket. Broadly equivalent to a singular call to upsert an instrument, then a counterparty and finally  a transaction that makes use of the two. It can be viewed as a utility function or part of a workflow more familiar to users  with OTC systems than flow and equity trading ones.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1991,7 +1991,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def create_trade_ticket_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], lusid_trade_ticket : Annotated[Optional[LusidTradeTicket], Field(description="the trade ticket to upsert")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] CreateTradeTicket: Create Trade Ticket  # noqa: E501
+        """CreateTradeTicket: Create Trade Ticket  # noqa: E501
 
         Upsert a trade ticket. Broadly equivalent to a singular call to upsert an instrument, then a counterparty and finally  a transaction that makes use of the two. It can be viewed as a utility function or part of a workflow more familiar to users  with OTC systems than flow and equity trading ones.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -2131,7 +2131,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def delete_custodian_accounts(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Transaction Portfolios.")], code : Annotated[StrictStr, Field(..., description="The code of the Transaction Portfolios. Together with the scope this uniquely identifies              the Transaction Portfolios.")], resource_id : Annotated[conlist(ResourceId), Field(..., description="The scope and codes of the custodian accounts to delete.")], delete_mode : Annotated[Optional[StrictStr], Field( description="The delete mode to use (defaults to 'Soft').")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[DeleteCustodianAccountsResponse, Awaitable[DeleteCustodianAccountsResponse]]:  # noqa: E501
-        """[EXPERIMENTAL] DeleteCustodianAccounts: Soft or hard delete multiple custodian accounts  # noqa: E501
+        """DeleteCustodianAccounts: Soft or hard delete multiple custodian accounts  # noqa: E501
 
         Delete one or more custodian accounts from the Transaction Portfolios. Soft deletion marks the custodian account as inactive  While the Hard deletion is deleting the custodian account.  The batch limit per request is 2,000.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -2168,7 +2168,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def delete_custodian_accounts_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Transaction Portfolios.")], code : Annotated[StrictStr, Field(..., description="The code of the Transaction Portfolios. Together with the scope this uniquely identifies              the Transaction Portfolios.")], resource_id : Annotated[conlist(ResourceId), Field(..., description="The scope and codes of the custodian accounts to delete.")], delete_mode : Annotated[Optional[StrictStr], Field( description="The delete mode to use (defaults to 'Soft').")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] DeleteCustodianAccounts: Soft or hard delete multiple custodian accounts  # noqa: E501
+        """DeleteCustodianAccounts: Soft or hard delete multiple custodian accounts  # noqa: E501
 
         Delete one or more custodian accounts from the Transaction Portfolios. Soft deletion marks the custodian account as inactive  While the Hard deletion is deleting the custodian account.  The batch limit per request is 2,000.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -2931,7 +2931,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def get_bucketed_cash_flows(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies the portfolio.")], bucketed_cash_flow_request : Annotated[Optional[BucketedCashFlowRequest], Field(description="Request specifying the bucketing of cashflows")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BucketedCashFlowResponse, Awaitable[BucketedCashFlowResponse]]:  # noqa: E501
-        """[EXPERIMENTAL] GetBucketedCashFlows: Get bucketed cash flows from a list of portfolios  # noqa: E501
+        """GetBucketedCashFlows: Get bucketed cash flows from a list of portfolios  # noqa: E501
 
         We bucket/aggregate a transaction portfolio's instruments by date or tenor specified in the request.  The cashflows are grouped by both instrumentId and currency.                If you want transactional level cashflow, please use the 'GetUpsertableCashFlows' endpoint.  If you want instrument cashflow, please use the 'GetPortfolioCashFlows' endpoint.  Note that these endpoints do not apply bucketing.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -2966,7 +2966,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def get_bucketed_cash_flows_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies the portfolio.")], bucketed_cash_flow_request : Annotated[Optional[BucketedCashFlowRequest], Field(description="Request specifying the bucketing of cashflows")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] GetBucketedCashFlows: Get bucketed cash flows from a list of portfolios  # noqa: E501
+        """GetBucketedCashFlows: Get bucketed cash flows from a list of portfolios  # noqa: E501
 
         We bucket/aggregate a transaction portfolio's instruments by date or tenor specified in the request.  The cashflows are grouped by both instrumentId and currency.                If you want transactional level cashflow, please use the 'GetUpsertableCashFlows' endpoint.  If you want instrument cashflow, please use the 'GetPortfolioCashFlows' endpoint.  Note that these endpoints do not apply bucketing.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -3106,7 +3106,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def get_custodian_account(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Transaction Portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the Transaction Portfolio. Together with the scope this uniquely identifies the Transaction Portfolio.")], custodian_account_scope : Annotated[StrictStr, Field(..., description="The scope of the Custodian Account.")], custodian_account_code : Annotated[StrictStr, Field(..., description="The code of the Custodian Account.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the Custodian Account 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 retrieve the Custodian Account definition. Defaults to returning the latest version of the Custodian Account definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustodianAccount' domain to decorate onto the Custodian Account.              These must take the format {domain}/{scope}/{code}, for example 'CustodianAccount/Manager/Id'. If no properties are specified, then no properties will be returned.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[CustodianAccount, Awaitable[CustodianAccount]]:  # noqa: E501
-        """[EXPERIMENTAL] GetCustodianAccount: Get Custodian Account  # noqa: E501
+        """GetCustodianAccount: Get Custodian Account  # noqa: E501
 
         Retrieve the definition of a particular Custodian Account which is part of a Transaction Portfolios.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -3149,7 +3149,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def get_custodian_account_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Transaction Portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the Transaction Portfolio. Together with the scope this uniquely identifies the Transaction Portfolio.")], custodian_account_scope : Annotated[StrictStr, Field(..., description="The scope of the Custodian Account.")], custodian_account_code : Annotated[StrictStr, Field(..., description="The code of the Custodian Account.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the Custodian Account 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 retrieve the Custodian Account definition. Defaults to returning the latest version of the Custodian Account definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustodianAccount' domain to decorate onto the Custodian Account.              These must take the format {domain}/{scope}/{code}, for example 'CustodianAccount/Manager/Id'. If no properties are specified, then no properties will be returned.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] GetCustodianAccount: Get Custodian Account  # noqa: E501
+        """GetCustodianAccount: Get Custodian Account  # noqa: E501
 
         Retrieve the definition of a particular Custodian Account which is part of a Transaction Portfolios.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -3489,7 +3489,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def get_holding_contributors(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], holding_id : Annotated[conint(strict=True), Field(..., description="The unique holding identifier")], effective_date : Annotated[Optional[StrictStr], Field( description="Effective date")] = None, from_trade_date : Annotated[Optional[StrictStr], Field( description="The from trade date, defaults to first time this holding is opened, lower bound for transactions")] = None, to_trade_date : Annotated[Optional[StrictStr], Field( description="The to trade date upper bound date, defaults to effectiveDate. upper bound for transactions")] = None, include_historic : Annotated[Optional[StrictBool], Field(description="If true, transactions from previously closed holdings are returned.              If false, only transactions from last time position is opened.")] = None, tax_lot_id : Annotated[Optional[StrictStr], Field( description="Constrains the Holding Contributors to those which contributed to the specified tax lot.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to build the transactions. Defaults to return the latest              version of each transaction if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to GetHoldingContributors.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[VersionedResourceListOfHoldingContributor, Awaitable[VersionedResourceListOfHoldingContributor]]:  # noqa: E501
-        """[EARLY ACCESS] GetHoldingContributors: Get Holdings Contributors  # noqa: E501
+        """GetHoldingContributors: Get Holdings Contributors  # noqa: E501
 
         Lists all transactions that affect the holdings of a portfolio over a given effective interval. This includes  transactions automatically generated by LUSID such as holding adjustments.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -3540,7 +3540,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def get_holding_contributors_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], holding_id : Annotated[conint(strict=True), Field(..., description="The unique holding identifier")], effective_date : Annotated[Optional[StrictStr], Field( description="Effective date")] = None, from_trade_date : Annotated[Optional[StrictStr], Field( description="The from trade date, defaults to first time this holding is opened, lower bound for transactions")] = None, to_trade_date : Annotated[Optional[StrictStr], Field( description="The to trade date upper bound date, defaults to effectiveDate. upper bound for transactions")] = None, include_historic : Annotated[Optional[StrictBool], Field(description="If true, transactions from previously closed holdings are returned.              If false, only transactions from last time position is opened.")] = None, tax_lot_id : Annotated[Optional[StrictStr], Field( description="Constrains the Holding Contributors to those which contributed to the specified tax lot.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to build the transactions. Defaults to return the latest              version of each transaction if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to GetHoldingContributors.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] GetHoldingContributors: Get Holdings Contributors  # noqa: E501
+        """GetHoldingContributors: Get Holdings Contributors  # noqa: E501
 
         Lists all transactions that affect the holdings of a portfolio over a given effective interval. This includes  transactions automatically generated by LUSID such as holding adjustments.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -4124,7 +4124,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def get_holdings_with_orders(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the holdings of the transaction              portfolio. 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 holdings of the transaction portfolio. Defaults              to return the latest version of the holdings if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Holding Type, use \"holdingType eq 'p'\"              For more information about filtering LUSID results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\", \"Holding\" or \"Portfolio\" domain to decorate onto              the holdings. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\" or \"Holding/system/Cost\".")] = None, by_taxlots : Annotated[Optional[StrictBool], Field(description="Whether or not to expand the holdings to return the underlying tax-lots. Defaults to              False.")] = None, recipe_id_scope : Annotated[Optional[StrictStr], Field( description="The scope of the given recipeId")] = None, recipe_id_code : Annotated[Optional[StrictStr], Field( description="The code of the given recipeId")] = None, include_settlement_events_after_days : Annotated[Optional[StrictInt], Field(description="Number of days ahead to bring back settlements from, in relation to the specified effectiveAt")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[VersionedResourceListWithWarningsOfPortfolioHolding, Awaitable[VersionedResourceListWithWarningsOfPortfolioHolding]]:  # noqa: E501
-        """[EXPERIMENTAL] GetHoldingsWithOrders: Get holdings with orders  # noqa: E501
+        """GetHoldingsWithOrders: Get holdings with orders  # noqa: E501
 
         Get the holdings of a transaction portfolio. Create virtual holdings for any outstanding orders,  and account for order state/fulfillment; that is, treat outstanding orders (and related records) as  if they had been realised at moment of query.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -4173,7 +4173,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def get_holdings_with_orders_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the holdings of the transaction              portfolio. 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 holdings of the transaction portfolio. Defaults              to return the latest version of the holdings if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Holding Type, use \"holdingType eq 'p'\"              For more information about filtering LUSID results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\", \"Holding\" or \"Portfolio\" domain to decorate onto              the holdings. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\" or \"Holding/system/Cost\".")] = None, by_taxlots : Annotated[Optional[StrictBool], Field(description="Whether or not to expand the holdings to return the underlying tax-lots. Defaults to              False.")] = None, recipe_id_scope : Annotated[Optional[StrictStr], Field( description="The scope of the given recipeId")] = None, recipe_id_code : Annotated[Optional[StrictStr], Field( description="The code of the given recipeId")] = None, include_settlement_events_after_days : Annotated[Optional[StrictInt], Field(description="Number of days ahead to bring back settlements from, in relation to the specified effectiveAt")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] GetHoldingsWithOrders: Get holdings with orders  # noqa: E501
+        """GetHoldingsWithOrders: Get holdings with orders  # noqa: E501
 
         Get the holdings of a transaction portfolio. Create virtual holdings for any outstanding orders,  and account for order state/fulfillment; that is, treat outstanding orders (and related records) as  if they had been realised at moment of query.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -4352,7 +4352,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def get_multiple_holding_contributors(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], holding_ids_request : Annotated[HoldingIdsRequest, Field(..., description="The array of unique holding identifiers")], effective_date : Annotated[Optional[StrictStr], Field( description="Effective date")] = None, from_transaction_date : Annotated[Optional[StrictStr], Field( description="The from trade date, defaults to first time this holding is opened, lower bound for transactions")] = None, to_transaction_date : Annotated[Optional[StrictStr], Field( description="The to trade date upper bound date, defaults to effectiveDate. upper bound for transactions")] = None, include_historic : Annotated[Optional[StrictBool], Field(description="If true, transactions from previously closed holdings are returned.              If false, only transactions from last time position is opened.")] = None, tax_lot_id : Annotated[Optional[StrictStr], Field( description="Constrains the Holding Contributors to those which contributed to the specified tax lot.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to build the transactions. Defaults to return the latest              version of each transaction if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to GetHoldingContributors.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[VersionedResourceListOfHoldingContributor, Awaitable[VersionedResourceListOfHoldingContributor]]:  # noqa: E501
-        """[EARLY ACCESS] GetMultipleHoldingContributors: Get Multiple Holding Contributors  # noqa: E501
+        """GetMultipleHoldingContributors: Get Multiple Holding Contributors  # noqa: E501
 
         Lists all transactions that affect multiple specified holdings of a portfolio over a given effective interval. This includes  transactions automatically generated by LUSID such as holding adjustments.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -4403,7 +4403,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def get_multiple_holding_contributors_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], holding_ids_request : Annotated[HoldingIdsRequest, Field(..., description="The array of unique holding identifiers")], effective_date : Annotated[Optional[StrictStr], Field( description="Effective date")] = None, from_transaction_date : Annotated[Optional[StrictStr], Field( description="The from trade date, defaults to first time this holding is opened, lower bound for transactions")] = None, to_transaction_date : Annotated[Optional[StrictStr], Field( description="The to trade date upper bound date, defaults to effectiveDate. upper bound for transactions")] = None, include_historic : Annotated[Optional[StrictBool], Field(description="If true, transactions from previously closed holdings are returned.              If false, only transactions from last time position is opened.")] = None, tax_lot_id : Annotated[Optional[StrictStr], Field( description="Constrains the Holding Contributors to those which contributed to the specified tax lot.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to build the transactions. Defaults to return the latest              version of each transaction if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to GetHoldingContributors.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] GetMultipleHoldingContributors: Get Multiple Holding Contributors  # noqa: E501
+        """GetMultipleHoldingContributors: Get Multiple Holding Contributors  # noqa: E501
 
         Lists all transactions that affect multiple specified holdings of a portfolio over a given effective interval. This includes  transactions automatically generated by LUSID such as holding adjustments.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -5902,7 +5902,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def list_custodian_accounts(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Transaction Portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the Transaction Portfolio. Together with the scope this uniquely identifies              the Transaction Portfolios.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the TimeVariant properties decorated on Custodian Accounts. 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. Defaults to              returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing custodian accounts; this              value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the Custodian Account type, specify \"code eq '001'\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustodianAccount' domain to decorate onto the Custodian Account.              These must have the format {domain}/{scope}/{code}, for example 'CustodianAccount/system/Name'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfCustodianAccount, Awaitable[PagedResourceListOfCustodianAccount]]:  # noqa: E501
-        """[EXPERIMENTAL] ListCustodianAccounts: List Custodian Accounts  # noqa: E501
+        """ListCustodianAccounts: List Custodian Accounts  # noqa: E501
 
         List the custodian accounts in a Transaction Portfolios  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -5947,7 +5947,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def list_custodian_accounts_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Transaction Portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the Transaction Portfolio. Together with the scope this uniquely identifies              the Transaction Portfolios.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the TimeVariant properties decorated on Custodian Accounts. 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. Defaults to              returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing custodian accounts; this              value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the Custodian Account type, specify \"code eq '001'\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustodianAccount' domain to decorate onto the Custodian Account.              These must have the format {domain}/{scope}/{code}, for example 'CustodianAccount/system/Name'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] ListCustodianAccounts: List Custodian Accounts  # noqa: E501
+        """ListCustodianAccounts: List Custodian Accounts  # noqa: E501
 
         List the custodian accounts in a Transaction Portfolios  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -6484,7 +6484,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def preview_transaction(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], transaction_request : Annotated[TransactionRequest, Field(..., description="The transaction to be previewed.")], property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\" or \"Transaction\" domain to decorate onto              the transactions. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\" or              \"Transaction/strategy/quantsignal\".")] = None, show_cancelled_transactions : Annotated[Optional[StrictBool], Field(description="Option to specify whether to include previous versions of an amended transaction in the response.              Defaults to False if not specified.")] = None, preserve_properties : Annotated[Optional[StrictBool], Field(description="If the preview transaction is an amendment to an existing transaction, then setting this to true will carry forward any unmodified properties from the earlier version.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfOutputTransaction, Awaitable[ResourceListOfOutputTransaction]]:  # noqa: E501
-        """[EARLY ACCESS] PreviewTransaction: Preview a transaction  # noqa: E501
+        """PreviewTransaction: Preview a transaction  # noqa: E501
 
         Returns the output-transaction(s) - e.g. as returned by BuildTransactions  that would come out of LUSID if the provided TransactionRequest was booked.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -6525,7 +6525,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def preview_transaction_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], transaction_request : Annotated[TransactionRequest, Field(..., description="The transaction to be previewed.")], property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\" or \"Transaction\" domain to decorate onto              the transactions. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\" or              \"Transaction/strategy/quantsignal\".")] = None, show_cancelled_transactions : Annotated[Optional[StrictBool], Field(description="Option to specify whether to include previous versions of an amended transaction in the response.              Defaults to False if not specified.")] = None, preserve_properties : Annotated[Optional[StrictBool], Field(description="If the preview transaction is an amendment to an existing transaction, then setting this to true will carry forward any unmodified properties from the earlier version.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] PreviewTransaction: Preview a transaction  # noqa: E501
+        """PreviewTransaction: Preview a transaction  # noqa: E501
 
         Returns the output-transaction(s) - e.g. as returned by BuildTransactions  that would come out of LUSID if the provided TransactionRequest was booked.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -7083,7 +7083,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def upsert_custodian_accounts(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Transaction Portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the Transaction Portfolio. Together with the scope this uniquely identifies              the Transaction Portfolios.")], custodian_account_request : Annotated[conlist(CustodianAccountRequest), Field(..., description="A list of Custodian Accounts to be created or updated.")], async_req: Optional[bool]=None, **kwargs) -> Union[CustodianAccountsUpsertResponse, Awaitable[CustodianAccountsUpsertResponse]]:  # noqa: E501
-        """[EXPERIMENTAL] UpsertCustodianAccounts: Upsert Custodian Accounts  # noqa: E501
+        """UpsertCustodianAccounts: Upsert Custodian Accounts  # noqa: E501
 
         Create or update Custodian Accounts in the Transaction Portfolios. A Custodian Account will be updated  if it already exists and created if it does not.  The batch limit per request is 2,000.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -7118,7 +7118,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def upsert_custodian_accounts_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Transaction Portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the Transaction Portfolio. Together with the scope this uniquely identifies              the Transaction Portfolios.")], custodian_account_request : Annotated[conlist(CustodianAccountRequest), Field(..., description="A list of Custodian Accounts to be created or updated.")], **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] UpsertCustodianAccounts: Upsert Custodian Accounts  # noqa: E501
+        """UpsertCustodianAccounts: Upsert Custodian Accounts  # noqa: E501
 
         Create or update Custodian Accounts in the Transaction Portfolios. A Custodian Account will be updated  if it already exists and created if it does not.  The batch limit per request is 2,000.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -7258,7 +7258,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def upsert_custodian_accounts_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Transaction Portfolios to update or insert the properties onto.")], code : Annotated[StrictStr, Field(..., description="The code of the Transaction Portfolios to update or insert the properties onto. Together with the scope this uniquely identifies the Transaction Portfolios.")], custodian_account_scope : Annotated[StrictStr, Field(..., description="The scope of the Custodian Account to update or insert the properties onto.")], custodian_account_code : Annotated[StrictStr, Field(..., description="The unique ID of the custodian account to create or update properties for.")], request_body : Annotated[Optional[Dict[str, ModelProperty]], Field(description="The properties to be updated or inserted onto the Transaction Portfolio. Each property in               the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code} e.g. \"CustodianAccount/Manager/Id\".")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[CustodianAccountProperties, Awaitable[CustodianAccountProperties]]:  # noqa: E501
-        """[EXPERIMENTAL] UpsertCustodianAccountsProperties: Upsert custodian accounts properties  # noqa: E501
+        """UpsertCustodianAccountsProperties: Upsert custodian accounts properties  # noqa: E501
 
         Update or insert one or more properties onto a single custodian account. A property will be updated if it  already exists and inserted if it does not. All properties must be of the domain 'CustodianAccount'.                Upserting a property that exists for a Transaction Portfolios, with a null value, will delete the instance of the property for that group.                Properties have an <i>effectiveFrom</i> datetime for 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
@@ -7297,7 +7297,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def upsert_custodian_accounts_properties_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Transaction Portfolios to update or insert the properties onto.")], code : Annotated[StrictStr, Field(..., description="The code of the Transaction Portfolios to update or insert the properties onto. Together with the scope this uniquely identifies the Transaction Portfolios.")], custodian_account_scope : Annotated[StrictStr, Field(..., description="The scope of the Custodian Account to update or insert the properties onto.")], custodian_account_code : Annotated[StrictStr, Field(..., description="The unique ID of the custodian account to create or update properties for.")], request_body : Annotated[Optional[Dict[str, ModelProperty]], Field(description="The properties to be updated or inserted onto the Transaction Portfolio. Each property in               the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code} e.g. \"CustodianAccount/Manager/Id\".")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] UpsertCustodianAccountsProperties: Upsert custodian accounts properties  # noqa: E501
+        """UpsertCustodianAccountsProperties: Upsert custodian accounts properties  # noqa: E501
 
         Update or insert one or more properties onto a single custodian account. A property will be updated if it  already exists and inserted if it does not. All properties must be of the domain 'CustodianAccount'.                Upserting a property that exists for a Transaction Portfolios, with a null value, will delete the instance of the property for that group.                Properties have an <i>effectiveFrom</i> datetime for 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

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.7535\n"\
+               "Version of the API: 0.11.7540\n"\
                "SDK Package Version: {package_version}".\
                format(env=sys.platform, pyversion=sys.version, package_version=package_version)