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

lusid/__init__.py

@@ -161,6 +161,7 @@ from lusid.models.batch_adjust_holdings_response import BatchAdjustHoldingsRespo
 from lusid.models.batch_upsert_instrument_properties_response import BatchUpsertInstrumentPropertiesResponse
 from lusid.models.batch_upsert_portfolio_access_metadata_request import BatchUpsertPortfolioAccessMetadataRequest
 from lusid.models.batch_upsert_portfolio_access_metadata_response import BatchUpsertPortfolioAccessMetadataResponse
+from lusid.models.batch_upsert_portfolio_access_metadata_response_item import BatchUpsertPortfolioAccessMetadataResponseItem
 from lusid.models.batch_upsert_portfolio_transactions_response import BatchUpsertPortfolioTransactionsResponse
 from lusid.models.batch_upsert_property_definition_properties_response import BatchUpsertPropertyDefinitionPropertiesResponse
 from lusid.models.block import Block
@@ -330,6 +331,7 @@ from lusid.models.custodian_account_request import CustodianAccountRequest
 from lusid.models.custodian_accounts_upsert_response import CustodianAccountsUpsertResponse
 from lusid.models.custom_entity_definition import CustomEntityDefinition
 from lusid.models.custom_entity_definition_request import CustomEntityDefinitionRequest
+from lusid.models.custom_entity_entity import CustomEntityEntity
 from lusid.models.custom_entity_field import CustomEntityField
 from lusid.models.custom_entity_field_definition import CustomEntityFieldDefinition
 from lusid.models.custom_entity_id import CustomEntityId
@@ -600,8 +602,6 @@ from lusid.models.market_quote import MarketQuote
 from lusid.models.match_criterion import MatchCriterion
 from lusid.models.maturity_event import MaturityEvent
 from lusid.models.merger_event import MergerEvent
-from lusid.models.metadata_key_value import MetadataKeyValue
-from lusid.models.metadata_key_value_response import MetadataKeyValueResponse
 from lusid.models.metric_value import MetricValue
 from lusid.models.model_options import ModelOptions
 from lusid.models.model_options_type import ModelOptionsType
@@ -1311,6 +1311,7 @@ __all__ = [
     "BatchUpsertInstrumentPropertiesResponse",
     "BatchUpsertPortfolioAccessMetadataRequest",
     "BatchUpsertPortfolioAccessMetadataResponse",
+    "BatchUpsertPortfolioAccessMetadataResponseItem",
     "BatchUpsertPortfolioTransactionsResponse",
     "BatchUpsertPropertyDefinitionPropertiesResponse",
     "Block",
@@ -1480,6 +1481,7 @@ __all__ = [
     "CustodianAccountsUpsertResponse",
     "CustomEntityDefinition",
     "CustomEntityDefinitionRequest",
+    "CustomEntityEntity",
     "CustomEntityField",
     "CustomEntityFieldDefinition",
     "CustomEntityId",
@@ -1750,8 +1752,6 @@ __all__ = [
     "MatchCriterion",
     "MaturityEvent",
     "MergerEvent",
-    "MetadataKeyValue",
-    "MetadataKeyValueResponse",
     "MetricValue",
     "ModelOptions",
     "ModelOptionsType",

lusid/api/abor_api.py

@@ -66,30 +66,28 @@ class AborApi:
         self.api_client = api_client
 
     @overload
-    async def add_diary_entry(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Abor.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Abor.")], diary_entry_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Diary entry code")], diary_entry_request : Annotated[DiaryEntryRequest, Field(..., description="The diary entry to add.")], **kwargs) -> DiaryEntry:  # noqa: E501
+    async def add_diary_entry(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Abor.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Abor.")], diary_entry_request : Annotated[DiaryEntryRequest, Field(..., description="The diary entry to add.")], **kwargs) -> DiaryEntry:  # noqa: E501
         ...
 
     @overload
-    def add_diary_entry(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Abor.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Abor.")], diary_entry_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Diary entry code")], diary_entry_request : Annotated[DiaryEntryRequest, Field(..., description="The diary entry to add.")], async_req: Optional[bool]=True, **kwargs) -> DiaryEntry:  # noqa: E501
+    def add_diary_entry(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Abor.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Abor.")], diary_entry_request : Annotated[DiaryEntryRequest, Field(..., description="The diary entry to add.")], async_req: Optional[bool]=True, **kwargs) -> DiaryEntry:  # noqa: E501
         ...
 
     @validate_arguments
-    def add_diary_entry(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Abor.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Abor.")], diary_entry_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Diary entry code")], diary_entry_request : Annotated[DiaryEntryRequest, Field(..., description="The diary entry to add.")], async_req: Optional[bool]=None, **kwargs) -> Union[DiaryEntry, Awaitable[DiaryEntry]]:  # noqa: E501
+    def add_diary_entry(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Abor.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Abor.")], diary_entry_request : Annotated[DiaryEntryRequest, Field(..., description="The diary entry to add.")], async_req: Optional[bool]=None, **kwargs) -> Union[DiaryEntry, Awaitable[DiaryEntry]]:  # noqa: E501
         """[EXPERIMENTAL] AddDiaryEntry: Add a diary entry to the specified Abor.  # noqa: E501
 
         Adds a new diary entry to the specified Abor  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.add_diary_entry(scope, code, diary_entry_code, diary_entry_request, async_req=True)
+        >>> thread = api.add_diary_entry(scope, code, diary_entry_request, async_req=True)
         >>> result = thread.get()
 
         :param scope: The scope of the Abor. (required)
         :type scope: str
         :param code: The code of the Abor. (required)
         :type code: str
-        :param diary_entry_code: Diary entry code (required)
-        :type diary_entry_code: str
         :param diary_entry_request: The diary entry to add. (required)
         :type diary_entry_request: DiaryEntryRequest
         :param async_req: Whether to execute the request asynchronously.
@@ -109,25 +107,23 @@ class AborApi:
             raise ValueError(message)
         if async_req is not None:
             kwargs['async_req'] = async_req
-        return self.add_diary_entry_with_http_info(scope, code, diary_entry_code, diary_entry_request, **kwargs)  # noqa: E501
+        return self.add_diary_entry_with_http_info(scope, code, diary_entry_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def add_diary_entry_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Abor.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Abor.")], diary_entry_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Diary entry code")], diary_entry_request : Annotated[DiaryEntryRequest, Field(..., description="The diary entry to add.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def add_diary_entry_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Abor.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Abor.")], diary_entry_request : Annotated[DiaryEntryRequest, Field(..., description="The diary entry to add.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] AddDiaryEntry: Add a diary entry to the specified Abor.  # noqa: E501
 
         Adds a new diary entry to the specified Abor  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.add_diary_entry_with_http_info(scope, code, diary_entry_code, diary_entry_request, async_req=True)
+        >>> thread = api.add_diary_entry_with_http_info(scope, code, diary_entry_request, async_req=True)
         >>> result = thread.get()
 
         :param scope: The scope of the Abor. (required)
         :type scope: str
         :param code: The code of the Abor. (required)
         :type code: str
-        :param diary_entry_code: Diary entry code (required)
-        :type diary_entry_code: str
         :param diary_entry_request: The diary entry to add. (required)
         :type diary_entry_request: DiaryEntryRequest
         :param async_req: Whether to execute the request asynchronously.
@@ -160,7 +156,6 @@ class AborApi:
         _all_params = [
             'scope',
             'code',
-            'diary_entry_code',
             'diary_entry_request'
         ]
         _all_params.extend(
@@ -195,9 +190,6 @@ class AborApi:
         if _params['code']:
             _path_params['code'] = _params['code']
 
-        if _params['diary_entry_code']:
-            _path_params['diaryEntryCode'] = _params['diary_entry_code']
-
 
         # process the query parameters
         _query_params = []
@@ -231,7 +223,7 @@ class AborApi:
         }
 
         return self.api_client.call_api(
-            '/api/abor/{scope}/{code}/accountingdiary/{diaryEntryCode}', 'POST',
+            '/api/abor/{scope}/{code}/accountingdiary', 'POST',
             _path_params,
             _query_params,
             _header_params,

lusid/api/entities_api.py

@@ -26,6 +26,7 @@ from pydantic.v1 import Field, StrictStr, conlist, constr, validator
 
 from typing import Optional
 
+from lusid.models.custom_entity_entity import CustomEntityEntity
 from lusid.models.data_type_entity import DataTypeEntity
 from lusid.models.instrument_entity import InstrumentEntity
 from lusid.models.portfolio_entity import PortfolioEntity
@@ -52,6 +53,185 @@ class EntitiesApi:
             api_client = ApiClient.get_default()
         self.api_client = api_client
 
+    @overload
+    async def get_custom_entity_by_entity_unique_id(self, entity_unique_id : Annotated[constr(strict=True, max_length=40, min_length=30), Field(..., description="The universally unique identifier of the Custom Entity.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to retrieve the Custom Entity. 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 Custom Entity. Defaults to returning the latest version of the Custom Entity if not specified.")] = None, previews : Annotated[Optional[conlist(StrictStr)], Field(description="The ids of the staged modifications to be previewed in the response.")] = None, **kwargs) -> CustomEntityEntity:  # noqa: E501
+        ...
+
+    @overload
+    def get_custom_entity_by_entity_unique_id(self, entity_unique_id : Annotated[constr(strict=True, max_length=40, min_length=30), Field(..., description="The universally unique identifier of the Custom Entity.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to retrieve the Custom Entity. 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 Custom Entity. Defaults to returning the latest version of the Custom Entity if not specified.")] = None, previews : Annotated[Optional[conlist(StrictStr)], Field(description="The ids of the staged modifications to be previewed in the response.")] = None, async_req: Optional[bool]=True, **kwargs) -> CustomEntityEntity:  # noqa: E501
+        ...
+
+    @validate_arguments
+    def get_custom_entity_by_entity_unique_id(self, entity_unique_id : Annotated[constr(strict=True, max_length=40, min_length=30), Field(..., description="The universally unique identifier of the Custom Entity.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to retrieve the Custom Entity. 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 Custom Entity. Defaults to returning the latest version of the Custom Entity if not specified.")] = None, previews : Annotated[Optional[conlist(StrictStr)], Field(description="The ids of the staged modifications to be previewed in the response.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[CustomEntityEntity, Awaitable[CustomEntityEntity]]:  # noqa: E501
+        """[EXPERIMENTAL] GetCustomEntityByEntityUniqueId: Get a Custom Entity instance by its EntityUniqueId  # noqa: E501
+
+        Retrieve a particular Custom Entity instance.  If the Custom Entity is deleted, this will return the state of the Custom Entity immediately prior to deletion.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_custom_entity_by_entity_unique_id(entity_unique_id, effective_at, as_at, previews, async_req=True)
+        >>> result = thread.get()
+
+        :param entity_unique_id: The universally unique identifier of the Custom Entity. (required)
+        :type entity_unique_id: str
+        :param effective_at: The effective datetime or cut label at which to retrieve the Custom Entity. 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 Custom Entity. Defaults to returning the latest version of the Custom Entity if not specified.
+        :type as_at: datetime
+        :param previews: The ids of the staged modifications to be previewed in the response.
+        :type previews: List[str]
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _request_timeout: timeout setting for this request.
+               If one number provided, it will be total request
+               timeout. It can also be a pair (tuple) of
+               (connection, read) timeouts.
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: CustomEntityEntity
+        """
+        kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the get_custom_entity_by_entity_unique_id_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
+        return self.get_custom_entity_by_entity_unique_id_with_http_info(entity_unique_id, effective_at, as_at, previews, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def get_custom_entity_by_entity_unique_id_with_http_info(self, entity_unique_id : Annotated[constr(strict=True, max_length=40, min_length=30), Field(..., description="The universally unique identifier of the Custom Entity.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to retrieve the Custom Entity. 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 Custom Entity. Defaults to returning the latest version of the Custom Entity if not specified.")] = None, previews : Annotated[Optional[conlist(StrictStr)], Field(description="The ids of the staged modifications to be previewed in the response.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+        """[EXPERIMENTAL] GetCustomEntityByEntityUniqueId: Get a Custom Entity instance by its EntityUniqueId  # noqa: E501
+
+        Retrieve a particular Custom Entity instance.  If the Custom Entity is deleted, this will return the state of the Custom Entity immediately prior to deletion.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_custom_entity_by_entity_unique_id_with_http_info(entity_unique_id, effective_at, as_at, previews, async_req=True)
+        >>> result = thread.get()
+
+        :param entity_unique_id: The universally unique identifier of the Custom Entity. (required)
+        :type entity_unique_id: str
+        :param effective_at: The effective datetime or cut label at which to retrieve the Custom Entity. 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 Custom Entity. Defaults to returning the latest version of the Custom Entity if not specified.
+        :type as_at: datetime
+        :param previews: The ids of the staged modifications to be previewed in the response.
+        :type previews: List[str]
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
+        :type _preload_content: bool, optional
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(CustomEntityEntity, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = [
+            'entity_unique_id',
+            'effective_at',
+            'as_at',
+            'previews'
+        ]
+        _all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout',
+                '_request_auth',
+                '_content_type',
+                '_headers'
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_custom_entity_by_entity_unique_id" % _key
+                )
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params['entity_unique_id']:
+            _path_params['entityUniqueId'] = _params['entity_unique_id']
+
+
+        # process the query parameters
+        _query_params = []
+        if _params.get('effective_at') is not None:  # noqa: E501
+            _query_params.append(('effectiveAt', _params['effective_at']))
+
+        if _params.get('as_at') is not None:  # noqa: E501
+            if isinstance(_params['as_at'], datetime):
+                _query_params.append(('asAt', _params['as_at'].strftime(self.api_client.configuration.datetime_format)))
+            else:
+                _query_params.append(('asAt', _params['as_at']))
+
+        if _params.get('previews') is not None:  # noqa: E501
+            _query_params.append(('previews', _params['previews']))
+            _collection_formats['previews'] = 'multi'
+
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
+
+        _response_types_map = {
+            '200': "CustomEntityEntity",
+            '400': "LusidValidationProblemDetails",
+        }
+
+        return self.api_client.call_api(
+            '/api/entities/customentities/{entityUniqueId}', 'GET',
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
     @overload
     async def get_data_type_by_entity_unique_id(self, entity_unique_id : Annotated[constr(strict=True, max_length=40, min_length=30), Field(..., description="The universally unique identifier of the DataType definition.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the DataType definition. Defaults to returning the latest version of the DataType definition if not specified.")] = None, previews : Annotated[Optional[conlist(StrictStr)], Field(description="The ids of the staged modifications to be previewed in the response.")] = None, **kwargs) -> DataTypeEntity:  # noqa: E501
         ...

lusid/api/group_reconciliations_api.py

@@ -27,6 +27,7 @@ from pydantic.v1 import Field, constr, validator
 from typing import Optional
 
 from lusid.models.create_group_reconciliation_comparison_ruleset_request import CreateGroupReconciliationComparisonRulesetRequest
+from lusid.models.deleted_entity_response import DeletedEntityResponse
 from lusid.models.group_reconciliation_comparison_ruleset import GroupReconciliationComparisonRuleset
 
 from lusid.api_client import ApiClient
@@ -207,6 +208,165 @@ class GroupReconciliationsApi:
             collection_formats=_collection_formats,
             _request_auth=_params.get('_request_auth'))
 
+    @overload
+    async def delete_comparison_ruleset(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the specified comparison ruleset.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the specified comparison ruleset. Together with the domain and scope this uniquely              identifies the reconciliation comparison ruleset.")], **kwargs) -> DeletedEntityResponse:  # noqa: E501
+        ...
+
+    @overload
+    def delete_comparison_ruleset(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the specified comparison ruleset.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the specified comparison ruleset. Together with the domain and scope this uniquely              identifies the reconciliation comparison ruleset.")], async_req: Optional[bool]=True, **kwargs) -> DeletedEntityResponse:  # noqa: E501
+        ...
+
+    @validate_arguments
+    def delete_comparison_ruleset(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the specified comparison ruleset.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the specified comparison ruleset. Together with the domain and scope this uniquely              identifies the reconciliation comparison ruleset.")], async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
+        """[EXPERIMENTAL] DeleteComparisonRuleset: Deletes a particular Group Reconciliation Comparison Ruleset  # noqa: E501
+
+        The deletion will take effect from the reconciliation comparison ruleset deletion datetime.  i.e. will no longer exist at any asAt datetime after the asAt datetime of deletion.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.delete_comparison_ruleset(scope, code, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope of the specified comparison ruleset. (required)
+        :type scope: str
+        :param code: The code of the specified comparison ruleset. Together with the domain and scope this uniquely              identifies the reconciliation comparison ruleset. (required)
+        :type code: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _request_timeout: timeout setting for this request.
+               If one number provided, it will be total request
+               timeout. It can also be a pair (tuple) of
+               (connection, read) timeouts.
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: DeletedEntityResponse
+        """
+        kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the delete_comparison_ruleset_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
+        return self.delete_comparison_ruleset_with_http_info(scope, code, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def delete_comparison_ruleset_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the specified comparison ruleset.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the specified comparison ruleset. Together with the domain and scope this uniquely              identifies the reconciliation comparison ruleset.")], **kwargs) -> ApiResponse:  # noqa: E501
+        """[EXPERIMENTAL] DeleteComparisonRuleset: Deletes a particular Group Reconciliation Comparison Ruleset  # noqa: E501
+
+        The deletion will take effect from the reconciliation comparison ruleset deletion datetime.  i.e. will no longer exist at any asAt datetime after the asAt datetime of deletion.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.delete_comparison_ruleset_with_http_info(scope, code, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope of the specified comparison ruleset. (required)
+        :type scope: str
+        :param code: The code of the specified comparison ruleset. Together with the domain and scope this uniquely              identifies the reconciliation comparison ruleset. (required)
+        :type code: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
+        :type _preload_content: bool, optional
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(DeletedEntityResponse, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = [
+            'scope',
+            'code'
+        ]
+        _all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout',
+                '_request_auth',
+                '_content_type',
+                '_headers'
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method delete_comparison_ruleset" % _key
+                )
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params['scope']:
+            _path_params['scope'] = _params['scope']
+
+        if _params['code']:
+            _path_params['code'] = _params['code']
+
+
+        # process the query parameters
+        _query_params = []
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
+
+        _response_types_map = {
+            '200': "DeletedEntityResponse",
+            '400': "LusidValidationProblemDetails",
+        }
+
+        return self.api_client.call_api(
+            '/api/reconciliations/comparisonrulesets/{scope}/{code}', 'DELETE',
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
     @overload
     async def get_comparison_ruleset(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the specified comparison ruleset.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the specified comparison ruleset. Together with the domain and scope this uniquely              identifies the reconciliation comparison ruleset.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the comparison ruleset definition. Defaults to return              the latest version of the definition if not specified.")] = None, **kwargs) -> GroupReconciliationComparisonRuleset:  # noqa: E501
         ...

lusid/api/portfolios_api.py

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