lusid-sdk 2.1.910__py3-none-any.whl → 2.1.912__py3-none-any.whl

lusid/api/transaction_configuration_api.py

@@ -233,7 +233,7 @@ class TransactionConfigurationApi:
     def delete_transaction_type(self, source : Annotated[StrictStr, Field(..., description="The source that the type is in")], type : Annotated[StrictStr, Field(..., description="One of the type's aliases")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
         """DeleteTransactionType: Delete a transaction type  # noqa: E501
 
-        /// WARNING! Changing existing transaction types has a material impact on how data, new and old,  is processed and aggregated by LUSID, and will affect your whole organisation. Only call this API if you are fully aware of the implications of the change.  # noqa: E501
+        /// WARNING! Changing existing transaction types has a material impact on how data, new and old, is processed and aggregated by LUSID, and will affect your whole organisation. Only call this API if you are fully aware of the implications of the change.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -268,7 +268,7 @@ class TransactionConfigurationApi:
     def delete_transaction_type_with_http_info(self, source : Annotated[StrictStr, Field(..., description="The source that the type is in")], type : Annotated[StrictStr, Field(..., description="One of the type's aliases")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """DeleteTransactionType: Delete a transaction type  # noqa: E501
 
-        /// WARNING! Changing existing transaction types has a material impact on how data, new and old,  is processed and aggregated by LUSID, and will affect your whole organisation. Only call this API if you are fully aware of the implications of the change.  # noqa: E501
+        /// WARNING! Changing existing transaction types has a material impact on how data, new and old, is processed and aggregated by LUSID, and will affect your whole organisation. Only call this API if you are fully aware of the implications of the change.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -721,15 +721,15 @@ class TransactionConfigurationApi:
 
 
     @overload
-    async def get_transaction_type(self, source : Annotated[StrictStr, Field(..., description="The source that the type is in")], type : Annotated[StrictStr, Field(..., description="One of the type's aliases")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction configuration.              Defaults to returning the latest version of the transaction configuration type if not specified")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> TransactionType:  # noqa: E501
+    async def get_transaction_type(self, source : Annotated[StrictStr, Field(..., description="The source that the type is in")], type : Annotated[StrictStr, Field(..., description="One of the type's aliases")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction configuration.             Defaults to returning the latest version of the transaction configuration type if not specified")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> TransactionType:  # noqa: E501
         ...
 
     @overload
-    def get_transaction_type(self, source : Annotated[StrictStr, Field(..., description="The source that the type is in")], type : Annotated[StrictStr, Field(..., description="One of the type's aliases")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction configuration.              Defaults to returning the latest version of the transaction configuration type if not specified")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=True, **kwargs) -> TransactionType:  # noqa: E501
+    def get_transaction_type(self, source : Annotated[StrictStr, Field(..., description="The source that the type is in")], type : Annotated[StrictStr, Field(..., description="One of the type's aliases")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction configuration.             Defaults to returning the latest version of the transaction configuration type if not specified")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=True, **kwargs) -> TransactionType:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_transaction_type(self, source : Annotated[StrictStr, Field(..., description="The source that the type is in")], type : Annotated[StrictStr, Field(..., description="One of the type's aliases")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction configuration.              Defaults to returning the latest version of the transaction configuration type if not specified")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[TransactionType, Awaitable[TransactionType]]:  # noqa: E501
+    def get_transaction_type(self, source : Annotated[StrictStr, Field(..., description="The source that the type is in")], type : Annotated[StrictStr, Field(..., description="One of the type's aliases")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction configuration.             Defaults to returning the latest version of the transaction configuration type if not specified")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[TransactionType, Awaitable[TransactionType]]:  # noqa: E501
         """GetTransactionType: Get a single transaction configuration type  # noqa: E501
 
         Get a single transaction type. Returns failure if not found  # noqa: E501
@@ -743,7 +743,7 @@ class TransactionConfigurationApi:
         :type source: str
         :param type: One of the type's aliases (required)
         :type type: str
-        :param as_at: The asAt datetime at which to retrieve the transaction configuration.              Defaults to returning the latest version of the transaction configuration type if not specified
+        :param as_at: The asAt datetime at which to retrieve the transaction configuration.             Defaults to returning the latest version of the transaction configuration type if not specified
         :type as_at: datetime
         :param scope: The scope in which the transaction types exists. When not supplied the scope is 'default'.
         :type scope: str
@@ -766,7 +766,7 @@ class TransactionConfigurationApi:
         return self.get_transaction_type_with_http_info(source, type, as_at, scope, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_transaction_type_with_http_info(self, source : Annotated[StrictStr, Field(..., description="The source that the type is in")], type : Annotated[StrictStr, Field(..., description="One of the type's aliases")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction configuration.              Defaults to returning the latest version of the transaction configuration type if not specified")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_transaction_type_with_http_info(self, source : Annotated[StrictStr, Field(..., description="The source that the type is in")], type : Annotated[StrictStr, Field(..., description="One of the type's aliases")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction configuration.             Defaults to returning the latest version of the transaction configuration type if not specified")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """GetTransactionType: Get a single transaction configuration type  # noqa: E501
 
         Get a single transaction type. Returns failure if not found  # noqa: E501
@@ -780,7 +780,7 @@ class TransactionConfigurationApi:
         :type source: str
         :param type: One of the type's aliases (required)
         :type type: str
-        :param as_at: The asAt datetime at which to retrieve the transaction configuration.              Defaults to returning the latest version of the transaction configuration type if not specified
+        :param as_at: The asAt datetime at which to retrieve the transaction configuration.             Defaults to returning the latest version of the transaction configuration type if not specified
         :type as_at: datetime
         :param scope: The scope in which the transaction types exists. When not supplied the scope is 'default'.
         :type scope: str
@@ -1063,25 +1063,25 @@ class TransactionConfigurationApi:
 
 
     @overload
-    async def list_transaction_types(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction types. Defaults              to returning the latest versions if not specified.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> Dict[str, List[TransactionType]]:  # noqa: E501
+    async def list_transaction_types(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction types. Defaults             to returning the latest versions if not specified.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> Dict[str, List[TransactionType]]:  # noqa: E501
         ...
 
     @overload
-    def list_transaction_types(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction types. Defaults              to returning the latest versions if not specified.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=True, **kwargs) -> Dict[str, List[TransactionType]]:  # noqa: E501
+    def list_transaction_types(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction types. Defaults             to returning the latest versions if not specified.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=True, **kwargs) -> Dict[str, List[TransactionType]]:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_transaction_types(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction types. Defaults              to returning the latest versions if not specified.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Dict[str, List[TransactionType]], Awaitable[Dict[str, List[TransactionType]]]]:  # noqa: E501
+    def list_transaction_types(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction types. Defaults             to returning the latest versions if not specified.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Dict[str, List[TransactionType]], Awaitable[Dict[str, List[TransactionType]]]]:  # noqa: E501
         """ListTransactionTypes: List transaction types  # noqa: E501
 
-        Get the list of current transaction types. For information on the default transaction types provided with  LUSID, see https://support.lusid.com/knowledgebase/article/KA-01873/.  # noqa: E501
+        Get the list of current transaction types. For information on the default transaction types provided with LUSID, see https://support.lusid.com/knowledgebase/article/KA-01873/.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
         >>> thread = api.list_transaction_types(as_at, scope, async_req=True)
         >>> result = thread.get()
 
-        :param as_at: The asAt datetime at which to retrieve the transaction types. Defaults              to returning the latest versions if not specified.
+        :param as_at: The asAt datetime at which to retrieve the transaction types. Defaults             to returning the latest versions if not specified.
         :type as_at: datetime
         :param scope: The scope in which the side exists. When not supplied the scope is 'default'.
         :type scope: str
@@ -1104,17 +1104,17 @@ class TransactionConfigurationApi:
         return self.list_transaction_types_with_http_info(as_at, scope, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_transaction_types_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction types. Defaults              to returning the latest versions if not specified.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_transaction_types_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction types. Defaults             to returning the latest versions if not specified.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """ListTransactionTypes: List transaction types  # noqa: E501
 
-        Get the list of current transaction types. For information on the default transaction types provided with  LUSID, see https://support.lusid.com/knowledgebase/article/KA-01873/.  # noqa: E501
+        Get the list of current transaction types. For information on the default transaction types provided with LUSID, see https://support.lusid.com/knowledgebase/article/KA-01873/.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
         >>> thread = api.list_transaction_types_with_http_info(as_at, scope, async_req=True)
         >>> result = thread.get()
 
-        :param as_at: The asAt datetime at which to retrieve the transaction types. Defaults              to returning the latest versions if not specified.
+        :param as_at: The asAt datetime at which to retrieve the transaction types. Defaults             to returning the latest versions if not specified.
         :type as_at: datetime
         :param scope: The scope in which the side exists. When not supplied the scope is 'default'.
         :type scope: str
@@ -1579,7 +1579,7 @@ class TransactionConfigurationApi:
     def set_transaction_type(self, source : Annotated[StrictStr, Field(..., description="The source to set the transaction configuration for")], type : Annotated[StrictStr, Field(..., description="One of the transaction configuration alias types to uniquely identify the configuration. If this type does not exist, then a new transaction type is created using the body of the request in the given source, without including this type")], transaction_type_request : Annotated[TransactionTypeRequest, Field(..., description="The transaction configuration to set")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[TransactionType, Awaitable[TransactionType]]:  # noqa: E501
         """SetTransactionType: Set a specific transaction type  # noqa: E501
 
-        Set a transaction type for the given source and type. If the requested transaction type does not exist, it will be created    WARNING! Changing existing transaction types has a material impact on how data, new and old, is processed and aggregated by LUSID, and will affect your whole organisation. Only call this API if you are fully aware of the implications of the change.  # noqa: E501
+        Set a transaction type for the given source and type. If the requested transaction type does not exist, it will be created  WARNING! Changing existing transaction types has a material impact on how data, new and old, is processed and aggregated by LUSID, and will affect your whole organisation. Only call this API if you are fully aware of the implications of the change.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -1616,7 +1616,7 @@ class TransactionConfigurationApi:
     def set_transaction_type_with_http_info(self, source : Annotated[StrictStr, Field(..., description="The source to set the transaction configuration for")], type : Annotated[StrictStr, Field(..., description="One of the transaction configuration alias types to uniquely identify the configuration. If this type does not exist, then a new transaction type is created using the body of the request in the given source, without including this type")], transaction_type_request : Annotated[TransactionTypeRequest, Field(..., description="The transaction configuration to set")], scope : Annotated[Optional[StrictStr], Field( description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """SetTransactionType: Set a specific transaction type  # noqa: E501
 
-        Set a transaction type for the given source and type. If the requested transaction type does not exist, it will be created    WARNING! Changing existing transaction types has a material impact on how data, new and old, is processed and aggregated by LUSID, and will affect your whole organisation. Only call this API if you are fully aware of the implications of the change.  # noqa: E501
+        Set a transaction type for the given source and type. If the requested transaction type does not exist, it will be created  WARNING! Changing existing transaction types has a material impact on how data, new and old, is processed and aggregated by LUSID, and will affect your whole organisation. Only call this API if you are fully aware of the implications of the change.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 

lusid/api/transaction_fees_api.py

@@ -70,7 +70,7 @@ class TransactionFeesApi:
     def delete_transaction_fee_rule(self, code : Annotated[StrictStr, Field(..., description="The fee rule code.")], async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
         """DeleteTransactionFeeRule: Deletes a fee rule.  # noqa: E501
 
-        Deletes the rule for all effective time.    The rule will remain viewable at previous as at times, but it will no longer be considered by  GetApplicableFees.    This cannot be undone.  # noqa: E501
+        Deletes the rule for all effective time.  The rule will remain viewable at previous as at times, but it will no longer be considered by GetApplicableFees.  This cannot be undone.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -101,7 +101,7 @@ class TransactionFeesApi:
     def delete_transaction_fee_rule_with_http_info(self, code : Annotated[StrictStr, Field(..., description="The fee rule code.")], **kwargs) -> ApiResponse:  # noqa: E501
         """DeleteTransactionFeeRule: Deletes a fee rule.  # noqa: E501
 
-        Deletes the rule for all effective time.    The rule will remain viewable at previous as at times, but it will no longer be considered by  GetApplicableFees.    This cannot be undone.  # noqa: E501
+        Deletes the rule for all effective time.  The rule will remain viewable at previous as at times, but it will no longer be considered by GetApplicableFees.  This cannot be undone.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -211,15 +211,15 @@ class TransactionFeesApi:
 
 
     @overload
-    async def get_applicable_transaction_fees(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to match rule definitions. Defaults to the current LUSID  system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to match rule definitions. Defaults to returning the latest version if not  specified.")] = None, instrument_identifier_type : Annotated[Optional[StrictStr], Field( description="Optional. The unique identifier type to use, eg 'Figi' or 'LusidInstrumentId'.")] = None, instrument_identifier : Annotated[Optional[StrictStr], Field( description="Optional. The Instrument Identifier to get properties for.")] = None, portfolio_scope : Annotated[Optional[StrictStr], Field( description="Optional. The scope of the portfolio to fetch properties from.")] = None, portfolio_code : Annotated[Optional[StrictStr], Field( description="Optional. The code of the portfolio to fetch properties from.")] = None, request_body : Annotated[Optional[Dict[str, StrictStr]], Field(description="Any other property keys or fields, including the top-level fields of the              fee rule (e.g. \"ExecutionBroker\" and \"SettlementCurrency\" ) and those defined in AdditionalKeys, along with              their corresponding values that should be matched for fees. Eg. \"Instrument/default/Name=exampleValue\" or              \"AdditionalKey2=Value2\".")] = None, **kwargs) -> ResourceListOfFeeRule:  # noqa: E501
+    async def get_applicable_transaction_fees(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to match rule definitions. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to match rule definitions. Defaults to returning the latest version if not specified.")] = None, instrument_identifier_type : Annotated[Optional[StrictStr], Field( description="Optional. The unique identifier type to use, eg 'Figi' or 'LusidInstrumentId'.")] = None, instrument_identifier : Annotated[Optional[StrictStr], Field( description="Optional. The Instrument Identifier to get properties for.")] = None, portfolio_scope : Annotated[Optional[StrictStr], Field( description="Optional. The scope of the portfolio to fetch properties from.")] = None, portfolio_code : Annotated[Optional[StrictStr], Field( description="Optional. The code of the portfolio to fetch properties from.")] = None, request_body : Annotated[Optional[Dict[str, StrictStr]], Field(description="Any other property keys or fields, including the top-level fields of the             fee rule (e.g. \"ExecutionBroker\" and \"SettlementCurrency\" ) and those defined in AdditionalKeys, along with             their corresponding values that should be matched for fees. Eg. \"Instrument/default/Name=exampleValue\" or             \"AdditionalKey2=Value2\".")] = None, **kwargs) -> ResourceListOfFeeRule:  # noqa: E501
         ...
 
     @overload
-    def get_applicable_transaction_fees(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to match rule definitions. Defaults to the current LUSID  system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to match rule definitions. Defaults to returning the latest version if not  specified.")] = None, instrument_identifier_type : Annotated[Optional[StrictStr], Field( description="Optional. The unique identifier type to use, eg 'Figi' or 'LusidInstrumentId'.")] = None, instrument_identifier : Annotated[Optional[StrictStr], Field( description="Optional. The Instrument Identifier to get properties for.")] = None, portfolio_scope : Annotated[Optional[StrictStr], Field( description="Optional. The scope of the portfolio to fetch properties from.")] = None, portfolio_code : Annotated[Optional[StrictStr], Field( description="Optional. The code of the portfolio to fetch properties from.")] = None, request_body : Annotated[Optional[Dict[str, StrictStr]], Field(description="Any other property keys or fields, including the top-level fields of the              fee rule (e.g. \"ExecutionBroker\" and \"SettlementCurrency\" ) and those defined in AdditionalKeys, along with              their corresponding values that should be matched for fees. Eg. \"Instrument/default/Name=exampleValue\" or              \"AdditionalKey2=Value2\".")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfFeeRule:  # noqa: E501
+    def get_applicable_transaction_fees(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to match rule definitions. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to match rule definitions. Defaults to returning the latest version if not specified.")] = None, instrument_identifier_type : Annotated[Optional[StrictStr], Field( description="Optional. The unique identifier type to use, eg 'Figi' or 'LusidInstrumentId'.")] = None, instrument_identifier : Annotated[Optional[StrictStr], Field( description="Optional. The Instrument Identifier to get properties for.")] = None, portfolio_scope : Annotated[Optional[StrictStr], Field( description="Optional. The scope of the portfolio to fetch properties from.")] = None, portfolio_code : Annotated[Optional[StrictStr], Field( description="Optional. The code of the portfolio to fetch properties from.")] = None, request_body : Annotated[Optional[Dict[str, StrictStr]], Field(description="Any other property keys or fields, including the top-level fields of the             fee rule (e.g. \"ExecutionBroker\" and \"SettlementCurrency\" ) and those defined in AdditionalKeys, along with             their corresponding values that should be matched for fees. Eg. \"Instrument/default/Name=exampleValue\" or             \"AdditionalKey2=Value2\".")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfFeeRule:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_applicable_transaction_fees(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to match rule definitions. Defaults to the current LUSID  system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to match rule definitions. Defaults to returning the latest version if not  specified.")] = None, instrument_identifier_type : Annotated[Optional[StrictStr], Field( description="Optional. The unique identifier type to use, eg 'Figi' or 'LusidInstrumentId'.")] = None, instrument_identifier : Annotated[Optional[StrictStr], Field( description="Optional. The Instrument Identifier to get properties for.")] = None, portfolio_scope : Annotated[Optional[StrictStr], Field( description="Optional. The scope of the portfolio to fetch properties from.")] = None, portfolio_code : Annotated[Optional[StrictStr], Field( description="Optional. The code of the portfolio to fetch properties from.")] = None, request_body : Annotated[Optional[Dict[str, StrictStr]], Field(description="Any other property keys or fields, including the top-level fields of the              fee rule (e.g. \"ExecutionBroker\" and \"SettlementCurrency\" ) and those defined in AdditionalKeys, along with              their corresponding values that should be matched for fees. Eg. \"Instrument/default/Name=exampleValue\" or              \"AdditionalKey2=Value2\".")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfFeeRule, Awaitable[ResourceListOfFeeRule]]:  # noqa: E501
+    def get_applicable_transaction_fees(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to match rule definitions. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to match rule definitions. Defaults to returning the latest version if not specified.")] = None, instrument_identifier_type : Annotated[Optional[StrictStr], Field( description="Optional. The unique identifier type to use, eg 'Figi' or 'LusidInstrumentId'.")] = None, instrument_identifier : Annotated[Optional[StrictStr], Field( description="Optional. The Instrument Identifier to get properties for.")] = None, portfolio_scope : Annotated[Optional[StrictStr], Field( description="Optional. The scope of the portfolio to fetch properties from.")] = None, portfolio_code : Annotated[Optional[StrictStr], Field( description="Optional. The code of the portfolio to fetch properties from.")] = None, request_body : Annotated[Optional[Dict[str, StrictStr]], Field(description="Any other property keys or fields, including the top-level fields of the             fee rule (e.g. \"ExecutionBroker\" and \"SettlementCurrency\" ) and those defined in AdditionalKeys, along with             their corresponding values that should be matched for fees. Eg. \"Instrument/default/Name=exampleValue\" or             \"AdditionalKey2=Value2\".")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfFeeRule, Awaitable[ResourceListOfFeeRule]]:  # noqa: E501
         """GetApplicableTransactionFees: Get the Fees and Commissions that may be applicable to a transaction.  # noqa: E501
 
         Additionally, matching can be based on the instrument's properties, its portfolio properties, and any additional property keys present in the data file.  # noqa: E501
@@ -229,9 +229,9 @@ class TransactionFeesApi:
         >>> thread = api.get_applicable_transaction_fees(effective_at, as_at, instrument_identifier_type, instrument_identifier, portfolio_scope, portfolio_code, request_body, async_req=True)
         >>> result = thread.get()
 
-        :param effective_at: The effective datetime or cut label at which to match rule definitions. Defaults to the current LUSID  system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to match rule definitions. Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
-        :param as_at: The asAt datetime at which to match rule definitions. Defaults to returning the latest version if not  specified.
+        :param as_at: The asAt datetime at which to match rule definitions. Defaults to returning the latest version if not specified.
         :type as_at: datetime
         :param instrument_identifier_type: Optional. The unique identifier type to use, eg 'Figi' or 'LusidInstrumentId'.
         :type instrument_identifier_type: str
@@ -241,7 +241,7 @@ class TransactionFeesApi:
         :type portfolio_scope: str
         :param portfolio_code: Optional. The code of the portfolio to fetch properties from.
         :type portfolio_code: str
-        :param request_body: Any other property keys or fields, including the top-level fields of the              fee rule (e.g. \"ExecutionBroker\" and \"SettlementCurrency\" ) and those defined in AdditionalKeys, along with              their corresponding values that should be matched for fees. Eg. \"Instrument/default/Name=exampleValue\" or              \"AdditionalKey2=Value2\".
+        :param request_body: Any other property keys or fields, including the top-level fields of the             fee rule (e.g. \"ExecutionBroker\" and \"SettlementCurrency\" ) and those defined in AdditionalKeys, along with             their corresponding values that should be matched for fees. Eg. \"Instrument/default/Name=exampleValue\" or             \"AdditionalKey2=Value2\".
         :type request_body: Dict[str, str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -262,7 +262,7 @@ class TransactionFeesApi:
         return self.get_applicable_transaction_fees_with_http_info(effective_at, as_at, instrument_identifier_type, instrument_identifier, portfolio_scope, portfolio_code, request_body, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_applicable_transaction_fees_with_http_info(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to match rule definitions. Defaults to the current LUSID  system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to match rule definitions. Defaults to returning the latest version if not  specified.")] = None, instrument_identifier_type : Annotated[Optional[StrictStr], Field( description="Optional. The unique identifier type to use, eg 'Figi' or 'LusidInstrumentId'.")] = None, instrument_identifier : Annotated[Optional[StrictStr], Field( description="Optional. The Instrument Identifier to get properties for.")] = None, portfolio_scope : Annotated[Optional[StrictStr], Field( description="Optional. The scope of the portfolio to fetch properties from.")] = None, portfolio_code : Annotated[Optional[StrictStr], Field( description="Optional. The code of the portfolio to fetch properties from.")] = None, request_body : Annotated[Optional[Dict[str, StrictStr]], Field(description="Any other property keys or fields, including the top-level fields of the              fee rule (e.g. \"ExecutionBroker\" and \"SettlementCurrency\" ) and those defined in AdditionalKeys, along with              their corresponding values that should be matched for fees. Eg. \"Instrument/default/Name=exampleValue\" or              \"AdditionalKey2=Value2\".")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_applicable_transaction_fees_with_http_info(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to match rule definitions. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to match rule definitions. Defaults to returning the latest version if not specified.")] = None, instrument_identifier_type : Annotated[Optional[StrictStr], Field( description="Optional. The unique identifier type to use, eg 'Figi' or 'LusidInstrumentId'.")] = None, instrument_identifier : Annotated[Optional[StrictStr], Field( description="Optional. The Instrument Identifier to get properties for.")] = None, portfolio_scope : Annotated[Optional[StrictStr], Field( description="Optional. The scope of the portfolio to fetch properties from.")] = None, portfolio_code : Annotated[Optional[StrictStr], Field( description="Optional. The code of the portfolio to fetch properties from.")] = None, request_body : Annotated[Optional[Dict[str, StrictStr]], Field(description="Any other property keys or fields, including the top-level fields of the             fee rule (e.g. \"ExecutionBroker\" and \"SettlementCurrency\" ) and those defined in AdditionalKeys, along with             their corresponding values that should be matched for fees. Eg. \"Instrument/default/Name=exampleValue\" or             \"AdditionalKey2=Value2\".")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """GetApplicableTransactionFees: Get the Fees and Commissions that may be applicable to a transaction.  # noqa: E501
 
         Additionally, matching can be based on the instrument's properties, its portfolio properties, and any additional property keys present in the data file.  # noqa: E501
@@ -272,9 +272,9 @@ class TransactionFeesApi:
         >>> thread = api.get_applicable_transaction_fees_with_http_info(effective_at, as_at, instrument_identifier_type, instrument_identifier, portfolio_scope, portfolio_code, request_body, async_req=True)
         >>> result = thread.get()
 
-        :param effective_at: The effective datetime or cut label at which to match rule definitions. Defaults to the current LUSID  system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to match rule definitions. Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
-        :param as_at: The asAt datetime at which to match rule definitions. Defaults to returning the latest version if not  specified.
+        :param as_at: The asAt datetime at which to match rule definitions. Defaults to returning the latest version if not specified.
         :type as_at: datetime
         :param instrument_identifier_type: Optional. The unique identifier type to use, eg 'Figi' or 'LusidInstrumentId'.
         :type instrument_identifier_type: str
@@ -284,7 +284,7 @@ class TransactionFeesApi:
         :type portfolio_scope: str
         :param portfolio_code: Optional. The code of the portfolio to fetch properties from.
         :type portfolio_code: str
-        :param request_body: Any other property keys or fields, including the top-level fields of the              fee rule (e.g. \"ExecutionBroker\" and \"SettlementCurrency\" ) and those defined in AdditionalKeys, along with              their corresponding values that should be matched for fees. Eg. \"Instrument/default/Name=exampleValue\" or              \"AdditionalKey2=Value2\".
+        :param request_body: Any other property keys or fields, including the top-level fields of the             fee rule (e.g. \"ExecutionBroker\" and \"SettlementCurrency\" ) and those defined in AdditionalKeys, along with             their corresponding values that should be matched for fees. Eg. \"Instrument/default/Name=exampleValue\" or             \"AdditionalKey2=Value2\".
         :type request_body: Dict[str, str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -421,15 +421,15 @@ class TransactionFeesApi:
 
 
     @overload
-    async def get_transaction_fee_rule(self, code : Annotated[StrictStr, Field(..., description="The fee rule code.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule 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 rule definition. Defaults to returning the latest version if not  specified.")] = None, **kwargs) -> FeeRule:  # noqa: E501
+    async def get_transaction_fee_rule(self, code : Annotated[StrictStr, Field(..., description="The fee rule code.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule 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 rule definition. Defaults to returning the latest version if not specified.")] = None, **kwargs) -> FeeRule:  # noqa: E501
         ...
 
     @overload
-    def get_transaction_fee_rule(self, code : Annotated[StrictStr, Field(..., description="The fee rule code.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule 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 rule definition. Defaults to returning the latest version if not  specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> FeeRule:  # noqa: E501
+    def get_transaction_fee_rule(self, code : Annotated[StrictStr, Field(..., description="The fee rule code.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule 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 rule definition. Defaults to returning the latest version if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> FeeRule:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_transaction_fee_rule(self, code : Annotated[StrictStr, Field(..., description="The fee rule code.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule 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 rule definition. Defaults to returning the latest version if not  specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[FeeRule, Awaitable[FeeRule]]:  # noqa: E501
+    def get_transaction_fee_rule(self, code : Annotated[StrictStr, Field(..., description="The fee rule code.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule 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 rule definition. Defaults to returning the latest version if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[FeeRule, Awaitable[FeeRule]]:  # noqa: E501
         """GetTransactionFeeRule: Retrieve the definition of single fee rule.  # noqa: E501
 
         Retrieves the fee rule definition at the given effective and as at times.  # noqa: E501
@@ -441,9 +441,9 @@ class TransactionFeesApi:
 
         :param code: The fee rule code. (required)
         :type code: str
-        :param effective_at: The effective datetime or cut label at which to retrieve the rule definition. Defaults to the current LUSID  system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to retrieve the rule 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 rule definition. Defaults to returning the latest version if not  specified.
+        :param as_at: The asAt datetime at which to retrieve the rule definition. Defaults to returning the latest version if not specified.
         :type as_at: datetime
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -464,7 +464,7 @@ class TransactionFeesApi:
         return self.get_transaction_fee_rule_with_http_info(code, effective_at, as_at, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_transaction_fee_rule_with_http_info(self, code : Annotated[StrictStr, Field(..., description="The fee rule code.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule 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 rule definition. Defaults to returning the latest version if not  specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_transaction_fee_rule_with_http_info(self, code : Annotated[StrictStr, Field(..., description="The fee rule code.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule 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 rule definition. Defaults to returning the latest version if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """GetTransactionFeeRule: Retrieve the definition of single fee rule.  # noqa: E501
 
         Retrieves the fee rule definition at the given effective and as at times.  # noqa: E501
@@ -476,9 +476,9 @@ class TransactionFeesApi:
 
         :param code: The fee rule code. (required)
         :type code: str
-        :param effective_at: The effective datetime or cut label at which to retrieve the rule definition. Defaults to the current LUSID  system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to retrieve the rule 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 rule definition. Defaults to returning the latest version if not  specified.
+        :param as_at: The asAt datetime at which to retrieve the rule definition. Defaults to returning the latest version if not specified.
         :type as_at: datetime
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -592,33 +592,33 @@ class TransactionFeesApi:
 
 
     @overload
-    async def list_transaction_fee_rules(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule definitions. 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 rule definitions. Defaults to returning the latest version if not  specified.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing entities; 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, **kwargs) -> ResourceListOfFeeRule:  # noqa: E501
+    async def list_transaction_fee_rules(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule definitions. 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 rule definitions. Defaults to returning the latest version if not specified.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing entities; 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, **kwargs) -> ResourceListOfFeeRule:  # noqa: E501
         ...
 
     @overload
-    def list_transaction_fee_rules(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule definitions. 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 rule definitions. Defaults to returning the latest version if not  specified.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing entities; 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, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfFeeRule:  # noqa: E501
+    def list_transaction_fee_rules(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule definitions. 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 rule definitions. Defaults to returning the latest version if not specified.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing entities; 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, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfFeeRule:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_transaction_fee_rules(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule definitions. 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 rule definitions. Defaults to returning the latest version if not  specified.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing entities; 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, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfFeeRule, Awaitable[ResourceListOfFeeRule]]:  # noqa: E501
+    def list_transaction_fee_rules(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule definitions. 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 rule definitions. Defaults to returning the latest version if not specified.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing entities; 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, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfFeeRule, Awaitable[ResourceListOfFeeRule]]:  # noqa: E501
         """ListTransactionFeeRules: List fee rules, with optional filtering.  # noqa: E501
 
-        For more information about filtering results,  see https://support.lusid.com/knowledgebase/article/KA-01914.  # noqa: E501
+        For more information about filtering results, see https://support.lusid.com/knowledgebase/article/KA-01914.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
         >>> thread = api.list_transaction_fee_rules(effective_at, as_at, limit, filter, page, async_req=True)
         >>> result = thread.get()
 
-        :param effective_at: The effective datetime or cut label at which to retrieve the rule definitions. Defaults to the current LUSID  system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to retrieve the rule definitions. 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 rule definitions. Defaults to returning the latest version if not  specified.
+        :param as_at: The asAt datetime at which to retrieve the rule definitions. Defaults to returning the latest version if not specified.
         :type as_at: datetime
         :param limit: When paginating, limit the results to this number. Defaults to 100 if not specified.
         :type limit: int
         :param filter: Expression to filter the results.
         :type filter: str
-        :param page: The pagination token to use to continue listing entities; 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 entities; 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 async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -639,25 +639,25 @@ class TransactionFeesApi:
         return self.list_transaction_fee_rules_with_http_info(effective_at, as_at, limit, filter, page, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_transaction_fee_rules_with_http_info(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule definitions. 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 rule definitions. Defaults to returning the latest version if not  specified.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing entities; 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, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_transaction_fee_rules_with_http_info(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule definitions. 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 rule definitions. Defaults to returning the latest version if not specified.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing entities; 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, **kwargs) -> ApiResponse:  # noqa: E501
         """ListTransactionFeeRules: List fee rules, with optional filtering.  # noqa: E501
 
-        For more information about filtering results,  see https://support.lusid.com/knowledgebase/article/KA-01914.  # noqa: E501
+        For more information about filtering results, see https://support.lusid.com/knowledgebase/article/KA-01914.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
         >>> thread = api.list_transaction_fee_rules_with_http_info(effective_at, as_at, limit, filter, page, async_req=True)
         >>> result = thread.get()
 
-        :param effective_at: The effective datetime or cut label at which to retrieve the rule definitions. Defaults to the current LUSID  system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to retrieve the rule definitions. 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 rule definitions. Defaults to returning the latest version if not  specified.
+        :param as_at: The asAt datetime at which to retrieve the rule definitions. Defaults to returning the latest version if not specified.
         :type as_at: datetime
         :param limit: When paginating, limit the results to this number. Defaults to 100 if not specified.
         :type limit: int
         :param filter: Expression to filter the results.
         :type filter: str
-        :param page: The pagination token to use to continue listing entities; 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 entities; 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 async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -779,27 +779,27 @@ class TransactionFeesApi:
 
 
     @overload
-    async def upsert_transaction_fee_rules(self, request_body : Annotated[Dict[str, FeeRuleUpsertRequest], Field(..., description="A dictionary of upsert request identifiers to rule upsert requests. The request              identifiers are valid for the request only and can be used to link the upserted fee rule to the code of a              created fee rule.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule will take effect. Defaults to the current LUSID  system datetime if not specified. In the case of an update, the changes will take place from this effective  time until the next effective time that the rule as been upserted at. For example, consider a rule that  already exists, and has previously had an update applied so that the definition will change on the first day  of the coming month. An upsert effective from the current day will only change the definition until the  first day of the coming month. An additional upsert at the same time (first day of the month) is required  if the newly-updated definition is to supersede the future definition.")] = None, **kwargs) -> FeeRuleUpsertResponse:  # noqa: E501
+    async def upsert_transaction_fee_rules(self, request_body : Annotated[Dict[str, FeeRuleUpsertRequest], Field(..., description="A dictionary of upsert request identifiers to rule upsert requests. The request             identifiers are valid for the request only and can be used to link the upserted fee rule to the code of a             created fee rule.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule will take effect. Defaults to the current LUSID system datetime if not specified. In the case of an update, the changes will take place from this effective time until the next effective time that the rule as been upserted at. For example, consider a rule that already exists, and has previously had an update applied so that the definition will change on the first day of the coming month. An upsert effective from the current day will only change the definition until the first day of the coming month. An additional upsert at the same time (first day of the month) is required if the newly-updated definition is to supersede the future definition.")] = None, **kwargs) -> FeeRuleUpsertResponse:  # noqa: E501
         ...
 
     @overload
-    def upsert_transaction_fee_rules(self, request_body : Annotated[Dict[str, FeeRuleUpsertRequest], Field(..., description="A dictionary of upsert request identifiers to rule upsert requests. The request              identifiers are valid for the request only and can be used to link the upserted fee rule to the code of a              created fee rule.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule will take effect. Defaults to the current LUSID  system datetime if not specified. In the case of an update, the changes will take place from this effective  time until the next effective time that the rule as been upserted at. For example, consider a rule that  already exists, and has previously had an update applied so that the definition will change on the first day  of the coming month. An upsert effective from the current day will only change the definition until the  first day of the coming month. An additional upsert at the same time (first day of the month) is required  if the newly-updated definition is to supersede the future definition.")] = None, async_req: Optional[bool]=True, **kwargs) -> FeeRuleUpsertResponse:  # noqa: E501
+    def upsert_transaction_fee_rules(self, request_body : Annotated[Dict[str, FeeRuleUpsertRequest], Field(..., description="A dictionary of upsert request identifiers to rule upsert requests. The request             identifiers are valid for the request only and can be used to link the upserted fee rule to the code of a             created fee rule.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule will take effect. Defaults to the current LUSID system datetime if not specified. In the case of an update, the changes will take place from this effective time until the next effective time that the rule as been upserted at. For example, consider a rule that already exists, and has previously had an update applied so that the definition will change on the first day of the coming month. An upsert effective from the current day will only change the definition until the first day of the coming month. An additional upsert at the same time (first day of the month) is required if the newly-updated definition is to supersede the future definition.")] = None, async_req: Optional[bool]=True, **kwargs) -> FeeRuleUpsertResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def upsert_transaction_fee_rules(self, request_body : Annotated[Dict[str, FeeRuleUpsertRequest], Field(..., description="A dictionary of upsert request identifiers to rule upsert requests. The request              identifiers are valid for the request only and can be used to link the upserted fee rule to the code of a              created fee rule.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule will take effect. Defaults to the current LUSID  system datetime if not specified. In the case of an update, the changes will take place from this effective  time until the next effective time that the rule as been upserted at. For example, consider a rule that  already exists, and has previously had an update applied so that the definition will change on the first day  of the coming month. An upsert effective from the current day will only change the definition until the  first day of the coming month. An additional upsert at the same time (first day of the month) is required  if the newly-updated definition is to supersede the future definition.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[FeeRuleUpsertResponse, Awaitable[FeeRuleUpsertResponse]]:  # noqa: E501
+    def upsert_transaction_fee_rules(self, request_body : Annotated[Dict[str, FeeRuleUpsertRequest], Field(..., description="A dictionary of upsert request identifiers to rule upsert requests. The request             identifiers are valid for the request only and can be used to link the upserted fee rule to the code of a             created fee rule.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule will take effect. Defaults to the current LUSID system datetime if not specified. In the case of an update, the changes will take place from this effective time until the next effective time that the rule as been upserted at. For example, consider a rule that already exists, and has previously had an update applied so that the definition will change on the first day of the coming month. An upsert effective from the current day will only change the definition until the first day of the coming month. An additional upsert at the same time (first day of the month) is required if the newly-updated definition is to supersede the future definition.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[FeeRuleUpsertResponse, Awaitable[FeeRuleUpsertResponse]]:  # noqa: E501
         """UpsertTransactionFeeRules: Upsert fee rules.  # noqa: E501
 
-        To upsert a new rule, the code field must be left empty, a code will then be assigned and returned as part  of the response. To update an existing rule, include the fee code. It is possible to both create and update  fee rules in the same request.    The upsert is transactional - either all create/update operations will succeed or none of them will.  # noqa: E501
+        To upsert a new rule, the code field must be left empty, a code will then be assigned and returned as part of the response. To update an existing rule, include the fee code. It is possible to both create and update fee rules in the same request.  The upsert is transactional - either all create/update operations will succeed or none of them will.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
         >>> thread = api.upsert_transaction_fee_rules(request_body, effective_at, async_req=True)
         >>> result = thread.get()
 
-        :param request_body: A dictionary of upsert request identifiers to rule upsert requests. The request              identifiers are valid for the request only and can be used to link the upserted fee rule to the code of a              created fee rule. (required)
+        :param request_body: A dictionary of upsert request identifiers to rule upsert requests. The request             identifiers are valid for the request only and can be used to link the upserted fee rule to the code of a             created fee rule. (required)
         :type request_body: Dict[str, FeeRuleUpsertRequest]
-        :param effective_at: The effective datetime or cut label at which the rule will take effect. Defaults to the current LUSID  system datetime if not specified. In the case of an update, the changes will take place from this effective  time until the next effective time that the rule as been upserted at. For example, consider a rule that  already exists, and has previously had an update applied so that the definition will change on the first day  of the coming month. An upsert effective from the current day will only change the definition until the  first day of the coming month. An additional upsert at the same time (first day of the month) is required  if the newly-updated definition is to supersede the future definition.
+        :param effective_at: The effective datetime or cut label at which the rule will take effect. Defaults to the current LUSID system datetime if not specified. In the case of an update, the changes will take place from this effective time until the next effective time that the rule as been upserted at. For example, consider a rule that already exists, and has previously had an update applied so that the definition will change on the first day of the coming month. An upsert effective from the current day will only change the definition until the first day of the coming month. An additional upsert at the same time (first day of the month) is required if the newly-updated definition is to supersede the future definition.
         :type effective_at: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -820,19 +820,19 @@ class TransactionFeesApi:
         return self.upsert_transaction_fee_rules_with_http_info(request_body, effective_at, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def upsert_transaction_fee_rules_with_http_info(self, request_body : Annotated[Dict[str, FeeRuleUpsertRequest], Field(..., description="A dictionary of upsert request identifiers to rule upsert requests. The request              identifiers are valid for the request only and can be used to link the upserted fee rule to the code of a              created fee rule.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule will take effect. Defaults to the current LUSID  system datetime if not specified. In the case of an update, the changes will take place from this effective  time until the next effective time that the rule as been upserted at. For example, consider a rule that  already exists, and has previously had an update applied so that the definition will change on the first day  of the coming month. An upsert effective from the current day will only change the definition until the  first day of the coming month. An additional upsert at the same time (first day of the month) is required  if the newly-updated definition is to supersede the future definition.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def upsert_transaction_fee_rules_with_http_info(self, request_body : Annotated[Dict[str, FeeRuleUpsertRequest], Field(..., description="A dictionary of upsert request identifiers to rule upsert requests. The request             identifiers are valid for the request only and can be used to link the upserted fee rule to the code of a             created fee rule.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which the rule will take effect. Defaults to the current LUSID system datetime if not specified. In the case of an update, the changes will take place from this effective time until the next effective time that the rule as been upserted at. For example, consider a rule that already exists, and has previously had an update applied so that the definition will change on the first day of the coming month. An upsert effective from the current day will only change the definition until the first day of the coming month. An additional upsert at the same time (first day of the month) is required if the newly-updated definition is to supersede the future definition.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """UpsertTransactionFeeRules: Upsert fee rules.  # noqa: E501
 
-        To upsert a new rule, the code field must be left empty, a code will then be assigned and returned as part  of the response. To update an existing rule, include the fee code. It is possible to both create and update  fee rules in the same request.    The upsert is transactional - either all create/update operations will succeed or none of them will.  # noqa: E501
+        To upsert a new rule, the code field must be left empty, a code will then be assigned and returned as part of the response. To update an existing rule, include the fee code. It is possible to both create and update fee rules in the same request.  The upsert is transactional - either all create/update operations will succeed or none of them will.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
         >>> thread = api.upsert_transaction_fee_rules_with_http_info(request_body, effective_at, async_req=True)
         >>> result = thread.get()
 
-        :param request_body: A dictionary of upsert request identifiers to rule upsert requests. The request              identifiers are valid for the request only and can be used to link the upserted fee rule to the code of a              created fee rule. (required)
+        :param request_body: A dictionary of upsert request identifiers to rule upsert requests. The request             identifiers are valid for the request only and can be used to link the upserted fee rule to the code of a             created fee rule. (required)
         :type request_body: Dict[str, FeeRuleUpsertRequest]
-        :param effective_at: The effective datetime or cut label at which the rule will take effect. Defaults to the current LUSID  system datetime if not specified. In the case of an update, the changes will take place from this effective  time until the next effective time that the rule as been upserted at. For example, consider a rule that  already exists, and has previously had an update applied so that the definition will change on the first day  of the coming month. An upsert effective from the current day will only change the definition until the  first day of the coming month. An additional upsert at the same time (first day of the month) is required  if the newly-updated definition is to supersede the future definition.
+        :param effective_at: The effective datetime or cut label at which the rule will take effect. Defaults to the current LUSID system datetime if not specified. In the case of an update, the changes will take place from this effective time until the next effective time that the rule as been upserted at. For example, consider a rule that already exists, and has previously had an update applied so that the definition will change on the first day of the coming month. An upsert effective from the current day will only change the definition until the first day of the coming month. An additional upsert at the same time (first day of the month) is required if the newly-updated definition is to supersede the future definition.
         :type effective_at: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional