lusid-sdk 2.1.913__py3-none-any.whl → 2.1.914__py3-none-any.whl

lusid/api/portfolio_groups_api.py

@@ -442,18 +442,18 @@ class PortfolioGroupsApi:
 
 
     @overload
-    async def build_transactions_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], transaction_query_parameters : Annotated[TransactionQueryParameters, Field(..., description="The query queryParameters which control how the output transactions are built.")], 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, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Transaction Type, use \"type eq 'Buy'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"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, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to BuildTransactions.")] = None, **kwargs) -> VersionedResourceListOfOutputTransaction:  # noqa: E501
+    async def build_transactions_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies               the portfolio group.")], transaction_query_parameters : Annotated[TransactionQueryParameters, Field(..., description="The query queryParameters which control how the output transactions are built.")], 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, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               For example, to filter on the Transaction Type, use \"type eq 'Buy'\"               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"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, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to BuildTransactions.")] = None, **kwargs) -> VersionedResourceListOfOutputTransaction:  # noqa: E501
         ...
 
     @overload
-    def build_transactions_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], transaction_query_parameters : Annotated[TransactionQueryParameters, Field(..., description="The query queryParameters which control how the output transactions are built.")], 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, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Transaction Type, use \"type eq 'Buy'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"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, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to BuildTransactions.")] = None, async_req: Optional[bool]=True, **kwargs) -> VersionedResourceListOfOutputTransaction:  # noqa: E501
+    def build_transactions_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies               the portfolio group.")], transaction_query_parameters : Annotated[TransactionQueryParameters, Field(..., description="The query queryParameters which control how the output transactions are built.")], 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, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               For example, to filter on the Transaction Type, use \"type eq 'Buy'\"               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"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, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to BuildTransactions.")] = None, async_req: Optional[bool]=True, **kwargs) -> VersionedResourceListOfOutputTransaction:  # noqa: E501
         ...
 
     @validate_arguments
-    def build_transactions_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], transaction_query_parameters : Annotated[TransactionQueryParameters, Field(..., description="The query queryParameters which control how the output transactions are built.")], 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, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Transaction Type, use \"type eq 'Buy'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"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, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to BuildTransactions.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[VersionedResourceListOfOutputTransaction, Awaitable[VersionedResourceListOfOutputTransaction]]:  # noqa: E501
+    def build_transactions_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies               the portfolio group.")], transaction_query_parameters : Annotated[TransactionQueryParameters, Field(..., description="The query queryParameters which control how the output transactions are built.")], 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, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               For example, to filter on the Transaction Type, use \"type eq 'Buy'\"               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"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, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to BuildTransactions.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[VersionedResourceListOfOutputTransaction, Awaitable[VersionedResourceListOfOutputTransaction]]:  # noqa: E501
         """BuildTransactionsForPortfolioGroup: Build transactions for transaction portfolios in a portfolio group  # noqa: E501
 
-        Build transactions for transaction portfolios in a portfolio group over a given interval of effective time.              When the specified portfolio in a portfolio group is a derived transaction portfolio, the returned set of transactions is the union set of all transactions of the parent (and any grandparents etc.) and the specified derived transaction portfolio itself.  # noqa: E501
+        Build transactions for transaction portfolios in a portfolio group over a given interval of effective time.                When the specified portfolio in a portfolio group is a derived transaction portfolio, the returned set of transactions is the  union set of all transactions of the parent (and any grandparents etc.) and the specified derived transaction portfolio itself.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -462,15 +462,15 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the portfolio group. (required)
         :type scope: str
-        :param code: The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group. (required)
+        :param code: The code of the portfolio group. Together with the scope this uniquely identifies               the portfolio group. (required)
         :type code: str
         :param transaction_query_parameters: The query queryParameters which control how the output transactions are built. (required)
         :type transaction_query_parameters: TransactionQueryParameters
-        :param as_at: The asAt datetime at which to build the transactions. Defaults to return the latest              version of each transaction if not specified.
+        :param as_at: The asAt datetime at which to build the transactions. Defaults to return the latest               version of each transaction if not specified.
         :type as_at: datetime
-        :param filter: Expression to filter the result set.              For example, to filter on the Transaction Type, use \"type eq 'Buy'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
+        :param filter: Expression to filter the result set.               For example, to filter on the Transaction Type, use \"type eq 'Buy'\"               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
-        :param property_keys: 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\".
+        :param property_keys: 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\".
         :type property_keys: List[str]
         :param limit: When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.
         :type limit: int
@@ -495,10 +495,10 @@ class PortfolioGroupsApi:
         return self.build_transactions_for_portfolio_group_with_http_info(scope, code, transaction_query_parameters, as_at, filter, property_keys, limit, page, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def build_transactions_for_portfolio_group_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], transaction_query_parameters : Annotated[TransactionQueryParameters, Field(..., description="The query queryParameters which control how the output transactions are built.")], 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, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Transaction Type, use \"type eq 'Buy'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"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, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to BuildTransactions.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def build_transactions_for_portfolio_group_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies               the portfolio group.")], transaction_query_parameters : Annotated[TransactionQueryParameters, Field(..., description="The query queryParameters which control how the output transactions are built.")], 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, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               For example, to filter on the Transaction Type, use \"type eq 'Buy'\"               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"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, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to BuildTransactions.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """BuildTransactionsForPortfolioGroup: Build transactions for transaction portfolios in a portfolio group  # noqa: E501
 
-        Build transactions for transaction portfolios in a portfolio group over a given interval of effective time.              When the specified portfolio in a portfolio group is a derived transaction portfolio, the returned set of transactions is the union set of all transactions of the parent (and any grandparents etc.) and the specified derived transaction portfolio itself.  # noqa: E501
+        Build transactions for transaction portfolios in a portfolio group over a given interval of effective time.                When the specified portfolio in a portfolio group is a derived transaction portfolio, the returned set of transactions is the  union set of all transactions of the parent (and any grandparents etc.) and the specified derived transaction portfolio itself.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -507,15 +507,15 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the portfolio group. (required)
         :type scope: str
-        :param code: The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group. (required)
+        :param code: The code of the portfolio group. Together with the scope this uniquely identifies               the portfolio group. (required)
         :type code: str
         :param transaction_query_parameters: The query queryParameters which control how the output transactions are built. (required)
         :type transaction_query_parameters: TransactionQueryParameters
-        :param as_at: The asAt datetime at which to build the transactions. Defaults to return the latest              version of each transaction if not specified.
+        :param as_at: The asAt datetime at which to build the transactions. Defaults to return the latest               version of each transaction if not specified.
         :type as_at: datetime
-        :param filter: Expression to filter the result set.              For example, to filter on the Transaction Type, use \"type eq 'Buy'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
+        :param filter: Expression to filter the result set.               For example, to filter on the Transaction Type, use \"type eq 'Buy'\"               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
-        :param property_keys: 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\".
+        :param property_keys: 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\".
         :type property_keys: List[str]
         :param limit: When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.
         :type limit: int
@@ -828,18 +828,18 @@ class PortfolioGroupsApi:
 
 
     @overload
-    async def delete_group_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to delete properties from.")], code : Annotated[StrictStr, Field(..., description="The code of the group to delete properties from. Together with the scope this uniquely identifies the group.")], request_body : Annotated[conlist(StrictStr), Field(..., description="The property keys of the properties to delete. These take the format             {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\". Each property must be from the \"PortfolioGroup\" domain.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.             The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is             before the time-variant property exists then a failure is returned. Do not specify this parameter if any of             the properties to delete are perpetual.")] = None, **kwargs) -> DeletedEntityResponse:  # noqa: E501
+    async def delete_group_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to delete properties from.")], code : Annotated[StrictStr, Field(..., description="The code of the group to delete properties from. Together with the scope this uniquely identifies the group.")], request_body : Annotated[conlist(StrictStr), Field(..., description="The property keys of the properties to delete. These take the format              {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\". Each property must be from the \"PortfolioGroup\" domain.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is              before the time-variant property exists then a failure is returned. Do not specify this parameter if any of              the properties to delete are perpetual.")] = None, **kwargs) -> DeletedEntityResponse:  # noqa: E501
         ...
 
     @overload
-    def delete_group_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to delete properties from.")], code : Annotated[StrictStr, Field(..., description="The code of the group to delete properties from. Together with the scope this uniquely identifies the group.")], request_body : Annotated[conlist(StrictStr), Field(..., description="The property keys of the properties to delete. These take the format             {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\". Each property must be from the \"PortfolioGroup\" domain.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.             The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is             before the time-variant property exists then a failure is returned. Do not specify this parameter if any of             the properties to delete are perpetual.")] = None, async_req: Optional[bool]=True, **kwargs) -> DeletedEntityResponse:  # noqa: E501
+    def delete_group_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to delete properties from.")], code : Annotated[StrictStr, Field(..., description="The code of the group to delete properties from. Together with the scope this uniquely identifies the group.")], request_body : Annotated[conlist(StrictStr), Field(..., description="The property keys of the properties to delete. These take the format              {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\". Each property must be from the \"PortfolioGroup\" domain.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is              before the time-variant property exists then a failure is returned. Do not specify this parameter if any of              the properties to delete are perpetual.")] = None, async_req: Optional[bool]=True, **kwargs) -> DeletedEntityResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def delete_group_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to delete properties from.")], code : Annotated[StrictStr, Field(..., description="The code of the group to delete properties from. Together with the scope this uniquely identifies the group.")], request_body : Annotated[conlist(StrictStr), Field(..., description="The property keys of the properties to delete. These take the format             {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\". Each property must be from the \"PortfolioGroup\" domain.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.             The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is             before the time-variant property exists then a failure is returned. Do not specify this parameter if any of             the properties to delete are perpetual.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
+    def delete_group_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to delete properties from.")], code : Annotated[StrictStr, Field(..., description="The code of the group to delete properties from. Together with the scope this uniquely identifies the group.")], request_body : Annotated[conlist(StrictStr), Field(..., description="The property keys of the properties to delete. These take the format              {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\". Each property must be from the \"PortfolioGroup\" domain.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is              before the time-variant property exists then a failure is returned. Do not specify this parameter if any of              the properties to delete are perpetual.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
         """[EARLY ACCESS] DeleteGroupProperties: Delete group properties  # noqa: E501
 
-        Delete one or more properties from a single portfolio group. If the properties are time variant then an effective date time from which the properties will be deleted must be specified. If the properties are perpetual then it is invalid to specify an effective date time for deletion.  # noqa: E501
+        Delete one or more properties from a single portfolio group. If the properties are time variant then an effective date time from which the properties  will be deleted must be specified. If the properties are perpetual then it is invalid to specify an effective date time for deletion.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -850,9 +850,9 @@ class PortfolioGroupsApi:
         :type scope: str
         :param code: The code of the group to delete properties from. Together with the scope this uniquely identifies the group. (required)
         :type code: str
-        :param request_body: The property keys of the properties to delete. These take the format             {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\". Each property must be from the \"PortfolioGroup\" domain. (required)
+        :param request_body: The property keys of the properties to delete. These take the format              {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\". Each property must be from the \"PortfolioGroup\" domain. (required)
         :type request_body: List[str]
-        :param effective_at: The effective datetime or cut label at which to delete time-variant properties from.             The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is             before the time-variant property exists then a failure is returned. Do not specify this parameter if any of             the properties to delete are perpetual.
+        :param effective_at: The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is              before the time-variant property exists then a failure is returned. Do not specify this parameter if any of              the properties to delete are perpetual.
         :type effective_at: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -873,10 +873,10 @@ class PortfolioGroupsApi:
         return self.delete_group_properties_with_http_info(scope, code, request_body, effective_at, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def delete_group_properties_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to delete properties from.")], code : Annotated[StrictStr, Field(..., description="The code of the group to delete properties from. Together with the scope this uniquely identifies the group.")], request_body : Annotated[conlist(StrictStr), Field(..., description="The property keys of the properties to delete. These take the format             {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\". Each property must be from the \"PortfolioGroup\" domain.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.             The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is             before the time-variant property exists then a failure is returned. Do not specify this parameter if any of             the properties to delete are perpetual.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def delete_group_properties_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to delete properties from.")], code : Annotated[StrictStr, Field(..., description="The code of the group to delete properties from. Together with the scope this uniquely identifies the group.")], request_body : Annotated[conlist(StrictStr), Field(..., description="The property keys of the properties to delete. These take the format              {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\". Each property must be from the \"PortfolioGroup\" domain.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is              before the time-variant property exists then a failure is returned. Do not specify this parameter if any of              the properties to delete are perpetual.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] DeleteGroupProperties: Delete group properties  # noqa: E501
 
-        Delete one or more properties from a single portfolio group. If the properties are time variant then an effective date time from which the properties will be deleted must be specified. If the properties are perpetual then it is invalid to specify an effective date time for deletion.  # noqa: E501
+        Delete one or more properties from a single portfolio group. If the properties are time variant then an effective date time from which the properties  will be deleted must be specified. If the properties are perpetual then it is invalid to specify an effective date time for deletion.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -887,9 +887,9 @@ class PortfolioGroupsApi:
         :type scope: str
         :param code: The code of the group to delete properties from. Together with the scope this uniquely identifies the group. (required)
         :type code: str
-        :param request_body: The property keys of the properties to delete. These take the format             {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\". Each property must be from the \"PortfolioGroup\" domain. (required)
+        :param request_body: The property keys of the properties to delete. These take the format              {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\". Each property must be from the \"PortfolioGroup\" domain. (required)
         :type request_body: List[str]
-        :param effective_at: The effective datetime or cut label at which to delete time-variant properties from.             The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is             before the time-variant property exists then a failure is returned. Do not specify this parameter if any of             the properties to delete are perpetual.
+        :param effective_at: The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is              before the time-variant property exists then a failure is returned. Do not specify this parameter if any of              the properties to delete are perpetual.
         :type effective_at: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -1022,7 +1022,7 @@ class PortfolioGroupsApi:
     def delete_key_from_portfolio_group_access_metadata(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Portfolio Group")], code : Annotated[StrictStr, Field(..., description="The Portfolio Group code")], metadata_key : Annotated[StrictStr, Field(..., description="Key of the Access Metadata entry to delete")], 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] DeleteKeyFromPortfolioGroupAccessMetadata: Delete a Portfolio Group Access Metadata entry  # noqa: E501
 
-        Deletes the Portfolio Group Access Metadata entry that exactly matches the provided identifier parts.  It is important to always check to verify success (or failure).  # noqa: E501
+        Deletes the Portfolio Group 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
         asynchronous HTTP request, please pass async_req=True
 
@@ -1061,7 +1061,7 @@ class PortfolioGroupsApi:
     def delete_key_from_portfolio_group_access_metadata_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Portfolio Group")], code : Annotated[StrictStr, Field(..., description="The Portfolio Group code")], metadata_key : Annotated[StrictStr, Field(..., description="Key of the Access Metadata entry to delete")], 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] DeleteKeyFromPortfolioGroupAccessMetadata: Delete a Portfolio Group Access Metadata entry  # noqa: E501
 
-        Deletes the Portfolio Group Access Metadata entry that exactly matches the provided identifier parts.  It is important to always check to verify success (or failure).  # noqa: E501
+        Deletes the Portfolio Group 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
         asynchronous HTTP request, please pass async_req=True
 
@@ -1393,7 +1393,7 @@ class PortfolioGroupsApi:
     def delete_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to delete.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to delete. Together with the scope this uniquely identifies the portfolio group to delete.")], async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
         """[EARLY ACCESS] DeletePortfolioGroup: Delete portfolio group  # noqa: E501
 
-        Delete a single portfolio group. A portfolio group can be deleted while it still contains portfolios or sub groups. In this case any portfolios or sub groups contained in this group will not be deleted, however they will no longer be grouped together by this portfolio group. The deletion will be valid from the portfolio group's creation datetime, ie. the portfolio group will no longer exist at any effective datetime from the asAt datetime of deletion.  # noqa: E501
+        Delete a single portfolio group. A portfolio group can be deleted while it still contains portfolios or sub groups.  In this case any portfolios or sub groups contained in this group will not be deleted, however they will no longer be grouped together by this portfolio group.  The deletion will be valid from the portfolio group's creation datetime, ie. the portfolio group will no longer exist at any effective datetime from the asAt datetime of deletion.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -1426,7 +1426,7 @@ class PortfolioGroupsApi:
     def delete_portfolio_group_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to delete.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to delete. Together with the scope this uniquely identifies the portfolio group to delete.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] DeletePortfolioGroup: Delete portfolio group  # noqa: E501
 
-        Delete a single portfolio group. A portfolio group can be deleted while it still contains portfolios or sub groups. In this case any portfolios or sub groups contained in this group will not be deleted, however they will no longer be grouped together by this portfolio group. The deletion will be valid from the portfolio group's creation datetime, ie. the portfolio group will no longer exist at any effective datetime from the asAt datetime of deletion.  # noqa: E501
+        Delete a single portfolio group. A portfolio group can be deleted while it still contains portfolios or sub groups.  In this case any portfolios or sub groups contained in this group will not be deleted, however they will no longer be grouped together by this portfolio group.  The deletion will be valid from the portfolio group's creation datetime, ie. the portfolio group will no longer exist at any effective datetime from the asAt datetime of deletion.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -1726,15 +1726,15 @@ class PortfolioGroupsApi:
 
 
     @overload
-    async def get_a2_b_data_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to retrieve the A2B report for.")], code : Annotated[StrictStr, Field(..., description="The code of the group to retrieve the A2B report for. Together with the scope this             uniquely identifies the portfolio group.")], from_effective_at : Annotated[StrictStr, Field(..., description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the data.             There is no lower bound if this is not specified.")], to_effective_at : Annotated[StrictStr, Field(..., description="The upper bound effective datetime or cut label (inclusive) from which to retrieve the data.             There is no upper bound if this is not specified.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the portfolio. Defaults to return the latest version             of each transaction if not specified.")] = 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\" domain to decorate onto             the results. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\".")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> VersionedResourceListOfA2BDataRecord:  # noqa: E501
+    async def get_a2_b_data_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to retrieve the A2B report for.")], code : Annotated[StrictStr, Field(..., description="The code of the group to retrieve the A2B report for. Together with the scope this              uniquely identifies the portfolio group.")], from_effective_at : Annotated[StrictStr, Field(..., description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the data.              There is no lower bound if this is not specified.")], to_effective_at : Annotated[StrictStr, Field(..., description="The upper bound effective datetime or cut label (inclusive) from which to retrieve the data.              There is no upper bound if this is not specified.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the portfolio. Defaults to return the latest version              of each transaction if not specified.")] = 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\" domain to decorate onto              the results. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\".")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> VersionedResourceListOfA2BDataRecord:  # noqa: E501
         ...
 
     @overload
-    def get_a2_b_data_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to retrieve the A2B report for.")], code : Annotated[StrictStr, Field(..., description="The code of the group to retrieve the A2B report for. Together with the scope this             uniquely identifies the portfolio group.")], from_effective_at : Annotated[StrictStr, Field(..., description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the data.             There is no lower bound if this is not specified.")], to_effective_at : Annotated[StrictStr, Field(..., description="The upper bound effective datetime or cut label (inclusive) from which to retrieve the data.             There is no upper bound if this is not specified.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the portfolio. Defaults to return the latest version             of each transaction if not specified.")] = 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\" domain to decorate onto             the results. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\".")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=True, **kwargs) -> VersionedResourceListOfA2BDataRecord:  # noqa: E501
+    def get_a2_b_data_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to retrieve the A2B report for.")], code : Annotated[StrictStr, Field(..., description="The code of the group to retrieve the A2B report for. Together with the scope this              uniquely identifies the portfolio group.")], from_effective_at : Annotated[StrictStr, Field(..., description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the data.              There is no lower bound if this is not specified.")], to_effective_at : Annotated[StrictStr, Field(..., description="The upper bound effective datetime or cut label (inclusive) from which to retrieve the data.              There is no upper bound if this is not specified.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the portfolio. Defaults to return the latest version              of each transaction if not specified.")] = 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\" domain to decorate onto              the results. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\".")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=True, **kwargs) -> VersionedResourceListOfA2BDataRecord:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_a2_b_data_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to retrieve the A2B report for.")], code : Annotated[StrictStr, Field(..., description="The code of the group to retrieve the A2B report for. Together with the scope this             uniquely identifies the portfolio group.")], from_effective_at : Annotated[StrictStr, Field(..., description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the data.             There is no lower bound if this is not specified.")], to_effective_at : Annotated[StrictStr, Field(..., description="The upper bound effective datetime or cut label (inclusive) from which to retrieve the data.             There is no upper bound if this is not specified.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the portfolio. Defaults to return the latest version             of each transaction if not specified.")] = 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\" domain to decorate onto             the results. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\".")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[VersionedResourceListOfA2BDataRecord, Awaitable[VersionedResourceListOfA2BDataRecord]]:  # noqa: E501
+    def get_a2_b_data_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to retrieve the A2B report for.")], code : Annotated[StrictStr, Field(..., description="The code of the group to retrieve the A2B report for. Together with the scope this              uniquely identifies the portfolio group.")], from_effective_at : Annotated[StrictStr, Field(..., description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the data.              There is no lower bound if this is not specified.")], to_effective_at : Annotated[StrictStr, Field(..., description="The upper bound effective datetime or cut label (inclusive) from which to retrieve the data.              There is no upper bound if this is not specified.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the portfolio. Defaults to return the latest version              of each transaction if not specified.")] = 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\" domain to decorate onto              the results. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\".")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[VersionedResourceListOfA2BDataRecord, Awaitable[VersionedResourceListOfA2BDataRecord]]:  # noqa: E501
         """[EARLY ACCESS] GetA2BDataForPortfolioGroup: Get A2B data for a Portfolio Group  # noqa: E501
 
         Get an A2B report for all Transaction Portfolios within the given portfolio group.  # noqa: E501
@@ -1746,21 +1746,21 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the group to retrieve the A2B report for. (required)
         :type scope: str
-        :param code: The code of the group to retrieve the A2B report for. Together with the scope this             uniquely identifies the portfolio group. (required)
+        :param code: The code of the group to retrieve the A2B report for. Together with the scope this              uniquely identifies the portfolio group. (required)
         :type code: str
-        :param from_effective_at: The lower bound effective datetime or cut label (inclusive) from which to retrieve the data.             There is no lower bound if this is not specified. (required)
+        :param from_effective_at: The lower bound effective datetime or cut label (inclusive) from which to retrieve the data.              There is no lower bound if this is not specified. (required)
         :type from_effective_at: str
-        :param to_effective_at: The upper bound effective datetime or cut label (inclusive) from which to retrieve the data.             There is no upper bound if this is not specified. (required)
+        :param to_effective_at: The upper bound effective datetime or cut label (inclusive) from which to retrieve the data.              There is no upper bound if this is not specified. (required)
         :type to_effective_at: str
-        :param as_at: The asAt datetime at which to retrieve the portfolio. Defaults to return the latest version             of each transaction if not specified.
+        :param as_at: The asAt datetime at which to retrieve the portfolio. Defaults to return the latest version              of each transaction if not specified.
         :type as_at: datetime
         :param recipe_id_scope: The scope of the given recipeId
         :type recipe_id_scope: str
         :param recipe_id_code: The code of the given recipeId
         :type recipe_id_code: str
-        :param property_keys: A list of property keys from the \"Instrument\" domain to decorate onto             the results. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\".
+        :param property_keys: A list of property keys from the \"Instrument\" domain to decorate onto              the results. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\".
         :type property_keys: List[str]
-        :param filter: Expression to filter the result set.             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
+        :param filter: Expression to filter the result set.              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -1781,7 +1781,7 @@ class PortfolioGroupsApi:
         return self.get_a2_b_data_for_portfolio_group_with_http_info(scope, code, from_effective_at, to_effective_at, as_at, recipe_id_scope, recipe_id_code, property_keys, filter, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_a2_b_data_for_portfolio_group_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to retrieve the A2B report for.")], code : Annotated[StrictStr, Field(..., description="The code of the group to retrieve the A2B report for. Together with the scope this             uniquely identifies the portfolio group.")], from_effective_at : Annotated[StrictStr, Field(..., description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the data.             There is no lower bound if this is not specified.")], to_effective_at : Annotated[StrictStr, Field(..., description="The upper bound effective datetime or cut label (inclusive) from which to retrieve the data.             There is no upper bound if this is not specified.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the portfolio. Defaults to return the latest version             of each transaction if not specified.")] = 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\" domain to decorate onto             the results. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\".")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_a2_b_data_for_portfolio_group_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to retrieve the A2B report for.")], code : Annotated[StrictStr, Field(..., description="The code of the group to retrieve the A2B report for. Together with the scope this              uniquely identifies the portfolio group.")], from_effective_at : Annotated[StrictStr, Field(..., description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the data.              There is no lower bound if this is not specified.")], to_effective_at : Annotated[StrictStr, Field(..., description="The upper bound effective datetime or cut label (inclusive) from which to retrieve the data.              There is no upper bound if this is not specified.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the portfolio. Defaults to return the latest version              of each transaction if not specified.")] = 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\" domain to decorate onto              the results. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\".")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] GetA2BDataForPortfolioGroup: Get A2B data for a Portfolio Group  # noqa: E501
 
         Get an A2B report for all Transaction Portfolios within the given portfolio group.  # noqa: E501
@@ -1793,21 +1793,21 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the group to retrieve the A2B report for. (required)
         :type scope: str
-        :param code: The code of the group to retrieve the A2B report for. Together with the scope this             uniquely identifies the portfolio group. (required)
+        :param code: The code of the group to retrieve the A2B report for. Together with the scope this              uniquely identifies the portfolio group. (required)
         :type code: str
-        :param from_effective_at: The lower bound effective datetime or cut label (inclusive) from which to retrieve the data.             There is no lower bound if this is not specified. (required)
+        :param from_effective_at: The lower bound effective datetime or cut label (inclusive) from which to retrieve the data.              There is no lower bound if this is not specified. (required)
         :type from_effective_at: str
-        :param to_effective_at: The upper bound effective datetime or cut label (inclusive) from which to retrieve the data.             There is no upper bound if this is not specified. (required)
+        :param to_effective_at: The upper bound effective datetime or cut label (inclusive) from which to retrieve the data.              There is no upper bound if this is not specified. (required)
         :type to_effective_at: str
-        :param as_at: The asAt datetime at which to retrieve the portfolio. Defaults to return the latest version             of each transaction if not specified.
+        :param as_at: The asAt datetime at which to retrieve the portfolio. Defaults to return the latest version              of each transaction if not specified.
         :type as_at: datetime
         :param recipe_id_scope: The scope of the given recipeId
         :type recipe_id_scope: str
         :param recipe_id_code: The code of the given recipeId
         :type recipe_id_code: str
-        :param property_keys: A list of property keys from the \"Instrument\" domain to decorate onto             the results. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\".
+        :param property_keys: A list of property keys from the \"Instrument\" domain to decorate onto              the results. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\".
         :type property_keys: List[str]
-        :param filter: Expression to filter the result set.             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
+        :param filter: Expression to filter the result set.              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -2125,15 +2125,15 @@ class PortfolioGroupsApi:
 
 
     @overload
-    async def get_holdings_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the holdings of transaction             portfolios in the portfolio group. 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 transaction portfolios in the portfolio group. 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. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"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, 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) -> VersionedResourceListOfPortfolioHolding:  # noqa: E501
+    async def get_holdings_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the holdings of transaction              portfolios in the portfolio group. 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 transaction portfolios in the portfolio group. 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. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"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, 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) -> VersionedResourceListOfPortfolioHolding:  # noqa: E501
         ...
 
     @overload
-    def get_holdings_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the holdings of transaction             portfolios in the portfolio group. 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 transaction portfolios in the portfolio group. 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. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"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, 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]=True, **kwargs) -> VersionedResourceListOfPortfolioHolding:  # noqa: E501
+    def get_holdings_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the holdings of transaction              portfolios in the portfolio group. 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 transaction portfolios in the portfolio group. 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. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"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, 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]=True, **kwargs) -> VersionedResourceListOfPortfolioHolding:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_holdings_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the holdings of transaction             portfolios in the portfolio group. 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 transaction portfolios in the portfolio group. 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. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"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, 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[VersionedResourceListOfPortfolioHolding, Awaitable[VersionedResourceListOfPortfolioHolding]]:  # noqa: E501
+    def get_holdings_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the holdings of transaction              portfolios in the portfolio group. 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 transaction portfolios in the portfolio group. 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. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"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, 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[VersionedResourceListOfPortfolioHolding, Awaitable[VersionedResourceListOfPortfolioHolding]]:  # noqa: E501
         """GetHoldingsForPortfolioGroup: Get holdings for transaction portfolios in portfolio group  # noqa: E501
 
         Get the holdings of transaction portfolios in specified portfolio group.  # noqa: E501
@@ -2145,17 +2145,17 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the portfolio group. (required)
         :type scope: str
-        :param code: The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group. (required)
+        :param code: The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group. (required)
         :type code: str
-        :param effective_at: The effective datetime or cut label at which to retrieve the holdings of transaction             portfolios in the portfolio group. Defaults to the current LUSID system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to retrieve the holdings of transaction              portfolios in the portfolio group. Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
-        :param as_at: The asAt datetime at which to retrieve the holdings of transaction portfolios in the portfolio group. Defaults             to return the latest version of the holdings if not specified.
+        :param as_at: The asAt datetime at which to retrieve the holdings of transaction portfolios in the portfolio group. Defaults              to return the latest version of the holdings if not specified.
         :type as_at: datetime
         :param filter: Expression to filter the result set. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
-        :param property_keys: 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\".
+        :param property_keys: 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\".
         :type property_keys: List[str]
-        :param by_taxlots: Whether or not to expand the holdings to return the underlying tax-lots. Defaults to             False.
+        :param by_taxlots: Whether or not to expand the holdings to return the underlying tax-lots. Defaults to              False.
         :type by_taxlots: bool
         :param include_settlement_events_after_days: Number of days ahead to bring back settlements from, in relation to the specified effectiveAt
         :type include_settlement_events_after_days: int
@@ -2178,7 +2178,7 @@ class PortfolioGroupsApi:
         return self.get_holdings_for_portfolio_group_with_http_info(scope, code, effective_at, as_at, filter, property_keys, by_taxlots, include_settlement_events_after_days, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_holdings_for_portfolio_group_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the holdings of transaction             portfolios in the portfolio group. 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 transaction portfolios in the portfolio group. 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. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"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, 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
+    def get_holdings_for_portfolio_group_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the holdings of transaction              portfolios in the portfolio group. 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 transaction portfolios in the portfolio group. 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. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"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, 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
         """GetHoldingsForPortfolioGroup: Get holdings for transaction portfolios in portfolio group  # noqa: E501
 
         Get the holdings of transaction portfolios in specified portfolio group.  # noqa: E501
@@ -2190,17 +2190,17 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the portfolio group. (required)
         :type scope: str
-        :param code: The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group. (required)
+        :param code: The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group. (required)
         :type code: str
-        :param effective_at: The effective datetime or cut label at which to retrieve the holdings of transaction             portfolios in the portfolio group. Defaults to the current LUSID system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to retrieve the holdings of transaction              portfolios in the portfolio group. Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
-        :param as_at: The asAt datetime at which to retrieve the holdings of transaction portfolios in the portfolio group. Defaults             to return the latest version of the holdings if not specified.
+        :param as_at: The asAt datetime at which to retrieve the holdings of transaction portfolios in the portfolio group. Defaults              to return the latest version of the holdings if not specified.
         :type as_at: datetime
         :param filter: Expression to filter the result set. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
-        :param property_keys: 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\".
+        :param property_keys: 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\".
         :type property_keys: List[str]
-        :param by_taxlots: Whether or not to expand the holdings to return the underlying tax-lots. Defaults to             False.
+        :param by_taxlots: Whether or not to expand the holdings to return the underlying tax-lots. Defaults to              False.
         :type by_taxlots: bool
         :param include_settlement_events_after_days: Number of days ahead to bring back settlements from, in relation to the specified effectiveAt
         :type include_settlement_events_after_days: int
@@ -2337,15 +2337,15 @@ class PortfolioGroupsApi:
 
 
     @overload
-    async def get_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to retrieve the definition for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to retrieve the definition for. Together with the scope             this uniquely identifies the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the portfolio group definition. 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 portfolio group definition. Defaults to return             the latest version of the portfolio group definition if not specified.")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships             to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities             onto the portfolio group in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> PortfolioGroup:  # noqa: E501
+    async def get_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to retrieve the definition for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to retrieve the definition for. Together with the scope              this uniquely identifies the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the portfolio group definition. 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 portfolio group definition. Defaults to return              the latest version of the portfolio group definition if not specified.")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships              to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the portfolio group in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> PortfolioGroup:  # noqa: E501
         ...
 
     @overload
-    def get_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to retrieve the definition for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to retrieve the definition for. Together with the scope             this uniquely identifies the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the portfolio group definition. 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 portfolio group definition. Defaults to return             the latest version of the portfolio group definition if not specified.")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships             to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities             onto the portfolio group in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, async_req: Optional[bool]=True, **kwargs) -> PortfolioGroup:  # noqa: E501
+    def get_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to retrieve the definition for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to retrieve the definition for. Together with the scope              this uniquely identifies the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the portfolio group definition. 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 portfolio group definition. Defaults to return              the latest version of the portfolio group definition if not specified.")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships              to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the portfolio group in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, async_req: Optional[bool]=True, **kwargs) -> PortfolioGroup:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to retrieve the definition for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to retrieve the definition for. Together with the scope             this uniquely identifies the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the portfolio group definition. 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 portfolio group definition. Defaults to return             the latest version of the portfolio group definition if not specified.")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships             to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities             onto the portfolio group in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PortfolioGroup, Awaitable[PortfolioGroup]]:  # noqa: E501
+    def get_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to retrieve the definition for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to retrieve the definition for. Together with the scope              this uniquely identifies the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the portfolio group definition. 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 portfolio group definition. Defaults to return              the latest version of the portfolio group definition if not specified.")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships              to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the portfolio group in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PortfolioGroup, Awaitable[PortfolioGroup]]:  # noqa: E501
         """GetPortfolioGroup: Get portfolio group  # noqa: E501
 
         Retrieve the definition of a single portfolio group.  # noqa: E501
@@ -2357,15 +2357,15 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the portfolio group to retrieve the definition for. (required)
         :type scope: str
-        :param code: The code of the portfolio group to retrieve the definition for. Together with the scope             this uniquely identifies the portfolio group. (required)
+        :param code: The code of the portfolio group to retrieve the definition for. Together with the scope              this uniquely identifies the portfolio group. (required)
         :type code: str
         :param effective_at: The effective datetime or cut label at which to retrieve the portfolio group definition. Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
-        :param as_at: The asAt datetime at which to retrieve the portfolio group definition. Defaults to return             the latest version of the portfolio group definition if not specified.
+        :param as_at: The asAt datetime at which to retrieve the portfolio group definition. Defaults to return              the latest version of the portfolio group definition if not specified.
         :type as_at: datetime
-        :param related_entity_property_keys: A list of property keys from any domain that supports relationships             to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.
+        :param related_entity_property_keys: A list of property keys from any domain that supports relationships              to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.
         :type related_entity_property_keys: List[str]
-        :param relationship_definition_ids: A list of relationship definitions that are used to decorate related entities             onto the portfolio group in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.
+        :param relationship_definition_ids: A list of relationship definitions that are used to decorate related entities              onto the portfolio group in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.
         :type relationship_definition_ids: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -2386,7 +2386,7 @@ class PortfolioGroupsApi:
         return self.get_portfolio_group_with_http_info(scope, code, effective_at, as_at, related_entity_property_keys, relationship_definition_ids, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_portfolio_group_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to retrieve the definition for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to retrieve the definition for. Together with the scope             this uniquely identifies the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the portfolio group definition. 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 portfolio group definition. Defaults to return             the latest version of the portfolio group definition if not specified.")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships             to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities             onto the portfolio group in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_portfolio_group_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to retrieve the definition for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to retrieve the definition for. Together with the scope              this uniquely identifies the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the portfolio group definition. 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 portfolio group definition. Defaults to return              the latest version of the portfolio group definition if not specified.")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships              to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the portfolio group in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """GetPortfolioGroup: Get portfolio group  # noqa: E501
 
         Retrieve the definition of a single portfolio group.  # noqa: E501
@@ -2398,15 +2398,15 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the portfolio group to retrieve the definition for. (required)
         :type scope: str
-        :param code: The code of the portfolio group to retrieve the definition for. Together with the scope             this uniquely identifies the portfolio group. (required)
+        :param code: The code of the portfolio group to retrieve the definition for. Together with the scope              this uniquely identifies the portfolio group. (required)
         :type code: str
         :param effective_at: The effective datetime or cut label at which to retrieve the portfolio group definition. Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
-        :param as_at: The asAt datetime at which to retrieve the portfolio group definition. Defaults to return             the latest version of the portfolio group definition if not specified.
+        :param as_at: The asAt datetime at which to retrieve the portfolio group definition. Defaults to return              the latest version of the portfolio group definition if not specified.
         :type as_at: datetime
-        :param related_entity_property_keys: A list of property keys from any domain that supports relationships             to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.
+        :param related_entity_property_keys: A list of property keys from any domain that supports relationships              to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.
         :type related_entity_property_keys: List[str]
-        :param relationship_definition_ids: A list of relationship definitions that are used to decorate related entities             onto the portfolio group in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.
+        :param relationship_definition_ids: A list of relationship definitions that are used to decorate related entities              onto the portfolio group in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.
         :type relationship_definition_ids: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -2545,7 +2545,7 @@ class PortfolioGroupsApi:
     def get_portfolio_group_access_metadata_by_key(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Portfolio Group")], code : Annotated[StrictStr, Field(..., description="The Portfolio Group code")], metadata_key : Annotated[StrictStr, Field(..., description="Key of the metadata entry to retrieve")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the access metadata")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the access metadata")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[List[AccessMetadataValue], Awaitable[List[AccessMetadataValue]]]:  # noqa: E501
         """[EARLY ACCESS] GetPortfolioGroupAccessMetadataByKey: Get an entry identified by a metadataKey in the Access Metadata of a Portfolio Group  # noqa: E501
 
-        Get a specific Portfolio Group access metadata by specifying the corresponding identifier parts              No matching will be performed through this endpoint. To retrieve a rule, it is necessary to specify, exactly, the identifier of the rule  # noqa: E501
+        Get a specific Portfolio Group access metadata by specifying the corresponding identifier parts                No matching will be performed through this endpoint. To retrieve a rule, it is necessary to specify, exactly, the identifier of the rule  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -2584,7 +2584,7 @@ class PortfolioGroupsApi:
     def get_portfolio_group_access_metadata_by_key_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Portfolio Group")], code : Annotated[StrictStr, Field(..., description="The Portfolio Group code")], metadata_key : Annotated[StrictStr, Field(..., description="Key of the metadata entry to retrieve")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the access metadata")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the access metadata")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] GetPortfolioGroupAccessMetadataByKey: Get an entry identified by a metadataKey in the Access Metadata of a Portfolio Group  # noqa: E501
 
-        Get a specific Portfolio Group access metadata by specifying the corresponding identifier parts              No matching will be performed through this endpoint. To retrieve a rule, it is necessary to specify, exactly, the identifier of the rule  # noqa: E501
+        Get a specific Portfolio Group access metadata by specifying the corresponding identifier parts                No matching will be performed through this endpoint. To retrieve a rule, it is necessary to specify, exactly, the identifier of the rule  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -2721,15 +2721,15 @@ class PortfolioGroupsApi:
 
 
     @overload
-    async def get_portfolio_group_commands(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to retrieve the commands for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to retrieve the commands for. Together with the scope this uniquely identifies the portfolio group.")], from_as_at : Annotated[Optional[datetime], Field(description="The lower bound asAt datetime (inclusive) from which to retrieve commands. There is no lower bound if this is not specified.")] = None, to_as_at : Annotated[Optional[datetime], Field(description="The upper bound asAt datetime (inclusive) from which to retrieve commands. There is no upper bound if this is not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the User ID, use \"userId.id eq 'string'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ResourceListOfProcessedCommand:  # noqa: E501
+    async def get_portfolio_group_commands(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to retrieve the commands for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to retrieve the commands for. Together with the scope this uniquely identifies the portfolio group.")], from_as_at : Annotated[Optional[datetime], Field(description="The lower bound asAt datetime (inclusive) from which to retrieve commands. There is no lower bound if this is not specified.")] = None, to_as_at : Annotated[Optional[datetime], Field(description="The upper bound asAt datetime (inclusive) from which to retrieve commands. There is no upper bound if this is not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               For example, to filter on the User ID, use \"userId.id eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ResourceListOfProcessedCommand:  # noqa: E501
         ...
 
     @overload
-    def get_portfolio_group_commands(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to retrieve the commands for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to retrieve the commands for. Together with the scope this uniquely identifies the portfolio group.")], from_as_at : Annotated[Optional[datetime], Field(description="The lower bound asAt datetime (inclusive) from which to retrieve commands. There is no lower bound if this is not specified.")] = None, to_as_at : Annotated[Optional[datetime], Field(description="The upper bound asAt datetime (inclusive) from which to retrieve commands. There is no upper bound if this is not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the User ID, use \"userId.id eq 'string'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfProcessedCommand:  # noqa: E501
+    def get_portfolio_group_commands(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to retrieve the commands for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to retrieve the commands for. Together with the scope this uniquely identifies the portfolio group.")], from_as_at : Annotated[Optional[datetime], Field(description="The lower bound asAt datetime (inclusive) from which to retrieve commands. There is no lower bound if this is not specified.")] = None, to_as_at : Annotated[Optional[datetime], Field(description="The upper bound asAt datetime (inclusive) from which to retrieve commands. There is no upper bound if this is not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               For example, to filter on the User ID, use \"userId.id eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfProcessedCommand:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_portfolio_group_commands(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to retrieve the commands for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to retrieve the commands for. Together with the scope this uniquely identifies the portfolio group.")], from_as_at : Annotated[Optional[datetime], Field(description="The lower bound asAt datetime (inclusive) from which to retrieve commands. There is no lower bound if this is not specified.")] = None, to_as_at : Annotated[Optional[datetime], Field(description="The upper bound asAt datetime (inclusive) from which to retrieve commands. There is no upper bound if this is not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the User ID, use \"userId.id eq 'string'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfProcessedCommand, Awaitable[ResourceListOfProcessedCommand]]:  # noqa: E501
+    def get_portfolio_group_commands(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to retrieve the commands for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to retrieve the commands for. Together with the scope this uniquely identifies the portfolio group.")], from_as_at : Annotated[Optional[datetime], Field(description="The lower bound asAt datetime (inclusive) from which to retrieve commands. There is no lower bound if this is not specified.")] = None, to_as_at : Annotated[Optional[datetime], Field(description="The upper bound asAt datetime (inclusive) from which to retrieve commands. There is no upper bound if this is not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               For example, to filter on the User ID, use \"userId.id eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfProcessedCommand, Awaitable[ResourceListOfProcessedCommand]]:  # noqa: E501
         """GetPortfolioGroupCommands: Get portfolio group commands  # noqa: E501
 
         Gets all the commands that modified a single portfolio group.  # noqa: E501
@@ -2747,7 +2747,7 @@ class PortfolioGroupsApi:
         :type from_as_at: datetime
         :param to_as_at: The upper bound asAt datetime (inclusive) from which to retrieve commands. There is no upper bound if this is not specified.
         :type to_as_at: datetime
-        :param filter: Expression to filter the result set.              For example, to filter on the User ID, use \"userId.id eq 'string'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
+        :param filter: Expression to filter the result set.               For example, to filter on the User ID, use \"userId.id eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -2768,7 +2768,7 @@ class PortfolioGroupsApi:
         return self.get_portfolio_group_commands_with_http_info(scope, code, from_as_at, to_as_at, filter, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_portfolio_group_commands_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to retrieve the commands for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to retrieve the commands for. Together with the scope this uniquely identifies the portfolio group.")], from_as_at : Annotated[Optional[datetime], Field(description="The lower bound asAt datetime (inclusive) from which to retrieve commands. There is no lower bound if this is not specified.")] = None, to_as_at : Annotated[Optional[datetime], Field(description="The upper bound asAt datetime (inclusive) from which to retrieve commands. There is no upper bound if this is not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the User ID, use \"userId.id eq 'string'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_portfolio_group_commands_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to retrieve the commands for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to retrieve the commands for. Together with the scope this uniquely identifies the portfolio group.")], from_as_at : Annotated[Optional[datetime], Field(description="The lower bound asAt datetime (inclusive) from which to retrieve commands. There is no lower bound if this is not specified.")] = None, to_as_at : Annotated[Optional[datetime], Field(description="The upper bound asAt datetime (inclusive) from which to retrieve commands. There is no upper bound if this is not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               For example, to filter on the User ID, use \"userId.id eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """GetPortfolioGroupCommands: Get portfolio group commands  # noqa: E501
 
         Gets all the commands that modified a single portfolio group.  # noqa: E501
@@ -2786,7 +2786,7 @@ class PortfolioGroupsApi:
         :type from_as_at: datetime
         :param to_as_at: The upper bound asAt datetime (inclusive) from which to retrieve commands. There is no upper bound if this is not specified.
         :type to_as_at: datetime
-        :param filter: Expression to filter the result set.              For example, to filter on the User ID, use \"userId.id eq 'string'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
+        :param filter: Expression to filter the result set.               For example, to filter on the User ID, use \"userId.id eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -2911,15 +2911,15 @@ class PortfolioGroupsApi:
 
 
     @overload
-    async def get_portfolio_group_expansion(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to expand.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to expand. Together with the scope this uniquely identifies the portfolio             group to expand.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to expand the portfolio group. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to expand the portfolio group. Defaults to return the latest version of each portfolio in the group if not specified.")] = None, property_filter : Annotated[Optional[conlist(StrictStr)], Field(description="The restricted list of property keys from the \"Portfolio\" domain which will be decorated onto each portfolio. These take the format {domain}/{scope}/{code} e.g. \"Portfolio/Manager/Id\".")] = None, **kwargs) -> ExpandedGroup:  # noqa: E501
+    async def get_portfolio_group_expansion(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to expand.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to expand. Together with the scope this uniquely identifies the portfolio              group to expand.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to expand the portfolio group. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to expand the portfolio group. Defaults to return the latest version of each portfolio in the group if not specified.")] = None, property_filter : Annotated[Optional[conlist(StrictStr)], Field(description="The restricted list of property keys from the \"Portfolio\" domain which will be decorated onto each portfolio. These take the format {domain}/{scope}/{code} e.g. \"Portfolio/Manager/Id\".")] = None, **kwargs) -> ExpandedGroup:  # noqa: E501
         ...
 
     @overload
-    def get_portfolio_group_expansion(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to expand.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to expand. Together with the scope this uniquely identifies the portfolio             group to expand.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to expand the portfolio group. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to expand the portfolio group. Defaults to return the latest version of each portfolio in the group if not specified.")] = None, property_filter : Annotated[Optional[conlist(StrictStr)], Field(description="The restricted list of property keys from the \"Portfolio\" domain which will be decorated onto each portfolio. These take the format {domain}/{scope}/{code} e.g. \"Portfolio/Manager/Id\".")] = None, async_req: Optional[bool]=True, **kwargs) -> ExpandedGroup:  # noqa: E501
+    def get_portfolio_group_expansion(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to expand.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to expand. Together with the scope this uniquely identifies the portfolio              group to expand.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to expand the portfolio group. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to expand the portfolio group. Defaults to return the latest version of each portfolio in the group if not specified.")] = None, property_filter : Annotated[Optional[conlist(StrictStr)], Field(description="The restricted list of property keys from the \"Portfolio\" domain which will be decorated onto each portfolio. These take the format {domain}/{scope}/{code} e.g. \"Portfolio/Manager/Id\".")] = None, async_req: Optional[bool]=True, **kwargs) -> ExpandedGroup:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_portfolio_group_expansion(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to expand.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to expand. Together with the scope this uniquely identifies the portfolio             group to expand.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to expand the portfolio group. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to expand the portfolio group. Defaults to return the latest version of each portfolio in the group if not specified.")] = None, property_filter : Annotated[Optional[conlist(StrictStr)], Field(description="The restricted list of property keys from the \"Portfolio\" domain which will be decorated onto each portfolio. These take the format {domain}/{scope}/{code} e.g. \"Portfolio/Manager/Id\".")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ExpandedGroup, Awaitable[ExpandedGroup]]:  # noqa: E501
+    def get_portfolio_group_expansion(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to expand.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to expand. Together with the scope this uniquely identifies the portfolio              group to expand.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to expand the portfolio group. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to expand the portfolio group. Defaults to return the latest version of each portfolio in the group if not specified.")] = None, property_filter : Annotated[Optional[conlist(StrictStr)], Field(description="The restricted list of property keys from the \"Portfolio\" domain which will be decorated onto each portfolio. These take the format {domain}/{scope}/{code} e.g. \"Portfolio/Manager/Id\".")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ExpandedGroup, Awaitable[ExpandedGroup]]:  # noqa: E501
         """[EARLY ACCESS] GetPortfolioGroupExpansion: Get portfolio group expansion  # noqa: E501
 
         List all the portfolios in a group, including all portfolios within sub groups in the group. Each portfolio will be decorated with all of its properties unless a property filter is specified.  # noqa: E501
@@ -2931,7 +2931,7 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the portfolio group to expand. (required)
         :type scope: str
-        :param code: The code of the portfolio group to expand. Together with the scope this uniquely identifies the portfolio             group to expand. (required)
+        :param code: The code of the portfolio group to expand. Together with the scope this uniquely identifies the portfolio              group to expand. (required)
         :type code: str
         :param effective_at: The effective datetime or cut label at which to expand the portfolio group. Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
@@ -2958,7 +2958,7 @@ class PortfolioGroupsApi:
         return self.get_portfolio_group_expansion_with_http_info(scope, code, effective_at, as_at, property_filter, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_portfolio_group_expansion_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to expand.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to expand. Together with the scope this uniquely identifies the portfolio             group to expand.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to expand the portfolio group. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to expand the portfolio group. Defaults to return the latest version of each portfolio in the group if not specified.")] = None, property_filter : Annotated[Optional[conlist(StrictStr)], Field(description="The restricted list of property keys from the \"Portfolio\" domain which will be decorated onto each portfolio. These take the format {domain}/{scope}/{code} e.g. \"Portfolio/Manager/Id\".")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_portfolio_group_expansion_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to expand.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to expand. Together with the scope this uniquely identifies the portfolio              group to expand.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to expand the portfolio group. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to expand the portfolio group. Defaults to return the latest version of each portfolio in the group if not specified.")] = None, property_filter : Annotated[Optional[conlist(StrictStr)], Field(description="The restricted list of property keys from the \"Portfolio\" domain which will be decorated onto each portfolio. These take the format {domain}/{scope}/{code} e.g. \"Portfolio/Manager/Id\".")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] GetPortfolioGroupExpansion: Get portfolio group expansion  # noqa: E501
 
         List all the portfolios in a group, including all portfolios within sub groups in the group. Each portfolio will be decorated with all of its properties unless a property filter is specified.  # noqa: E501
@@ -2970,7 +2970,7 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the portfolio group to expand. (required)
         :type scope: str
-        :param code: The code of the portfolio group to expand. Together with the scope this uniquely identifies the portfolio             group to expand. (required)
+        :param code: The code of the portfolio group to expand. Together with the scope this uniquely identifies the portfolio              group to expand. (required)
         :type code: str
         :param effective_at: The effective datetime or cut label at which to expand the portfolio group. Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
@@ -3278,15 +3278,15 @@ class PortfolioGroupsApi:
 
 
     @overload
-    async def get_portfolio_group_property_time_series(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group.")], code : Annotated[StrictStr, Field(..., description="The code of the group. Together with the scope this uniquely identifies             the portfolio group.")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property that will have its history shown. These must be in the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".             Each property must be from the \"PortfolioGroup\" domain.")], portfolio_group_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime used to resolve the portfolio group. 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 portfolio group's property history. Defaults to return the current datetime if not supplied.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing properties from a previous call to get property time series.             This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, and asAt fields             must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, **kwargs) -> ResourceListOfPropertyInterval:  # noqa: E501
+    async def get_portfolio_group_property_time_series(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group.")], code : Annotated[StrictStr, Field(..., description="The code of the group. Together with the scope this uniquely identifies              the portfolio group.")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property that will have its history shown. These must be in the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".              Each property must be from the \"PortfolioGroup\" domain.")], portfolio_group_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime used to resolve the portfolio group. 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 portfolio group's property history. Defaults to return the current datetime if not supplied.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing properties from a previous call to get property time series.              This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, **kwargs) -> ResourceListOfPropertyInterval:  # noqa: E501
         ...
 
     @overload
-    def get_portfolio_group_property_time_series(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group.")], code : Annotated[StrictStr, Field(..., description="The code of the group. Together with the scope this uniquely identifies             the portfolio group.")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property that will have its history shown. These must be in the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".             Each property must be from the \"PortfolioGroup\" domain.")], portfolio_group_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime used to resolve the portfolio group. 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 portfolio group's property history. Defaults to return the current datetime if not supplied.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing properties from a previous call to get property time series.             This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, and asAt fields             must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfPropertyInterval:  # noqa: E501
+    def get_portfolio_group_property_time_series(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group.")], code : Annotated[StrictStr, Field(..., description="The code of the group. Together with the scope this uniquely identifies              the portfolio group.")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property that will have its history shown. These must be in the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".              Each property must be from the \"PortfolioGroup\" domain.")], portfolio_group_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime used to resolve the portfolio group. 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 portfolio group's property history. Defaults to return the current datetime if not supplied.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing properties from a previous call to get property time series.              This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfPropertyInterval:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_portfolio_group_property_time_series(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group.")], code : Annotated[StrictStr, Field(..., description="The code of the group. Together with the scope this uniquely identifies             the portfolio group.")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property that will have its history shown. These must be in the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".             Each property must be from the \"PortfolioGroup\" domain.")], portfolio_group_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime used to resolve the portfolio group. 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 portfolio group's property history. Defaults to return the current datetime if not supplied.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing properties from a previous call to get property time series.             This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, and asAt fields             must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfPropertyInterval, Awaitable[ResourceListOfPropertyInterval]]:  # noqa: E501
+    def get_portfolio_group_property_time_series(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group.")], code : Annotated[StrictStr, Field(..., description="The code of the group. Together with the scope this uniquely identifies              the portfolio group.")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property that will have its history shown. These must be in the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".              Each property must be from the \"PortfolioGroup\" domain.")], portfolio_group_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime used to resolve the portfolio group. 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 portfolio group's property history. Defaults to return the current datetime if not supplied.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing properties from a previous call to get property time series.              This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfPropertyInterval, Awaitable[ResourceListOfPropertyInterval]]:  # noqa: E501
         """[EARLY ACCESS] GetPortfolioGroupPropertyTimeSeries: Get the time series of a portfolio group property  # noqa: E501
 
         List the complete time series of a portfolio group property.  # noqa: E501
@@ -3298,9 +3298,9 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the group. (required)
         :type scope: str
-        :param code: The code of the group. Together with the scope this uniquely identifies             the portfolio group. (required)
+        :param code: The code of the group. Together with the scope this uniquely identifies              the portfolio group. (required)
         :type code: str
-        :param property_key: The property key of the property that will have its history shown. These must be in the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".             Each property must be from the \"PortfolioGroup\" domain. (required)
+        :param property_key: The property key of the property that will have its history shown. These must be in the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".              Each property must be from the \"PortfolioGroup\" domain. (required)
         :type property_key: str
         :param portfolio_group_effective_at: The effective datetime used to resolve the portfolio group. Defaults to the current LUSID system datetime if not specified.
         :type portfolio_group_effective_at: str
@@ -3308,7 +3308,7 @@ class PortfolioGroupsApi:
         :type as_at: datetime
         :param filter: Expression to filter the result set. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
-        :param page: The pagination token to use to continue listing properties from a previous call to get property time series.             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.
+        :param page: The pagination token to use to continue listing properties from a previous call to get property time series.              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.
         :type page: str
         :param limit: When paginating, limit the number of returned results to this many.
         :type limit: int
@@ -3331,7 +3331,7 @@ class PortfolioGroupsApi:
         return self.get_portfolio_group_property_time_series_with_http_info(scope, code, property_key, portfolio_group_effective_at, as_at, filter, page, limit, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_portfolio_group_property_time_series_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group.")], code : Annotated[StrictStr, Field(..., description="The code of the group. Together with the scope this uniquely identifies             the portfolio group.")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property that will have its history shown. These must be in the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".             Each property must be from the \"PortfolioGroup\" domain.")], portfolio_group_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime used to resolve the portfolio group. 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 portfolio group's property history. Defaults to return the current datetime if not supplied.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing properties from a previous call to get property time series.             This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, and asAt fields             must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_portfolio_group_property_time_series_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group.")], code : Annotated[StrictStr, Field(..., description="The code of the group. Together with the scope this uniquely identifies              the portfolio group.")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property that will have its history shown. These must be in the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".              Each property must be from the \"PortfolioGroup\" domain.")], portfolio_group_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime used to resolve the portfolio group. 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 portfolio group's property history. Defaults to return the current datetime if not supplied.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing properties from a previous call to get property time series.              This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] GetPortfolioGroupPropertyTimeSeries: Get the time series of a portfolio group property  # noqa: E501
 
         List the complete time series of a portfolio group property.  # noqa: E501
@@ -3343,9 +3343,9 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the group. (required)
         :type scope: str
-        :param code: The code of the group. Together with the scope this uniquely identifies             the portfolio group. (required)
+        :param code: The code of the group. Together with the scope this uniquely identifies              the portfolio group. (required)
         :type code: str
-        :param property_key: The property key of the property that will have its history shown. These must be in the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".             Each property must be from the \"PortfolioGroup\" domain. (required)
+        :param property_key: The property key of the property that will have its history shown. These must be in the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".              Each property must be from the \"PortfolioGroup\" domain. (required)
         :type property_key: str
         :param portfolio_group_effective_at: The effective datetime used to resolve the portfolio group. Defaults to the current LUSID system datetime if not specified.
         :type portfolio_group_effective_at: str
@@ -3353,7 +3353,7 @@ class PortfolioGroupsApi:
         :type as_at: datetime
         :param filter: Expression to filter the result set. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
-        :param page: The pagination token to use to continue listing properties from a previous call to get property time series.             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.
+        :param page: The pagination token to use to continue listing properties from a previous call to get property time series.              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.
         :type page: str
         :param limit: When paginating, limit the number of returned results to this many.
         :type limit: int
@@ -3489,15 +3489,15 @@ class PortfolioGroupsApi:
 
 
     @overload
-    async def get_portfolio_group_relations(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve relations. 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 relations. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the relations. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifiers types (as property keys) used for referencing Persons or Legal Entities. These take the format             {domain}/{scope}/{code} e.g. \"Person/CompanyDetails/Role\". They must be from the \"Person\" or \"LegalEntity\" domain.             Only identifier types stated will be used to look up relevant entities in relations. If not applicable, provide an empty array.")] = None, **kwargs) -> ResourceListOfRelation:  # noqa: E501
+    async def get_portfolio_group_relations(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve relations. 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 relations. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the relations. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifiers types (as property keys) used for referencing Persons or Legal Entities. These take the format              {domain}/{scope}/{code} e.g. \"Person/CompanyDetails/Role\". They must be from the \"Person\" or \"LegalEntity\" domain.              Only identifier types stated will be used to look up relevant entities in relations. If not applicable, provide an empty array.")] = None, **kwargs) -> ResourceListOfRelation:  # noqa: E501
         ...
 
     @overload
-    def get_portfolio_group_relations(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve relations. 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 relations. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the relations. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifiers types (as property keys) used for referencing Persons or Legal Entities. These take the format             {domain}/{scope}/{code} e.g. \"Person/CompanyDetails/Role\". They must be from the \"Person\" or \"LegalEntity\" domain.             Only identifier types stated will be used to look up relevant entities in relations. If not applicable, provide an empty array.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfRelation:  # noqa: E501
+    def get_portfolio_group_relations(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve relations. 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 relations. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the relations. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifiers types (as property keys) used for referencing Persons or Legal Entities. These take the format              {domain}/{scope}/{code} e.g. \"Person/CompanyDetails/Role\". They must be from the \"Person\" or \"LegalEntity\" domain.              Only identifier types stated will be used to look up relevant entities in relations. If not applicable, provide an empty array.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfRelation:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_portfolio_group_relations(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve relations. 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 relations. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the relations. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifiers types (as property keys) used for referencing Persons or Legal Entities. These take the format             {domain}/{scope}/{code} e.g. \"Person/CompanyDetails/Role\". They must be from the \"Person\" or \"LegalEntity\" domain.             Only identifier types stated will be used to look up relevant entities in relations. If not applicable, provide an empty array.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfRelation, Awaitable[ResourceListOfRelation]]:  # noqa: E501
+    def get_portfolio_group_relations(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve relations. 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 relations. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the relations. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifiers types (as property keys) used for referencing Persons or Legal Entities. These take the format              {domain}/{scope}/{code} e.g. \"Person/CompanyDetails/Role\". They must be from the \"Person\" or \"LegalEntity\" domain.              Only identifier types stated will be used to look up relevant entities in relations. If not applicable, provide an empty array.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfRelation, Awaitable[ResourceListOfRelation]]:  # noqa: E501
         """[EXPERIMENTAL] GetPortfolioGroupRelations: Get Relations for Portfolio Group  # noqa: E501
 
         Get relations for the specified Portfolio Group  # noqa: E501
@@ -3509,7 +3509,7 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the portfolio group. (required)
         :type scope: str
-        :param code: The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group. (required)
+        :param code: The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group. (required)
         :type code: str
         :param effective_at: The effective datetime or cut label at which to retrieve relations. Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
@@ -3517,7 +3517,7 @@ class PortfolioGroupsApi:
         :type as_at: datetime
         :param filter: Expression to filter the relations. Users should provide null or empty string for this field until further notice.
         :type filter: str
-        :param identifier_types: Identifiers types (as property keys) used for referencing Persons or Legal Entities. These take the format             {domain}/{scope}/{code} e.g. \"Person/CompanyDetails/Role\". They must be from the \"Person\" or \"LegalEntity\" domain.             Only identifier types stated will be used to look up relevant entities in relations. If not applicable, provide an empty array.
+        :param identifier_types: Identifiers types (as property keys) used for referencing Persons or Legal Entities. These take the format              {domain}/{scope}/{code} e.g. \"Person/CompanyDetails/Role\". They must be from the \"Person\" or \"LegalEntity\" domain.              Only identifier types stated will be used to look up relevant entities in relations. If not applicable, provide an empty array.
         :type identifier_types: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -3538,7 +3538,7 @@ class PortfolioGroupsApi:
         return self.get_portfolio_group_relations_with_http_info(scope, code, effective_at, as_at, filter, identifier_types, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_portfolio_group_relations_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve relations. 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 relations. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the relations. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifiers types (as property keys) used for referencing Persons or Legal Entities. These take the format             {domain}/{scope}/{code} e.g. \"Person/CompanyDetails/Role\". They must be from the \"Person\" or \"LegalEntity\" domain.             Only identifier types stated will be used to look up relevant entities in relations. If not applicable, provide an empty array.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_portfolio_group_relations_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve relations. 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 relations. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the relations. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifiers types (as property keys) used for referencing Persons or Legal Entities. These take the format              {domain}/{scope}/{code} e.g. \"Person/CompanyDetails/Role\". They must be from the \"Person\" or \"LegalEntity\" domain.              Only identifier types stated will be used to look up relevant entities in relations. If not applicable, provide an empty array.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] GetPortfolioGroupRelations: Get Relations for Portfolio Group  # noqa: E501
 
         Get relations for the specified Portfolio Group  # noqa: E501
@@ -3550,7 +3550,7 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the portfolio group. (required)
         :type scope: str
-        :param code: The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group. (required)
+        :param code: The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group. (required)
         :type code: str
         :param effective_at: The effective datetime or cut label at which to retrieve relations. Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
@@ -3558,7 +3558,7 @@ class PortfolioGroupsApi:
         :type as_at: datetime
         :param filter: Expression to filter the relations. Users should provide null or empty string for this field until further notice.
         :type filter: str
-        :param identifier_types: Identifiers types (as property keys) used for referencing Persons or Legal Entities. These take the format             {domain}/{scope}/{code} e.g. \"Person/CompanyDetails/Role\". They must be from the \"Person\" or \"LegalEntity\" domain.             Only identifier types stated will be used to look up relevant entities in relations. If not applicable, provide an empty array.
+        :param identifier_types: Identifiers types (as property keys) used for referencing Persons or Legal Entities. These take the format              {domain}/{scope}/{code} e.g. \"Person/CompanyDetails/Role\". They must be from the \"Person\" or \"LegalEntity\" domain.              Only identifier types stated will be used to look up relevant entities in relations. If not applicable, provide an empty array.
         :type identifier_types: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -3685,15 +3685,15 @@ class PortfolioGroupsApi:
 
 
     @overload
-    async def get_portfolio_group_relationships(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve relationship. 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 relationships. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter relationships. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifier types (as property keys) used for referencing Persons or Legal Entities.             These can be specified from the 'Person' or 'LegalEntity' domains and have the format {domain}/{scope}/{code}, for example             'Person/CompanyDetails/Role'. An Empty array may be used to return all related Entities.")] = None, **kwargs) -> ResourceListOfRelationship:  # noqa: E501
+    async def get_portfolio_group_relationships(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve relationship. 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 relationships. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter relationships. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifier types (as property keys) used for referencing Persons or Legal Entities.              These can be specified from the 'Person' or 'LegalEntity' domains and have the format {domain}/{scope}/{code}, for example              'Person/CompanyDetails/Role'. An Empty array may be used to return all related Entities.")] = None, **kwargs) -> ResourceListOfRelationship:  # noqa: E501
         ...
 
     @overload
-    def get_portfolio_group_relationships(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve relationship. 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 relationships. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter relationships. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifier types (as property keys) used for referencing Persons or Legal Entities.             These can be specified from the 'Person' or 'LegalEntity' domains and have the format {domain}/{scope}/{code}, for example             'Person/CompanyDetails/Role'. An Empty array may be used to return all related Entities.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfRelationship:  # noqa: E501
+    def get_portfolio_group_relationships(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve relationship. 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 relationships. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter relationships. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifier types (as property keys) used for referencing Persons or Legal Entities.              These can be specified from the 'Person' or 'LegalEntity' domains and have the format {domain}/{scope}/{code}, for example              'Person/CompanyDetails/Role'. An Empty array may be used to return all related Entities.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfRelationship:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_portfolio_group_relationships(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve relationship. 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 relationships. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter relationships. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifier types (as property keys) used for referencing Persons or Legal Entities.             These can be specified from the 'Person' or 'LegalEntity' domains and have the format {domain}/{scope}/{code}, for example             'Person/CompanyDetails/Role'. An Empty array may be used to return all related Entities.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfRelationship, Awaitable[ResourceListOfRelationship]]:  # noqa: E501
+    def get_portfolio_group_relationships(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve relationship. 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 relationships. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter relationships. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifier types (as property keys) used for referencing Persons or Legal Entities.              These can be specified from the 'Person' or 'LegalEntity' domains and have the format {domain}/{scope}/{code}, for example              'Person/CompanyDetails/Role'. An Empty array may be used to return all related Entities.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfRelationship, Awaitable[ResourceListOfRelationship]]:  # noqa: E501
         """[EARLY ACCESS] GetPortfolioGroupRelationships: Get Relationships for Portfolio Group  # noqa: E501
 
         Get relationships for the specified Portfolio Group  # noqa: E501
@@ -3705,7 +3705,7 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the portfolio group. (required)
         :type scope: str
-        :param code: The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group. (required)
+        :param code: The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group. (required)
         :type code: str
         :param effective_at: The effective datetime or cut label at which to retrieve relationship. Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
@@ -3713,7 +3713,7 @@ class PortfolioGroupsApi:
         :type as_at: datetime
         :param filter: Expression to filter relationships. Users should provide null or empty string for this field until further notice.
         :type filter: str
-        :param identifier_types: Identifier types (as property keys) used for referencing Persons or Legal Entities.             These can be specified from the 'Person' or 'LegalEntity' domains and have the format {domain}/{scope}/{code}, for example             'Person/CompanyDetails/Role'. An Empty array may be used to return all related Entities.
+        :param identifier_types: Identifier types (as property keys) used for referencing Persons or Legal Entities.              These can be specified from the 'Person' or 'LegalEntity' domains and have the format {domain}/{scope}/{code}, for example              'Person/CompanyDetails/Role'. An Empty array may be used to return all related Entities.
         :type identifier_types: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -3734,7 +3734,7 @@ class PortfolioGroupsApi:
         return self.get_portfolio_group_relationships_with_http_info(scope, code, effective_at, as_at, filter, identifier_types, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_portfolio_group_relationships_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve relationship. 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 relationships. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter relationships. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifier types (as property keys) used for referencing Persons or Legal Entities.             These can be specified from the 'Person' or 'LegalEntity' domains and have the format {domain}/{scope}/{code}, for example             'Person/CompanyDetails/Role'. An Empty array may be used to return all related Entities.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_portfolio_group_relationships_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve relationship. 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 relationships. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter relationships. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifier types (as property keys) used for referencing Persons or Legal Entities.              These can be specified from the 'Person' or 'LegalEntity' domains and have the format {domain}/{scope}/{code}, for example              'Person/CompanyDetails/Role'. An Empty array may be used to return all related Entities.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] GetPortfolioGroupRelationships: Get Relationships for Portfolio Group  # noqa: E501
 
         Get relationships for the specified Portfolio Group  # noqa: E501
@@ -3746,7 +3746,7 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the portfolio group. (required)
         :type scope: str
-        :param code: The code of the portfolio group. Together with the scope this uniquely identifies             the portfolio group. (required)
+        :param code: The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group. (required)
         :type code: str
         :param effective_at: The effective datetime or cut label at which to retrieve relationship. Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
@@ -3754,7 +3754,7 @@ class PortfolioGroupsApi:
         :type as_at: datetime
         :param filter: Expression to filter relationships. Users should provide null or empty string for this field until further notice.
         :type filter: str
-        :param identifier_types: Identifier types (as property keys) used for referencing Persons or Legal Entities.             These can be specified from the 'Person' or 'LegalEntity' domains and have the format {domain}/{scope}/{code}, for example             'Person/CompanyDetails/Role'. An Empty array may be used to return all related Entities.
+        :param identifier_types: Identifier types (as property keys) used for referencing Persons or Legal Entities.              These can be specified from the 'Person' or 'LegalEntity' domains and have the format {domain}/{scope}/{code}, for example              'Person/CompanyDetails/Role'. An Empty array may be used to return all related Entities.
         :type identifier_types: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -3881,18 +3881,18 @@ class PortfolioGroupsApi:
 
 
     @overload
-    async def get_transactions_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], from_transaction_date : Annotated[Optional[StrictStr], Field( description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the transactions.              There is no lower bound if this is not specified.")] = None, to_transaction_date : Annotated[Optional[StrictStr], Field( description="The upper bound effective datetime or cut label (inclusive) from which to retrieve transactions.              There is no upper bound if this is not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transactions. Defaults to return the latest version              of each transaction if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Transaction Type, use \"type eq 'Buy'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\", \"Transaction\", \"LegalEntity\" or \"CustodianAccount\" domain to decorate onto              the transactions. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\" or              \"Transaction/strategy/quantsignal\".")] = 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, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to GetTransactions.")] = None, show_cancelled_transactions : Annotated[Optional[StrictBool], Field(description="Option to specify whether or not to include cancelled transactions,              including previous versions of transactions which have since been amended.              Defaults to False if not specified.")] = 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, **kwargs) -> VersionedResourceListOfTransaction:  # noqa: E501
+    async def get_transactions_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies               the portfolio group.")], from_transaction_date : Annotated[Optional[StrictStr], Field( description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the transactions.               There is no lower bound if this is not specified.")] = None, to_transaction_date : Annotated[Optional[StrictStr], Field( description="The upper bound effective datetime or cut label (inclusive) from which to retrieve transactions.               There is no upper bound if this is not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transactions. Defaults to return the latest version               of each transaction if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               For example, to filter on the Transaction Type, use \"type eq 'Buy'\"               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\", \"Transaction\", \"LegalEntity\" or \"CustodianAccount\" domain to decorate onto               the transactions. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\" or               \"Transaction/strategy/quantsignal\".")] = 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, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to GetTransactions.")] = None, show_cancelled_transactions : Annotated[Optional[StrictBool], Field(description="Option to specify whether or not to include cancelled transactions,               including previous versions of transactions which have since been amended.               Defaults to False if not specified.")] = 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, **kwargs) -> VersionedResourceListOfTransaction:  # noqa: E501
         ...
 
     @overload
-    def get_transactions_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], from_transaction_date : Annotated[Optional[StrictStr], Field( description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the transactions.              There is no lower bound if this is not specified.")] = None, to_transaction_date : Annotated[Optional[StrictStr], Field( description="The upper bound effective datetime or cut label (inclusive) from which to retrieve transactions.              There is no upper bound if this is not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transactions. Defaults to return the latest version              of each transaction if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Transaction Type, use \"type eq 'Buy'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\", \"Transaction\", \"LegalEntity\" or \"CustodianAccount\" domain to decorate onto              the transactions. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\" or              \"Transaction/strategy/quantsignal\".")] = 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, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to GetTransactions.")] = None, show_cancelled_transactions : Annotated[Optional[StrictBool], Field(description="Option to specify whether or not to include cancelled transactions,              including previous versions of transactions which have since been amended.              Defaults to False if not specified.")] = 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, async_req: Optional[bool]=True, **kwargs) -> VersionedResourceListOfTransaction:  # noqa: E501
+    def get_transactions_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies               the portfolio group.")], from_transaction_date : Annotated[Optional[StrictStr], Field( description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the transactions.               There is no lower bound if this is not specified.")] = None, to_transaction_date : Annotated[Optional[StrictStr], Field( description="The upper bound effective datetime or cut label (inclusive) from which to retrieve transactions.               There is no upper bound if this is not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transactions. Defaults to return the latest version               of each transaction if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               For example, to filter on the Transaction Type, use \"type eq 'Buy'\"               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\", \"Transaction\", \"LegalEntity\" or \"CustodianAccount\" domain to decorate onto               the transactions. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\" or               \"Transaction/strategy/quantsignal\".")] = 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, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to GetTransactions.")] = None, show_cancelled_transactions : Annotated[Optional[StrictBool], Field(description="Option to specify whether or not to include cancelled transactions,               including previous versions of transactions which have since been amended.               Defaults to False if not specified.")] = 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, async_req: Optional[bool]=True, **kwargs) -> VersionedResourceListOfTransaction:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_transactions_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], from_transaction_date : Annotated[Optional[StrictStr], Field( description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the transactions.              There is no lower bound if this is not specified.")] = None, to_transaction_date : Annotated[Optional[StrictStr], Field( description="The upper bound effective datetime or cut label (inclusive) from which to retrieve transactions.              There is no upper bound if this is not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transactions. Defaults to return the latest version              of each transaction if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Transaction Type, use \"type eq 'Buy'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\", \"Transaction\", \"LegalEntity\" or \"CustodianAccount\" domain to decorate onto              the transactions. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\" or              \"Transaction/strategy/quantsignal\".")] = 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, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to GetTransactions.")] = None, show_cancelled_transactions : Annotated[Optional[StrictBool], Field(description="Option to specify whether or not to include cancelled transactions,              including previous versions of transactions which have since been amended.              Defaults to False if not specified.")] = 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, async_req: Optional[bool]=None, **kwargs) -> Union[VersionedResourceListOfTransaction, Awaitable[VersionedResourceListOfTransaction]]:  # noqa: E501
+    def get_transactions_for_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies               the portfolio group.")], from_transaction_date : Annotated[Optional[StrictStr], Field( description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the transactions.               There is no lower bound if this is not specified.")] = None, to_transaction_date : Annotated[Optional[StrictStr], Field( description="The upper bound effective datetime or cut label (inclusive) from which to retrieve transactions.               There is no upper bound if this is not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transactions. Defaults to return the latest version               of each transaction if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               For example, to filter on the Transaction Type, use \"type eq 'Buy'\"               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\", \"Transaction\", \"LegalEntity\" or \"CustodianAccount\" domain to decorate onto               the transactions. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\" or               \"Transaction/strategy/quantsignal\".")] = 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, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to GetTransactions.")] = None, show_cancelled_transactions : Annotated[Optional[StrictBool], Field(description="Option to specify whether or not to include cancelled transactions,               including previous versions of transactions which have since been amended.               Defaults to False if not specified.")] = 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, async_req: Optional[bool]=None, **kwargs) -> Union[VersionedResourceListOfTransaction, Awaitable[VersionedResourceListOfTransaction]]:  # noqa: E501
         """GetTransactionsForPortfolioGroup: Get transactions for transaction portfolios in a portfolio group  # noqa: E501
 
-        Get transactions for transaction portfolios in a portfolio group over a given interval of effective time.              When the specified portfolio in a portfolio group is a derived transaction portfolio, the returned set of transactions is the union set of all transactions of the parent (and any grandparents etc.) and the specified derived transaction portfolio itself.  # noqa: E501
+        Get transactions for transaction portfolios in a portfolio group over a given interval of effective time.                When the specified portfolio in a portfolio group is a derived transaction portfolio, the returned set of transactions is the  union set of all transactions of the parent (and any grandparents etc.) and the specified derived transaction portfolio itself.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -3901,23 +3901,23 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the portfolio group. (required)
         :type scope: str
-        :param code: The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group. (required)
+        :param code: The code of the portfolio group. Together with the scope this uniquely identifies               the portfolio group. (required)
         :type code: str
-        :param from_transaction_date: The lower bound effective datetime or cut label (inclusive) from which to retrieve the transactions.              There is no lower bound if this is not specified.
+        :param from_transaction_date: The lower bound effective datetime or cut label (inclusive) from which to retrieve the transactions.               There is no lower bound if this is not specified.
         :type from_transaction_date: str
-        :param to_transaction_date: The upper bound effective datetime or cut label (inclusive) from which to retrieve transactions.              There is no upper bound if this is not specified.
+        :param to_transaction_date: The upper bound effective datetime or cut label (inclusive) from which to retrieve transactions.               There is no upper bound if this is not specified.
         :type to_transaction_date: str
-        :param as_at: The asAt datetime at which to retrieve the transactions. Defaults to return the latest version              of each transaction if not specified.
+        :param as_at: The asAt datetime at which to retrieve the transactions. Defaults to return the latest version               of each transaction if not specified.
         :type as_at: datetime
-        :param filter: Expression to filter the result set.              For example, to filter on the Transaction Type, use \"type eq 'Buy'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
+        :param filter: Expression to filter the result set.               For example, to filter on the Transaction Type, use \"type eq 'Buy'\"               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
-        :param property_keys: A list of property keys from the \"Instrument\", \"Transaction\", \"LegalEntity\" or \"CustodianAccount\" domain to decorate onto              the transactions. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\" or              \"Transaction/strategy/quantsignal\".
+        :param property_keys: A list of property keys from the \"Instrument\", \"Transaction\", \"LegalEntity\" or \"CustodianAccount\" domain to decorate onto               the transactions. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\" or               \"Transaction/strategy/quantsignal\".
         :type property_keys: List[str]
         :param limit: When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.
         :type limit: int
         :param page: The pagination token to use to continue listing transactions from a previous call to GetTransactions.
         :type page: str
-        :param show_cancelled_transactions: Option to specify whether or not to include cancelled transactions,              including previous versions of transactions which have since been amended.              Defaults to False if not specified.
+        :param show_cancelled_transactions: Option to specify whether or not to include cancelled transactions,               including previous versions of transactions which have since been amended.               Defaults to False if not specified.
         :type show_cancelled_transactions: bool
         :param sort_by: A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".
         :type sort_by: List[str]
@@ -3940,10 +3940,10 @@ class PortfolioGroupsApi:
         return self.get_transactions_for_portfolio_group_with_http_info(scope, code, from_transaction_date, to_transaction_date, as_at, filter, property_keys, limit, page, show_cancelled_transactions, sort_by, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_transactions_for_portfolio_group_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group.")], from_transaction_date : Annotated[Optional[StrictStr], Field( description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the transactions.              There is no lower bound if this is not specified.")] = None, to_transaction_date : Annotated[Optional[StrictStr], Field( description="The upper bound effective datetime or cut label (inclusive) from which to retrieve transactions.              There is no upper bound if this is not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transactions. Defaults to return the latest version              of each transaction if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Transaction Type, use \"type eq 'Buy'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\", \"Transaction\", \"LegalEntity\" or \"CustodianAccount\" domain to decorate onto              the transactions. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\" or              \"Transaction/strategy/quantsignal\".")] = 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, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to GetTransactions.")] = None, show_cancelled_transactions : Annotated[Optional[StrictBool], Field(description="Option to specify whether or not to include cancelled transactions,              including previous versions of transactions which have since been amended.              Defaults to False if not specified.")] = 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, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_transactions_for_portfolio_group_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group. Together with the scope this uniquely identifies               the portfolio group.")], from_transaction_date : Annotated[Optional[StrictStr], Field( description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the transactions.               There is no lower bound if this is not specified.")] = None, to_transaction_date : Annotated[Optional[StrictStr], Field( description="The upper bound effective datetime or cut label (inclusive) from which to retrieve transactions.               There is no upper bound if this is not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transactions. Defaults to return the latest version               of each transaction if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               For example, to filter on the Transaction Type, use \"type eq 'Buy'\"               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Instrument\", \"Transaction\", \"LegalEntity\" or \"CustodianAccount\" domain to decorate onto               the transactions. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\" or               \"Transaction/strategy/quantsignal\".")] = 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, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing transactions from a previous call to GetTransactions.")] = None, show_cancelled_transactions : Annotated[Optional[StrictBool], Field(description="Option to specify whether or not to include cancelled transactions,               including previous versions of transactions which have since been amended.               Defaults to False if not specified.")] = 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, **kwargs) -> ApiResponse:  # noqa: E501
         """GetTransactionsForPortfolioGroup: Get transactions for transaction portfolios in a portfolio group  # noqa: E501
 
-        Get transactions for transaction portfolios in a portfolio group over a given interval of effective time.              When the specified portfolio in a portfolio group is a derived transaction portfolio, the returned set of transactions is the union set of all transactions of the parent (and any grandparents etc.) and the specified derived transaction portfolio itself.  # noqa: E501
+        Get transactions for transaction portfolios in a portfolio group over a given interval of effective time.                When the specified portfolio in a portfolio group is a derived transaction portfolio, the returned set of transactions is the  union set of all transactions of the parent (and any grandparents etc.) and the specified derived transaction portfolio itself.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -3952,23 +3952,23 @@ class PortfolioGroupsApi:
 
         :param scope: The scope of the portfolio group. (required)
         :type scope: str
-        :param code: The code of the portfolio group. Together with the scope this uniquely identifies              the portfolio group. (required)
+        :param code: The code of the portfolio group. Together with the scope this uniquely identifies               the portfolio group. (required)
         :type code: str
-        :param from_transaction_date: The lower bound effective datetime or cut label (inclusive) from which to retrieve the transactions.              There is no lower bound if this is not specified.
+        :param from_transaction_date: The lower bound effective datetime or cut label (inclusive) from which to retrieve the transactions.               There is no lower bound if this is not specified.
         :type from_transaction_date: str
-        :param to_transaction_date: The upper bound effective datetime or cut label (inclusive) from which to retrieve transactions.              There is no upper bound if this is not specified.
+        :param to_transaction_date: The upper bound effective datetime or cut label (inclusive) from which to retrieve transactions.               There is no upper bound if this is not specified.
         :type to_transaction_date: str
-        :param as_at: The asAt datetime at which to retrieve the transactions. Defaults to return the latest version              of each transaction if not specified.
+        :param as_at: The asAt datetime at which to retrieve the transactions. Defaults to return the latest version               of each transaction if not specified.
         :type as_at: datetime
-        :param filter: Expression to filter the result set.              For example, to filter on the Transaction Type, use \"type eq 'Buy'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
+        :param filter: Expression to filter the result set.               For example, to filter on the Transaction Type, use \"type eq 'Buy'\"               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
-        :param property_keys: A list of property keys from the \"Instrument\", \"Transaction\", \"LegalEntity\" or \"CustodianAccount\" domain to decorate onto              the transactions. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\" or              \"Transaction/strategy/quantsignal\".
+        :param property_keys: A list of property keys from the \"Instrument\", \"Transaction\", \"LegalEntity\" or \"CustodianAccount\" domain to decorate onto               the transactions. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\" or               \"Transaction/strategy/quantsignal\".
         :type property_keys: List[str]
         :param limit: When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.
         :type limit: int
         :param page: The pagination token to use to continue listing transactions from a previous call to GetTransactions.
         :type page: str
-        :param show_cancelled_transactions: Option to specify whether or not to include cancelled transactions,              including previous versions of transactions which have since been amended.              Defaults to False if not specified.
+        :param show_cancelled_transactions: Option to specify whether or not to include cancelled transactions,               including previous versions of transactions which have since been amended.               Defaults to False if not specified.
         :type show_cancelled_transactions: bool
         :param sort_by: A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".
         :type sort_by: List[str]
@@ -4118,15 +4118,15 @@ class PortfolioGroupsApi:
 
 
     @overload
-    async def list_portfolio_groups(self, scope : Annotated[StrictStr, Field(..., description="The scope to list the portfolio groups in.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the portfolio groups. 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 portfolio groups. Defaults to return the latest version of each portfolio group if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing portfolio groups from a previous call to list portfolio groups. This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.             For example, to filter on the Display Name, use \"displayName eq 'string'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships             to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities             onto the portfolio groups in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> PagedResourceListOfPortfolioGroup:  # noqa: E501
+    async def list_portfolio_groups(self, scope : Annotated[StrictStr, Field(..., description="The scope to list the portfolio groups in.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the portfolio groups. 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 portfolio groups. Defaults to return the latest version of each portfolio group if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing portfolio groups from a previous call to list portfolio groups. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Display Name, use \"displayName eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships              to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the portfolio groups in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> PagedResourceListOfPortfolioGroup:  # noqa: E501
         ...
 
     @overload
-    def list_portfolio_groups(self, scope : Annotated[StrictStr, Field(..., description="The scope to list the portfolio groups in.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the portfolio groups. 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 portfolio groups. Defaults to return the latest version of each portfolio group if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing portfolio groups from a previous call to list portfolio groups. This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.             For example, to filter on the Display Name, use \"displayName eq 'string'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships             to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities             onto the portfolio groups in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfPortfolioGroup:  # noqa: E501
+    def list_portfolio_groups(self, scope : Annotated[StrictStr, Field(..., description="The scope to list the portfolio groups in.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the portfolio groups. 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 portfolio groups. Defaults to return the latest version of each portfolio group if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing portfolio groups from a previous call to list portfolio groups. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Display Name, use \"displayName eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships              to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the portfolio groups in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfPortfolioGroup:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_portfolio_groups(self, scope : Annotated[StrictStr, Field(..., description="The scope to list the portfolio groups in.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the portfolio groups. 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 portfolio groups. Defaults to return the latest version of each portfolio group if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing portfolio groups from a previous call to list portfolio groups. This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.             For example, to filter on the Display Name, use \"displayName eq 'string'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships             to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities             onto the portfolio groups in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfPortfolioGroup, Awaitable[PagedResourceListOfPortfolioGroup]]:  # noqa: E501
+    def list_portfolio_groups(self, scope : Annotated[StrictStr, Field(..., description="The scope to list the portfolio groups in.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the portfolio groups. 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 portfolio groups. Defaults to return the latest version of each portfolio group if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing portfolio groups from a previous call to list portfolio groups. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Display Name, use \"displayName eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships              to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the portfolio groups in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfPortfolioGroup, Awaitable[PagedResourceListOfPortfolioGroup]]:  # noqa: E501
         """ListPortfolioGroups: List portfolio groups  # noqa: E501
 
         List all the portfolio groups in a single scope.  # noqa: E501
@@ -4142,17 +4142,17 @@ class PortfolioGroupsApi:
         :type effective_at: str
         :param as_at: The asAt datetime at which to list the portfolio groups. Defaults to return the latest version of each portfolio group if not specified.
         :type as_at: datetime
-        :param page: The pagination token to use to continue listing portfolio groups from a previous call to list portfolio groups. This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy and asAt fields must not have changed since the original request.
+        :param page: The pagination token to use to continue listing portfolio groups from a previous call to list portfolio groups. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.
         :type page: str
         :param limit: When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.
         :type limit: int
-        :param filter: Expression to filter the result set.             For example, to filter on the Display Name, use \"displayName eq 'string'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
+        :param filter: Expression to filter the result set.              For example, to filter on the Display Name, use \"displayName eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
         :param sort_by: A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"
         :type sort_by: List[str]
-        :param related_entity_property_keys: A list of property keys from any domain that supports relationships             to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.
+        :param related_entity_property_keys: A list of property keys from any domain that supports relationships              to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.
         :type related_entity_property_keys: List[str]
-        :param relationship_definition_ids: A list of relationship definitions that are used to decorate related entities             onto the portfolio groups in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.
+        :param relationship_definition_ids: A list of relationship definitions that are used to decorate related entities              onto the portfolio groups in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.
         :type relationship_definition_ids: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -4173,7 +4173,7 @@ class PortfolioGroupsApi:
         return self.list_portfolio_groups_with_http_info(scope, effective_at, as_at, page, limit, filter, sort_by, related_entity_property_keys, relationship_definition_ids, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_portfolio_groups_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope to list the portfolio groups in.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the portfolio groups. 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 portfolio groups. Defaults to return the latest version of each portfolio group if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing portfolio groups from a previous call to list portfolio groups. This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.             For example, to filter on the Display Name, use \"displayName eq 'string'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships             to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities             onto the portfolio groups in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_portfolio_groups_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope to list the portfolio groups in.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the portfolio groups. 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 portfolio groups. Defaults to return the latest version of each portfolio group if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing portfolio groups from a previous call to list portfolio groups. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Display Name, use \"displayName eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships              to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the portfolio groups in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """ListPortfolioGroups: List portfolio groups  # noqa: E501
 
         List all the portfolio groups in a single scope.  # noqa: E501
@@ -4189,17 +4189,17 @@ class PortfolioGroupsApi:
         :type effective_at: str
         :param as_at: The asAt datetime at which to list the portfolio groups. Defaults to return the latest version of each portfolio group if not specified.
         :type as_at: datetime
-        :param page: The pagination token to use to continue listing portfolio groups from a previous call to list portfolio groups. This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy and asAt fields must not have changed since the original request.
+        :param page: The pagination token to use to continue listing portfolio groups from a previous call to list portfolio groups. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.
         :type page: str
         :param limit: When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.
         :type limit: int
-        :param filter: Expression to filter the result set.             For example, to filter on the Display Name, use \"displayName eq 'string'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
+        :param filter: Expression to filter the result set.              For example, to filter on the Display Name, use \"displayName eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
         :param sort_by: A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"
         :type sort_by: List[str]
-        :param related_entity_property_keys: A list of property keys from any domain that supports relationships             to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.
+        :param related_entity_property_keys: A list of property keys from any domain that supports relationships              to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.
         :type related_entity_property_keys: List[str]
-        :param relationship_definition_ids: A list of relationship definitions that are used to decorate related entities             onto the portfolio groups in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.
+        :param relationship_definition_ids: A list of relationship definitions that are used to decorate related entities              onto the portfolio groups in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.
         :type relationship_definition_ids: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -4351,7 +4351,7 @@ class PortfolioGroupsApi:
     def patch_portfolio_group_access_metadata(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Portfolio Group")], code : Annotated[StrictStr, Field(..., description="The Portfolio Group code")], access_metadata_operation : Annotated[conlist(AccessMetadataOperation), Field(..., description="The Json patch document")], effective_at : Annotated[Optional[StrictStr], Field( description="The date this rule will be 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[Dict[str, List[AccessMetadataValue]], Awaitable[Dict[str, List[AccessMetadataValue]]]]:  # noqa: E501
         """[EARLY ACCESS] PatchPortfolioGroupAccessMetadata: Patch Access Metadata rules for a Portfolio Group.  # noqa: E501
 
-        Patch Portfolio Group Access Metadata Rules in a single scope. The behaviour is defined by the JSON Patch specification.              Currently only 'add' is a supported operation on the patch document.  Currently only valid metadata keys are supported paths on the patch document.              The response will return any affected Portfolio Group Access Metadata rules or a 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
+        Patch Portfolio Group Access Metadata Rules in a single scope.  The behaviour is defined by the JSON Patch specification.                Currently only 'add' is a supported operation on the patch document.    Currently only valid metadata keys are supported paths on the patch document.                The response will return any affected Portfolio Group Access Metadata rules or a 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
         asynchronous HTTP request, please pass async_req=True
 
@@ -4390,7 +4390,7 @@ class PortfolioGroupsApi:
     def patch_portfolio_group_access_metadata_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Portfolio Group")], code : Annotated[StrictStr, Field(..., description="The Portfolio Group code")], access_metadata_operation : Annotated[conlist(AccessMetadataOperation), Field(..., description="The Json patch document")], effective_at : Annotated[Optional[StrictStr], Field( description="The date this rule will be 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] PatchPortfolioGroupAccessMetadata: Patch Access Metadata rules for a Portfolio Group.  # noqa: E501
 
-        Patch Portfolio Group Access Metadata Rules in a single scope. The behaviour is defined by the JSON Patch specification.              Currently only 'add' is a supported operation on the patch document.  Currently only valid metadata keys are supported paths on the patch document.              The response will return any affected Portfolio Group Access Metadata rules or a 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
+        Patch Portfolio Group Access Metadata Rules in a single scope.  The behaviour is defined by the JSON Patch specification.                Currently only 'add' is a supported operation on the patch document.    Currently only valid metadata keys are supported paths on the patch document.                The response will return any affected Portfolio Group Access Metadata rules or a 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
         asynchronous HTTP request, please pass async_req=True
 
@@ -4545,7 +4545,7 @@ class PortfolioGroupsApi:
     def update_portfolio_group(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to update the definition for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to update the definition for. Together with the scope this uniquely identifies the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to update the definition.")] = None, update_portfolio_group_request : Annotated[Optional[UpdatePortfolioGroupRequest], Field(description="The updated portfolio group definition.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PortfolioGroup, Awaitable[PortfolioGroup]]:  # noqa: E501
         """[EARLY ACCESS] UpdatePortfolioGroup: Update portfolio group  # noqa: E501
 
-        Update the definition of a single portfolio group. Not all elements within a portfolio group definition are modifiable due to the potential implications for data already stored against the portfolio group.  # noqa: E501
+        Update the definition of a single portfolio group. Not all elements within a portfolio group definition are modifiable  due to the potential implications for data already stored against the portfolio group.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -4582,7 +4582,7 @@ class PortfolioGroupsApi:
     def update_portfolio_group_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the portfolio group to update the definition for.")], code : Annotated[StrictStr, Field(..., description="The code of the portfolio group to update the definition for. Together with the scope this uniquely identifies the portfolio group.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to update the definition.")] = None, update_portfolio_group_request : Annotated[Optional[UpdatePortfolioGroupRequest], Field(description="The updated portfolio group definition.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] UpdatePortfolioGroup: Update portfolio group  # noqa: E501
 
-        Update the definition of a single portfolio group. Not all elements within a portfolio group definition are modifiable due to the potential implications for data already stored against the portfolio group.  # noqa: E501
+        Update the definition of a single portfolio group. Not all elements within a portfolio group definition are modifiable  due to the potential implications for data already stored against the portfolio group.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -4717,18 +4717,18 @@ class PortfolioGroupsApi:
 
 
     @overload
-    async def upsert_group_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to update or insert the properties onto.")], code : Annotated[StrictStr, Field(..., description="The code of the group to update or insert the properties onto. Together with the scope this uniquely identifies the group.")], request_body : Annotated[Optional[Dict[str, ModelProperty]], Field(description="The properties to be updated or inserted onto the group. Each property in              the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".")] = None, **kwargs) -> PortfolioGroupProperties:  # noqa: E501
+    async def upsert_group_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to update or insert the properties onto.")], code : Annotated[StrictStr, Field(..., description="The code of the group to update or insert the properties onto. Together with the scope this uniquely identifies the group.")], request_body : Annotated[Optional[Dict[str, ModelProperty]], Field(description="The properties to be updated or inserted onto the group. Each property in               the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".")] = None, **kwargs) -> PortfolioGroupProperties:  # noqa: E501
         ...
 
     @overload
-    def upsert_group_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to update or insert the properties onto.")], code : Annotated[StrictStr, Field(..., description="The code of the group to update or insert the properties onto. Together with the scope this uniquely identifies the group.")], request_body : Annotated[Optional[Dict[str, ModelProperty]], Field(description="The properties to be updated or inserted onto the group. Each property in              the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".")] = None, async_req: Optional[bool]=True, **kwargs) -> PortfolioGroupProperties:  # noqa: E501
+    def upsert_group_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to update or insert the properties onto.")], code : Annotated[StrictStr, Field(..., description="The code of the group to update or insert the properties onto. Together with the scope this uniquely identifies the group.")], request_body : Annotated[Optional[Dict[str, ModelProperty]], Field(description="The properties to be updated or inserted onto the group. Each property in               the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".")] = None, async_req: Optional[bool]=True, **kwargs) -> PortfolioGroupProperties:  # noqa: E501
         ...
 
     @validate_arguments
-    def upsert_group_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to update or insert the properties onto.")], code : Annotated[StrictStr, Field(..., description="The code of the group to update or insert the properties onto. Together with the scope this uniquely identifies the group.")], request_body : Annotated[Optional[Dict[str, ModelProperty]], Field(description="The properties to be updated or inserted onto the group. Each property in              the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PortfolioGroupProperties, Awaitable[PortfolioGroupProperties]]:  # noqa: E501
+    def upsert_group_properties(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to update or insert the properties onto.")], code : Annotated[StrictStr, Field(..., description="The code of the group to update or insert the properties onto. Together with the scope this uniquely identifies the group.")], request_body : Annotated[Optional[Dict[str, ModelProperty]], Field(description="The properties to be updated or inserted onto the group. Each property in               the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PortfolioGroupProperties, Awaitable[PortfolioGroupProperties]]:  # noqa: E501
         """[EARLY ACCESS] UpsertGroupProperties: Upsert group properties  # noqa: E501
 
-        Update or insert one or more properties onto a single group. A property will be updated if it already exists and inserted if it does not. All properties must be of the domain 'PortfolioGroup'.              Upserting a property that exists for a group, 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
+        Update or insert one or more properties onto a single group. A property will be updated if it  already exists and inserted if it does not. All properties must be of the domain 'PortfolioGroup'.                Upserting a property that exists for a group, 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
         asynchronous HTTP request, please pass async_req=True
 
@@ -4739,7 +4739,7 @@ class PortfolioGroupsApi:
         :type scope: str
         :param code: The code of the group to update or insert the properties onto. Together with the scope this uniquely identifies the group. (required)
         :type code: str
-        :param request_body: The properties to be updated or inserted onto the group. Each property in              the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".
+        :param request_body: The properties to be updated or inserted onto the group. Each property in               the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".
         :type request_body: Dict[str, ModelProperty]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -4760,10 +4760,10 @@ class PortfolioGroupsApi:
         return self.upsert_group_properties_with_http_info(scope, code, request_body, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def upsert_group_properties_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to update or insert the properties onto.")], code : Annotated[StrictStr, Field(..., description="The code of the group to update or insert the properties onto. Together with the scope this uniquely identifies the group.")], request_body : Annotated[Optional[Dict[str, ModelProperty]], Field(description="The properties to be updated or inserted onto the group. Each property in              the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def upsert_group_properties_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the group to update or insert the properties onto.")], code : Annotated[StrictStr, Field(..., description="The code of the group to update or insert the properties onto. Together with the scope this uniquely identifies the group.")], request_body : Annotated[Optional[Dict[str, ModelProperty]], Field(description="The properties to be updated or inserted onto the group. Each property in               the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] UpsertGroupProperties: Upsert group properties  # noqa: E501
 
-        Update or insert one or more properties onto a single group. A property will be updated if it already exists and inserted if it does not. All properties must be of the domain 'PortfolioGroup'.              Upserting a property that exists for a group, 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
+        Update or insert one or more properties onto a single group. A property will be updated if it  already exists and inserted if it does not. All properties must be of the domain 'PortfolioGroup'.                Upserting a property that exists for a group, 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
         asynchronous HTTP request, please pass async_req=True
 
@@ -4774,7 +4774,7 @@ class PortfolioGroupsApi:
         :type scope: str
         :param code: The code of the group to update or insert the properties onto. Together with the scope this uniquely identifies the group. (required)
         :type code: str
-        :param request_body: The properties to be updated or inserted onto the group. Each property in              the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".
+        :param request_body: The properties to be updated or inserted onto the group. Each property in               the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code} e.g. \"PortfolioGroup/Manager/Id\".
         :type request_body: Dict[str, ModelProperty]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -4903,7 +4903,7 @@ class PortfolioGroupsApi:
     def upsert_portfolio_group_access_metadata(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Portfolio Group")], code : Annotated[StrictStr, Field(..., description="The Portfolio Group code")], metadata_key : Annotated[StrictStr, Field(..., description="Key of the access metadata entry to upsert")], upsert_portfolio_group_access_metadata_request : Annotated[UpsertPortfolioGroupAccessMetadataRequest, Field(..., description="The Portfolio Group Access Metadata rule to upsert")], effective_at : Annotated[Optional[StrictStr], Field( description="The date this rule will be 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
         """UpsertPortfolioGroupAccessMetadata: Upsert a Portfolio Group Access Metadata entry associated with a specific metadataKey. This creates or updates the data in LUSID.  # noqa: E501
 
-        Update or insert one Portfolio Group 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 Portfolio Group 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
+        Update or insert one Portfolio Group 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 Portfolio Group 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
         asynchronous HTTP request, please pass async_req=True
 
@@ -4944,7 +4944,7 @@ class PortfolioGroupsApi:
     def upsert_portfolio_group_access_metadata_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Portfolio Group")], code : Annotated[StrictStr, Field(..., description="The Portfolio Group code")], metadata_key : Annotated[StrictStr, Field(..., description="Key of the access metadata entry to upsert")], upsert_portfolio_group_access_metadata_request : Annotated[UpsertPortfolioGroupAccessMetadataRequest, Field(..., description="The Portfolio Group Access Metadata rule to upsert")], effective_at : Annotated[Optional[StrictStr], Field( description="The date this rule will be 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
         """UpsertPortfolioGroupAccessMetadata: Upsert a Portfolio Group Access Metadata entry associated with a specific metadataKey. This creates or updates the data in LUSID.  # noqa: E501
 
-        Update or insert one Portfolio Group 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 Portfolio Group 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
+        Update or insert one Portfolio Group 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 Portfolio Group 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
         asynchronous HTTP request, please pass async_req=True