lusid-sdk 2.1.991__py3-none-any.whl → 2.2.2__py3-none-any.whl

lusid/api/group_reconciliations_api.py

@@ -19,13 +19,10 @@ import warnings
 from pydantic.v1 import validate_arguments, ValidationError
 from typing import overload, Optional, Union, Awaitable
 
-from typing_extensions import Annotated
 from datetime import datetime
-
-from pydantic.v1 import Field, StrictStr, conint, conlist, constr, validator
-
-from typing import Optional
-
+from pydantic.v1 import Field, StrictInt, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
 from lusid.models.batch_update_user_review_for_comparison_result_request import BatchUpdateUserReviewForComparisonResultRequest
 from lusid.models.batch_update_user_review_for_comparison_result_response import BatchUpdateUserReviewForComparisonResultResponse
 from lusid.models.create_group_reconciliation_comparison_ruleset_request import CreateGroupReconciliationComparisonRulesetRequest
@@ -69,15 +66,15 @@ class GroupReconciliationsApi:
 
 
     @overload
-    async def batch_update_comparison_results(self, scope : Annotated[StrictStr, Field(..., description="Shared Scope of the GroupReconciliationDefinition and GroupReconciliationComparisonResults.")], code : Annotated[StrictStr, Field(..., description="GroupReconciliationDefinitionId code.")], batch_update_user_review_for_comparison_result_request : Annotated[conlist(BatchUpdateUserReviewForComparisonResultRequest), Field(..., description="A collection of the comparison result Ids and their user review entries to be added or removed.                  Single request contains resultId, break code/match key/comment to add and break code/match key/comment to remove by added timestamp.")], success_mode : Annotated[Optional[StrictStr], Field( description="Defines whether the request should fail if at least one of the entries is failed to update                  or process all the entries regardless and return collections of successful and failed updates. \"Partial\" (default) | \"Atomic\".")] = None, **kwargs) -> BatchUpdateUserReviewForComparisonResultResponse:  # noqa: E501
+    async def batch_update_comparison_results(self, scope : Annotated[StrictStr, Field(..., description="Shared Scope of the GroupReconciliationDefinition and GroupReconciliationComparisonResults.")], code : Annotated[StrictStr, Field(..., description="GroupReconciliationDefinitionId code.")], batch_update_user_review_for_comparison_result_request : Annotated[List[BatchUpdateUserReviewForComparisonResultRequest], Field(description="A collection of the comparison result Ids and their user review entries to be added or removed.                  Single request contains resultId, break code/match key/comment to add and break code/match key/comment to remove by added timestamp.")], success_mode : Annotated[Optional[StrictStr], Field( description="Defines whether the request should fail if at least one of the entries is failed to update                  or process all the entries regardless and return collections of successful and failed updates. \"Partial\" (default) | \"Atomic\".")] = None, **kwargs) -> BatchUpdateUserReviewForComparisonResultResponse:  # noqa: E501
         ...
 
     @overload
-    def batch_update_comparison_results(self, scope : Annotated[StrictStr, Field(..., description="Shared Scope of the GroupReconciliationDefinition and GroupReconciliationComparisonResults.")], code : Annotated[StrictStr, Field(..., description="GroupReconciliationDefinitionId code.")], batch_update_user_review_for_comparison_result_request : Annotated[conlist(BatchUpdateUserReviewForComparisonResultRequest), Field(..., description="A collection of the comparison result Ids and their user review entries to be added or removed.                  Single request contains resultId, break code/match key/comment to add and break code/match key/comment to remove by added timestamp.")], success_mode : Annotated[Optional[StrictStr], Field( description="Defines whether the request should fail if at least one of the entries is failed to update                  or process all the entries regardless and return collections of successful and failed updates. \"Partial\" (default) | \"Atomic\".")] = None, async_req: Optional[bool]=True, **kwargs) -> BatchUpdateUserReviewForComparisonResultResponse:  # noqa: E501
+    def batch_update_comparison_results(self, scope : Annotated[StrictStr, Field(..., description="Shared Scope of the GroupReconciliationDefinition and GroupReconciliationComparisonResults.")], code : Annotated[StrictStr, Field(..., description="GroupReconciliationDefinitionId code.")], batch_update_user_review_for_comparison_result_request : Annotated[List[BatchUpdateUserReviewForComparisonResultRequest], Field(description="A collection of the comparison result Ids and their user review entries to be added or removed.                  Single request contains resultId, break code/match key/comment to add and break code/match key/comment to remove by added timestamp.")], success_mode : Annotated[Optional[StrictStr], Field( description="Defines whether the request should fail if at least one of the entries is failed to update                  or process all the entries regardless and return collections of successful and failed updates. \"Partial\" (default) | \"Atomic\".")] = None, async_req: Optional[bool]=True, **kwargs) -> BatchUpdateUserReviewForComparisonResultResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def batch_update_comparison_results(self, scope : Annotated[StrictStr, Field(..., description="Shared Scope of the GroupReconciliationDefinition and GroupReconciliationComparisonResults.")], code : Annotated[StrictStr, Field(..., description="GroupReconciliationDefinitionId code.")], batch_update_user_review_for_comparison_result_request : Annotated[conlist(BatchUpdateUserReviewForComparisonResultRequest), Field(..., description="A collection of the comparison result Ids and their user review entries to be added or removed.                  Single request contains resultId, break code/match key/comment to add and break code/match key/comment to remove by added timestamp.")], success_mode : Annotated[Optional[StrictStr], Field( description="Defines whether the request should fail if at least one of the entries is failed to update                  or process all the entries regardless and return collections of successful and failed updates. \"Partial\" (default) | \"Atomic\".")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BatchUpdateUserReviewForComparisonResultResponse, Awaitable[BatchUpdateUserReviewForComparisonResultResponse]]:  # noqa: E501
+    def batch_update_comparison_results(self, scope : Annotated[StrictStr, Field(..., description="Shared Scope of the GroupReconciliationDefinition and GroupReconciliationComparisonResults.")], code : Annotated[StrictStr, Field(..., description="GroupReconciliationDefinitionId code.")], batch_update_user_review_for_comparison_result_request : Annotated[List[BatchUpdateUserReviewForComparisonResultRequest], Field(description="A collection of the comparison result Ids and their user review entries to be added or removed.                  Single request contains resultId, break code/match key/comment to add and break code/match key/comment to remove by added timestamp.")], success_mode : Annotated[Optional[StrictStr], Field( description="Defines whether the request should fail if at least one of the entries is failed to update                  or process all the entries regardless and return collections of successful and failed updates. \"Partial\" (default) | \"Atomic\".")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BatchUpdateUserReviewForComparisonResultResponse, Awaitable[BatchUpdateUserReviewForComparisonResultResponse]]:  # noqa: E501
         """[EXPERIMENTAL] BatchUpdateComparisonResults: Add User Review entries for a range of comparison results related to a specific GroupReconciliationDefinition.  # noqa: E501
 
         Allows to update multiple Group Reconciliation Comparison Results related to the same definition specified by the Scope and Code.  Updates User Review with new entries and sets the relevant Review Status.  Supports partial success when all the entries that haven't passed validation or are not related to the definition will be returned with respectful error details.  # noqa: E501
@@ -114,7 +111,7 @@ class GroupReconciliationsApi:
         return self.batch_update_comparison_results_with_http_info(scope, code, batch_update_user_review_for_comparison_result_request, success_mode, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def batch_update_comparison_results_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="Shared Scope of the GroupReconciliationDefinition and GroupReconciliationComparisonResults.")], code : Annotated[StrictStr, Field(..., description="GroupReconciliationDefinitionId code.")], batch_update_user_review_for_comparison_result_request : Annotated[conlist(BatchUpdateUserReviewForComparisonResultRequest), Field(..., description="A collection of the comparison result Ids and their user review entries to be added or removed.                  Single request contains resultId, break code/match key/comment to add and break code/match key/comment to remove by added timestamp.")], success_mode : Annotated[Optional[StrictStr], Field( description="Defines whether the request should fail if at least one of the entries is failed to update                  or process all the entries regardless and return collections of successful and failed updates. \"Partial\" (default) | \"Atomic\".")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def batch_update_comparison_results_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="Shared Scope of the GroupReconciliationDefinition and GroupReconciliationComparisonResults.")], code : Annotated[StrictStr, Field(..., description="GroupReconciliationDefinitionId code.")], batch_update_user_review_for_comparison_result_request : Annotated[List[BatchUpdateUserReviewForComparisonResultRequest], Field(description="A collection of the comparison result Ids and their user review entries to be added or removed.                  Single request contains resultId, break code/match key/comment to add and break code/match key/comment to remove by added timestamp.")], success_mode : Annotated[Optional[StrictStr], Field( description="Defines whether the request should fail if at least one of the entries is failed to update                  or process all the entries regardless and return collections of successful and failed updates. \"Partial\" (default) | \"Atomic\".")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] BatchUpdateComparisonResults: Add User Review entries for a range of comparison results related to a specific GroupReconciliationDefinition.  # noqa: E501
 
         Allows to update multiple Group Reconciliation Comparison Results related to the same definition specified by the Scope and Code.  Updates User Review with new entries and sets the relevant Review Status.  Supports partial success when all the entries that haven't passed validation or are not related to the definition will be returned with respectful error details.  # noqa: E501
@@ -1419,15 +1416,15 @@ class GroupReconciliationsApi:
 
 
     @overload
-    async def list_comparison_results(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the comparison results. Defaults to return the latest              version of the comparison results if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing comparison results from a previous call to list              comparison results. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> PagedResourceListOfGroupReconciliationComparisonResult:  # noqa: E501
+    async def list_comparison_results(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the comparison results. Defaults to return the latest              version of the comparison results if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing comparison results from a previous call to list              comparison results. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> PagedResourceListOfGroupReconciliationComparisonResult:  # noqa: E501
         ...
 
     @overload
-    def list_comparison_results(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the comparison results. Defaults to return the latest              version of the comparison results if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing comparison results from a previous call to list              comparison results. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfGroupReconciliationComparisonResult:  # noqa: E501
+    def list_comparison_results(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the comparison results. Defaults to return the latest              version of the comparison results if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing comparison results from a previous call to list              comparison results. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfGroupReconciliationComparisonResult:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_comparison_results(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the comparison results. Defaults to return the latest              version of the comparison results if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing comparison results from a previous call to list              comparison results. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfGroupReconciliationComparisonResult, Awaitable[PagedResourceListOfGroupReconciliationComparisonResult]]:  # noqa: E501
+    def list_comparison_results(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the comparison results. Defaults to return the latest              version of the comparison results if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing comparison results from a previous call to list              comparison results. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfGroupReconciliationComparisonResult, Awaitable[PagedResourceListOfGroupReconciliationComparisonResult]]:  # noqa: E501
         """[EXPERIMENTAL] ListComparisonResults: Get a set of Group Reconciliation Comparison Results.  # noqa: E501
 
         Retrieves all Group Reconciliation Comparison Results that fit the filter, in a specific order if sortBy is provided.  Supports pagination.  # noqa: E501
@@ -1466,7 +1463,7 @@ class GroupReconciliationsApi:
         return self.list_comparison_results_with_http_info(as_at, page, sort_by, limit, filter, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_comparison_results_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the comparison results. Defaults to return the latest              version of the comparison results if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing comparison results from a previous call to list              comparison results. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_comparison_results_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the comparison results. Defaults to return the latest              version of the comparison results if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing comparison results from a previous call to list              comparison results. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] ListComparisonResults: Get a set of Group Reconciliation Comparison Results.  # noqa: E501
 
         Retrieves all Group Reconciliation Comparison Results that fit the filter, in a specific order if sortBy is provided.  Supports pagination.  # noqa: E501
@@ -1607,15 +1604,15 @@ class GroupReconciliationsApi:
 
 
     @overload
-    async def list_comparison_rulesets(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the comparison rulesets. Defaults to return the latest              version of the comparison rulesets if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing comparison rulesets from a previous call to list              comparison rulesets. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> PagedResourceListOfGroupReconciliationComparisonRuleset:  # noqa: E501
+    async def list_comparison_rulesets(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the comparison rulesets. Defaults to return the latest              version of the comparison rulesets if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing comparison rulesets from a previous call to list              comparison rulesets. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> PagedResourceListOfGroupReconciliationComparisonRuleset:  # noqa: E501
         ...
 
     @overload
-    def list_comparison_rulesets(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the comparison rulesets. Defaults to return the latest              version of the comparison rulesets if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing comparison rulesets from a previous call to list              comparison rulesets. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfGroupReconciliationComparisonRuleset:  # noqa: E501
+    def list_comparison_rulesets(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the comparison rulesets. Defaults to return the latest              version of the comparison rulesets if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing comparison rulesets from a previous call to list              comparison rulesets. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfGroupReconciliationComparisonRuleset:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_comparison_rulesets(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the comparison rulesets. Defaults to return the latest              version of the comparison rulesets if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing comparison rulesets from a previous call to list              comparison rulesets. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfGroupReconciliationComparisonRuleset, Awaitable[PagedResourceListOfGroupReconciliationComparisonRuleset]]:  # noqa: E501
+    def list_comparison_rulesets(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the comparison rulesets. Defaults to return the latest              version of the comparison rulesets if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing comparison rulesets from a previous call to list              comparison rulesets. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfGroupReconciliationComparisonRuleset, Awaitable[PagedResourceListOfGroupReconciliationComparisonRuleset]]:  # noqa: E501
         """[EXPERIMENTAL] ListComparisonRulesets: Get a set of Group Reconciliation Comparison Rulesets  # noqa: E501
 
         Retrieves all Group Reconciliation Comparison Ruleset that fit the filter, in a specific order if sortBy is provided  Supports pagination  # noqa: E501
@@ -1654,7 +1651,7 @@ class GroupReconciliationsApi:
         return self.list_comparison_rulesets_with_http_info(as_at, page, sort_by, limit, filter, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_comparison_rulesets_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the comparison rulesets. Defaults to return the latest              version of the comparison rulesets if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing comparison rulesets from a previous call to list              comparison rulesets. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_comparison_rulesets_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the comparison rulesets. Defaults to return the latest              version of the comparison rulesets if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing comparison rulesets from a previous call to list              comparison rulesets. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] ListComparisonRulesets: Get a set of Group Reconciliation Comparison Rulesets  # noqa: E501
 
         Retrieves all Group Reconciliation Comparison Ruleset that fit the filter, in a specific order if sortBy is provided  Supports pagination  # noqa: E501
@@ -1795,15 +1792,15 @@ class GroupReconciliationsApi:
 
 
     @overload
-    async def list_group_reconciliation_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the group reconciliation 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 list the group reconciliation definitions. Defaults to return the latest version of each group reconciliation definition if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing group reconciliation definitions from a previous call to list group reconciliation definitions. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Display Name, use \"displayName eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, **kwargs) -> PagedResourceListOfGroupReconciliationDefinition:  # noqa: E501
+    async def list_group_reconciliation_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the group reconciliation 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 list the group reconciliation definitions. Defaults to return the latest version of each group reconciliation definition if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing group reconciliation definitions from a previous call to list group reconciliation definitions. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Display Name, use \"displayName eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, **kwargs) -> PagedResourceListOfGroupReconciliationDefinition:  # noqa: E501
         ...
 
     @overload
-    def list_group_reconciliation_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the group reconciliation 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 list the group reconciliation definitions. Defaults to return the latest version of each group reconciliation definition if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing group reconciliation definitions from a previous call to list group reconciliation definitions. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Display Name, use \"displayName eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfGroupReconciliationDefinition:  # noqa: E501
+    def list_group_reconciliation_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the group reconciliation 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 list the group reconciliation definitions. Defaults to return the latest version of each group reconciliation definition if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing group reconciliation definitions from a previous call to list group reconciliation definitions. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Display Name, use \"displayName eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfGroupReconciliationDefinition:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_group_reconciliation_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the group reconciliation 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 list the group reconciliation definitions. Defaults to return the latest version of each group reconciliation definition if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing group reconciliation definitions from a previous call to list group reconciliation definitions. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Display Name, use \"displayName eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfGroupReconciliationDefinition, Awaitable[PagedResourceListOfGroupReconciliationDefinition]]:  # noqa: E501
+    def list_group_reconciliation_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the group reconciliation 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 list the group reconciliation definitions. Defaults to return the latest version of each group reconciliation definition if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing group reconciliation definitions from a previous call to list group reconciliation definitions. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Display Name, use \"displayName eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfGroupReconciliationDefinition, Awaitable[PagedResourceListOfGroupReconciliationDefinition]]:  # noqa: E501
         """[EXPERIMENTAL] ListGroupReconciliationDefinitions: List group reconciliation definitions  # noqa: E501
 
         Lists Group Reconciliation Definitions matching any provided filter, limit and sorting rules  # noqa: E501
@@ -1844,7 +1841,7 @@ class GroupReconciliationsApi:
         return self.list_group_reconciliation_definitions_with_http_info(effective_at, as_at, page, limit, filter, sort_by, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_group_reconciliation_definitions_with_http_info(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the group reconciliation 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 list the group reconciliation definitions. Defaults to return the latest version of each group reconciliation definition if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing group reconciliation definitions from a previous call to list group reconciliation definitions. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Display Name, use \"displayName eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_group_reconciliation_definitions_with_http_info(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the group reconciliation 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 list the group reconciliation definitions. Defaults to return the latest version of each group reconciliation definition if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing group reconciliation definitions from a previous call to list group reconciliation definitions. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to no limit if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Display Name, use \"displayName eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] ListGroupReconciliationDefinitions: List group reconciliation definitions  # noqa: E501
 
         Lists Group Reconciliation Definitions matching any provided filter, limit and sorting rules  # noqa: E501

lusid/api/identifier_definitions_api.py

@@ -19,13 +19,10 @@ import warnings
 from pydantic.v1 import validate_arguments, ValidationError
 from typing import overload, Optional, Union, Awaitable
 
-from typing_extensions import Annotated
 from datetime import datetime
-
-from pydantic.v1 import Field, StrictStr, conint, conlist, constr, validator
-
-from typing import Optional
-
+from pydantic.v1 import Field, StrictInt, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
 from lusid.models.create_identifier_definition_request import CreateIdentifierDefinitionRequest
 from lusid.models.deleted_entity_response import DeletedEntityResponse
 from lusid.models.identifier_definition import IdentifierDefinition
@@ -386,15 +383,15 @@ class IdentifierDefinitionsApi:
 
 
     @overload
-    async def get_identifier_definition(self, domain : Annotated[StrictStr, Field(..., description="The type of entity to which the identifier relates.")], identifier_scope : Annotated[StrictStr, Field(..., description="The scope that the identifier exists in")], identifier_type : Annotated[StrictStr, Field(..., description="What the identifier represents. Together with \"domain\" and \"identifierScope\" this uniquely identifies the identifier definition")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Identifier Definition. Defaults to return              the latest version of the definition if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the Identifier Definitions.              Since Identifier Definitions exist for all effective time, this will only apply to properties (if requested)              on the Identifier Definition.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'IdentifierDefinition' domain to decorate onto the Identifier Definition.              These must take the format {domain}/{scope}/{code}. If no properties are specified, then no properties will be returned.")] = None, **kwargs) -> IdentifierDefinition:  # noqa: E501
+    async def get_identifier_definition(self, domain : Annotated[StrictStr, Field(..., description="The type of entity to which the identifier relates.")], identifier_scope : Annotated[StrictStr, Field(..., description="The scope that the identifier exists in")], identifier_type : Annotated[StrictStr, Field(..., description="What the identifier represents. Together with \"domain\" and \"identifierScope\" this uniquely identifies the identifier definition")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Identifier Definition. Defaults to return              the latest version of the definition if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the Identifier Definitions.              Since Identifier Definitions exist for all effective time, this will only apply to properties (if requested)              on the Identifier Definition.")] = None, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'IdentifierDefinition' domain to decorate onto the Identifier Definition.              These must take the format {domain}/{scope}/{code}. If no properties are specified, then no properties will be returned.")] = None, **kwargs) -> IdentifierDefinition:  # noqa: E501
         ...
 
     @overload
-    def get_identifier_definition(self, domain : Annotated[StrictStr, Field(..., description="The type of entity to which the identifier relates.")], identifier_scope : Annotated[StrictStr, Field(..., description="The scope that the identifier exists in")], identifier_type : Annotated[StrictStr, Field(..., description="What the identifier represents. Together with \"domain\" and \"identifierScope\" this uniquely identifies the identifier definition")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Identifier Definition. Defaults to return              the latest version of the definition if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the Identifier Definitions.              Since Identifier Definitions exist for all effective time, this will only apply to properties (if requested)              on the Identifier Definition.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'IdentifierDefinition' domain to decorate onto the Identifier Definition.              These must take the format {domain}/{scope}/{code}. If no properties are specified, then no properties will be returned.")] = None, async_req: Optional[bool]=True, **kwargs) -> IdentifierDefinition:  # noqa: E501
+    def get_identifier_definition(self, domain : Annotated[StrictStr, Field(..., description="The type of entity to which the identifier relates.")], identifier_scope : Annotated[StrictStr, Field(..., description="The scope that the identifier exists in")], identifier_type : Annotated[StrictStr, Field(..., description="What the identifier represents. Together with \"domain\" and \"identifierScope\" this uniquely identifies the identifier definition")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Identifier Definition. Defaults to return              the latest version of the definition if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the Identifier Definitions.              Since Identifier Definitions exist for all effective time, this will only apply to properties (if requested)              on the Identifier Definition.")] = None, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'IdentifierDefinition' domain to decorate onto the Identifier Definition.              These must take the format {domain}/{scope}/{code}. If no properties are specified, then no properties will be returned.")] = None, async_req: Optional[bool]=True, **kwargs) -> IdentifierDefinition:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_identifier_definition(self, domain : Annotated[StrictStr, Field(..., description="The type of entity to which the identifier relates.")], identifier_scope : Annotated[StrictStr, Field(..., description="The scope that the identifier exists in")], identifier_type : Annotated[StrictStr, Field(..., description="What the identifier represents. Together with \"domain\" and \"identifierScope\" this uniquely identifies the identifier definition")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Identifier Definition. Defaults to return              the latest version of the definition if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the Identifier Definitions.              Since Identifier Definitions exist for all effective time, this will only apply to properties (if requested)              on the Identifier Definition.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'IdentifierDefinition' domain to decorate onto the Identifier Definition.              These must take the format {domain}/{scope}/{code}. If no properties are specified, then no properties will be returned.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[IdentifierDefinition, Awaitable[IdentifierDefinition]]:  # noqa: E501
+    def get_identifier_definition(self, domain : Annotated[StrictStr, Field(..., description="The type of entity to which the identifier relates.")], identifier_scope : Annotated[StrictStr, Field(..., description="The scope that the identifier exists in")], identifier_type : Annotated[StrictStr, Field(..., description="What the identifier represents. Together with \"domain\" and \"identifierScope\" this uniquely identifies the identifier definition")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Identifier Definition. Defaults to return              the latest version of the definition if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the Identifier Definitions.              Since Identifier Definitions exist for all effective time, this will only apply to properties (if requested)              on the Identifier Definition.")] = None, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'IdentifierDefinition' domain to decorate onto the Identifier Definition.              These must take the format {domain}/{scope}/{code}. If no properties are specified, then no properties will be returned.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[IdentifierDefinition, Awaitable[IdentifierDefinition]]:  # noqa: E501
         """[EXPERIMENTAL] GetIdentifierDefinition: Get a single Identifier Definition  # noqa: E501
 
         Get a single Identifier Definition using domain, identifierScope, identifierType, and an optional asAt              - defaulting to latest if not specified  # noqa: E501
@@ -435,7 +432,7 @@ class IdentifierDefinitionsApi:
         return self.get_identifier_definition_with_http_info(domain, identifier_scope, identifier_type, as_at, effective_at, property_keys, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_identifier_definition_with_http_info(self, domain : Annotated[StrictStr, Field(..., description="The type of entity to which the identifier relates.")], identifier_scope : Annotated[StrictStr, Field(..., description="The scope that the identifier exists in")], identifier_type : Annotated[StrictStr, Field(..., description="What the identifier represents. Together with \"domain\" and \"identifierScope\" this uniquely identifies the identifier definition")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Identifier Definition. Defaults to return              the latest version of the definition if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the Identifier Definitions.              Since Identifier Definitions exist for all effective time, this will only apply to properties (if requested)              on the Identifier Definition.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'IdentifierDefinition' domain to decorate onto the Identifier Definition.              These must take the format {domain}/{scope}/{code}. If no properties are specified, then no properties will be returned.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_identifier_definition_with_http_info(self, domain : Annotated[StrictStr, Field(..., description="The type of entity to which the identifier relates.")], identifier_scope : Annotated[StrictStr, Field(..., description="The scope that the identifier exists in")], identifier_type : Annotated[StrictStr, Field(..., description="What the identifier represents. Together with \"domain\" and \"identifierScope\" this uniquely identifies the identifier definition")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Identifier Definition. Defaults to return              the latest version of the definition if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the Identifier Definitions.              Since Identifier Definitions exist for all effective time, this will only apply to properties (if requested)              on the Identifier Definition.")] = None, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'IdentifierDefinition' domain to decorate onto the Identifier Definition.              These must take the format {domain}/{scope}/{code}. If no properties are specified, then no properties will be returned.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] GetIdentifierDefinition: Get a single Identifier Definition  # noqa: E501
 
         Get a single Identifier Definition using domain, identifierScope, identifierType, and an optional asAt              - defaulting to latest if not specified  # noqa: E501
@@ -582,15 +579,15 @@ class IdentifierDefinitionsApi:
 
 
     @overload
-    async def list_identifier_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the Identifier Definitions.              Since Identifier Definitions exist for all effective time, this will only apply to properties (if requested)              on the Identifier Definition.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Identifier Definitions. Defaults to return the latest              version of the Identifier Definitions if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Identifier Definitions from a previous call to list              Identifier Definitions. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'IdentifierDefinition' domain to decorate onto the Identifier Definition.              These must take the format {domain}/{scope}/{code}.")] = None, **kwargs) -> PagedResourceListOfIdentifierDefinition:  # noqa: E501
+    async def list_identifier_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the Identifier Definitions.              Since Identifier Definitions exist for all effective time, this will only apply to properties (if requested)              on the Identifier Definition.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Identifier Definitions. Defaults to return the latest              version of the Identifier Definitions if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Identifier Definitions from a previous call to list              Identifier Definitions. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'IdentifierDefinition' domain to decorate onto the Identifier Definition.              These must take the format {domain}/{scope}/{code}.")] = None, **kwargs) -> PagedResourceListOfIdentifierDefinition:  # noqa: E501
         ...
 
     @overload
-    def list_identifier_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the Identifier Definitions.              Since Identifier Definitions exist for all effective time, this will only apply to properties (if requested)              on the Identifier Definition.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Identifier Definitions. Defaults to return the latest              version of the Identifier Definitions if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Identifier Definitions from a previous call to list              Identifier Definitions. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'IdentifierDefinition' domain to decorate onto the Identifier Definition.              These must take the format {domain}/{scope}/{code}.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfIdentifierDefinition:  # noqa: E501
+    def list_identifier_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the Identifier Definitions.              Since Identifier Definitions exist for all effective time, this will only apply to properties (if requested)              on the Identifier Definition.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Identifier Definitions. Defaults to return the latest              version of the Identifier Definitions if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Identifier Definitions from a previous call to list              Identifier Definitions. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'IdentifierDefinition' domain to decorate onto the Identifier Definition.              These must take the format {domain}/{scope}/{code}.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfIdentifierDefinition:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_identifier_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the Identifier Definitions.              Since Identifier Definitions exist for all effective time, this will only apply to properties (if requested)              on the Identifier Definition.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Identifier Definitions. Defaults to return the latest              version of the Identifier Definitions if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Identifier Definitions from a previous call to list              Identifier Definitions. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'IdentifierDefinition' domain to decorate onto the Identifier Definition.              These must take the format {domain}/{scope}/{code}.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfIdentifierDefinition, Awaitable[PagedResourceListOfIdentifierDefinition]]:  # noqa: E501
+    def list_identifier_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the Identifier Definitions.              Since Identifier Definitions exist for all effective time, this will only apply to properties (if requested)              on the Identifier Definition.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Identifier Definitions. Defaults to return the latest              version of the Identifier Definitions if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Identifier Definitions from a previous call to list              Identifier Definitions. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'IdentifierDefinition' domain to decorate onto the Identifier Definition.              These must take the format {domain}/{scope}/{code}.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfIdentifierDefinition, Awaitable[PagedResourceListOfIdentifierDefinition]]:  # noqa: E501
         """[EXPERIMENTAL] ListIdentifierDefinitions: List Identifier Definitions  # noqa: E501
 
         Retrieves all Identifier Definitions that fit the filter, in a specific order if sortBy is provided  Supports pagination  # noqa: E501
@@ -633,7 +630,7 @@ class IdentifierDefinitionsApi:
         return self.list_identifier_definitions_with_http_info(effective_at, as_at, page, limit, filter, sort_by, property_keys, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_identifier_definitions_with_http_info(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the Identifier Definitions.              Since Identifier Definitions exist for all effective time, this will only apply to properties (if requested)              on the Identifier Definition.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Identifier Definitions. Defaults to return the latest              version of the Identifier Definitions if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Identifier Definitions from a previous call to list              Identifier Definitions. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'IdentifierDefinition' domain to decorate onto the Identifier Definition.              These must take the format {domain}/{scope}/{code}.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_identifier_definitions_with_http_info(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which to retrieve the Identifier Definitions.              Since Identifier Definitions exist for all effective time, this will only apply to properties (if requested)              on the Identifier Definition.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Identifier Definitions. Defaults to return the latest              version of the Identifier Definitions if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Identifier Definitions from a previous call to list              Identifier Definitions. This value is returned from the previous call. If a pagination token is provided the sortBy,              filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many per page.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'IdentifierDefinition' domain to decorate onto the Identifier Definition.              These must take the format {domain}/{scope}/{code}.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] ListIdentifierDefinitions: List Identifier Definitions  # noqa: E501
 
         Retrieves all Identifier Definitions that fit the filter, in a specific order if sortBy is provided  Supports pagination  # noqa: E501

lusid/api/instrument_event_types_api.py

@@ -19,13 +19,10 @@ import warnings
 from pydantic.v1 import validate_arguments, ValidationError
 from typing import overload, Optional, Union, Awaitable
 
-from typing_extensions import Annotated
 from datetime import datetime
-
-from pydantic.v1 import Field, StrictStr, conint, conlist, constr, validator
-
-from typing import Optional
-
+from pydantic.v1 import Field, StrictInt, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
 from lusid.models.paged_resource_list_of_transaction_template import PagedResourceListOfTransactionTemplate
 from lusid.models.paged_resource_list_of_transaction_template_specification import PagedResourceListOfTransactionTemplateSpecification
 from lusid.models.transaction_template import TransactionTemplate
@@ -59,15 +56,15 @@ class InstrumentEventTypesApi:
 
 
     @overload
-    async def create_transaction_template(self, instrument_event_type : Annotated[StrictStr, Field(..., description="The type of instrument events that the template is applied to.")], instrument_type : Annotated[StrictStr, Field(..., description="The instrument type of the transaction template. The combination of the instrument              event type, instrument type and scope uniquely identifies a transaction template")], scope : Annotated[StrictStr, Field(..., description="The scope in which the template lies.")], transaction_template_request : Annotated[TransactionTemplateRequest, Field(..., description="A request defining a new transaction template to be created.")], **kwargs) -> TransactionTemplate:  # noqa: E501
+    async def create_transaction_template(self, instrument_event_type : Annotated[StrictStr, Field(..., description="The type of instrument events that the template is applied to.")], instrument_type : Annotated[StrictStr, Field(..., description="The instrument type of the transaction template. The combination of the instrument              event type, instrument type and scope uniquely identifies a transaction template")], scope : Annotated[StrictStr, Field(..., description="The scope in which the template lies.")], transaction_template_request : Annotated[TransactionTemplateRequest, Field(description="A request defining a new transaction template to be created.")], **kwargs) -> TransactionTemplate:  # noqa: E501
         ...
 
     @overload
-    def create_transaction_template(self, instrument_event_type : Annotated[StrictStr, Field(..., description="The type of instrument events that the template is applied to.")], instrument_type : Annotated[StrictStr, Field(..., description="The instrument type of the transaction template. The combination of the instrument              event type, instrument type and scope uniquely identifies a transaction template")], scope : Annotated[StrictStr, Field(..., description="The scope in which the template lies.")], transaction_template_request : Annotated[TransactionTemplateRequest, Field(..., description="A request defining a new transaction template to be created.")], async_req: Optional[bool]=True, **kwargs) -> TransactionTemplate:  # noqa: E501
+    def create_transaction_template(self, instrument_event_type : Annotated[StrictStr, Field(..., description="The type of instrument events that the template is applied to.")], instrument_type : Annotated[StrictStr, Field(..., description="The instrument type of the transaction template. The combination of the instrument              event type, instrument type and scope uniquely identifies a transaction template")], scope : Annotated[StrictStr, Field(..., description="The scope in which the template lies.")], transaction_template_request : Annotated[TransactionTemplateRequest, Field(description="A request defining a new transaction template to be created.")], async_req: Optional[bool]=True, **kwargs) -> TransactionTemplate:  # noqa: E501
         ...
 
     @validate_arguments
-    def create_transaction_template(self, instrument_event_type : Annotated[StrictStr, Field(..., description="The type of instrument events that the template is applied to.")], instrument_type : Annotated[StrictStr, Field(..., description="The instrument type of the transaction template. The combination of the instrument              event type, instrument type and scope uniquely identifies a transaction template")], scope : Annotated[StrictStr, Field(..., description="The scope in which the template lies.")], transaction_template_request : Annotated[TransactionTemplateRequest, Field(..., description="A request defining a new transaction template to be created.")], async_req: Optional[bool]=None, **kwargs) -> Union[TransactionTemplate, Awaitable[TransactionTemplate]]:  # noqa: E501
+    def create_transaction_template(self, instrument_event_type : Annotated[StrictStr, Field(..., description="The type of instrument events that the template is applied to.")], instrument_type : Annotated[StrictStr, Field(..., description="The instrument type of the transaction template. The combination of the instrument              event type, instrument type and scope uniquely identifies a transaction template")], scope : Annotated[StrictStr, Field(..., description="The scope in which the template lies.")], transaction_template_request : Annotated[TransactionTemplateRequest, Field(description="A request defining a new transaction template to be created.")], async_req: Optional[bool]=None, **kwargs) -> Union[TransactionTemplate, Awaitable[TransactionTemplate]]:  # noqa: E501
         """CreateTransactionTemplate: Create Transaction Template  # noqa: E501
 
         Create a transaction template for a particular instrument event type in a scope.  # noqa: E501
@@ -104,7 +101,7 @@ class InstrumentEventTypesApi:
         return self.create_transaction_template_with_http_info(instrument_event_type, instrument_type, scope, transaction_template_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def create_transaction_template_with_http_info(self, instrument_event_type : Annotated[StrictStr, Field(..., description="The type of instrument events that the template is applied to.")], instrument_type : Annotated[StrictStr, Field(..., description="The instrument type of the transaction template. The combination of the instrument              event type, instrument type and scope uniquely identifies a transaction template")], scope : Annotated[StrictStr, Field(..., description="The scope in which the template lies.")], transaction_template_request : Annotated[TransactionTemplateRequest, Field(..., description="A request defining a new transaction template to be created.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def create_transaction_template_with_http_info(self, instrument_event_type : Annotated[StrictStr, Field(..., description="The type of instrument events that the template is applied to.")], instrument_type : Annotated[StrictStr, Field(..., description="The instrument type of the transaction template. The combination of the instrument              event type, instrument type and scope uniquely identifies a transaction template")], scope : Annotated[StrictStr, Field(..., description="The scope in which the template lies.")], transaction_template_request : Annotated[TransactionTemplateRequest, Field(description="A request defining a new transaction template to be created.")], **kwargs) -> ApiResponse:  # noqa: E501
         """CreateTransactionTemplate: Create Transaction Template  # noqa: E501
 
         Create a transaction template for a particular instrument event type in a scope.  # noqa: E501
@@ -741,15 +738,15 @@ class InstrumentEventTypesApi:
 
 
     @overload
-    async def list_transaction_template_specifications(self, as_at : Annotated[Optional[datetime], Field(description="AsAt of the request")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Transaction Template Specifications from              a previous call to list Transaction Template Specifications.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, and asAt              fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, **kwargs) -> PagedResourceListOfTransactionTemplateSpecification:  # noqa: E501
+    async def list_transaction_template_specifications(self, as_at : Annotated[Optional[datetime], Field(description="AsAt of the request")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Transaction Template Specifications from              a previous call to list Transaction Template Specifications.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, and asAt              fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, **kwargs) -> PagedResourceListOfTransactionTemplateSpecification:  # noqa: E501
         ...
 
     @overload
-    def list_transaction_template_specifications(self, as_at : Annotated[Optional[datetime], Field(description="AsAt of the request")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Transaction Template Specifications from              a previous call to list Transaction Template Specifications.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, and asAt              fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfTransactionTemplateSpecification:  # noqa: E501
+    def list_transaction_template_specifications(self, as_at : Annotated[Optional[datetime], Field(description="AsAt of the request")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Transaction Template Specifications from              a previous call to list Transaction Template Specifications.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, and asAt              fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfTransactionTemplateSpecification:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_transaction_template_specifications(self, as_at : Annotated[Optional[datetime], Field(description="AsAt of the request")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Transaction Template Specifications from              a previous call to list Transaction Template Specifications.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, and asAt              fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfTransactionTemplateSpecification, Awaitable[PagedResourceListOfTransactionTemplateSpecification]]:  # noqa: E501
+    def list_transaction_template_specifications(self, as_at : Annotated[Optional[datetime], Field(description="AsAt of the request")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Transaction Template Specifications from              a previous call to list Transaction Template Specifications.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, and asAt              fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfTransactionTemplateSpecification, Awaitable[PagedResourceListOfTransactionTemplateSpecification]]:  # noqa: E501
         """ListTransactionTemplateSpecifications: List Transaction Template Specifications.  # noqa: E501
 
         Retrieves all transaction template specifications.  # noqa: E501
@@ -788,7 +785,7 @@ class InstrumentEventTypesApi:
         return self.list_transaction_template_specifications_with_http_info(as_at, page, limit, filter, sort_by, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_transaction_template_specifications_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="AsAt of the request")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Transaction Template Specifications from              a previous call to list Transaction Template Specifications.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, and asAt              fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_transaction_template_specifications_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="AsAt of the request")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Transaction Template Specifications from              a previous call to list Transaction Template Specifications.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, and asAt              fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\".")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """ListTransactionTemplateSpecifications: List Transaction Template Specifications.  # noqa: E501
 
         Retrieves all transaction template specifications.  # noqa: E501
@@ -929,15 +926,15 @@ class InstrumentEventTypesApi:
 
 
     @overload
-    async def list_transaction_templates(self, as_at : Annotated[Optional[datetime], Field(description="The AsAt time at which to retrieve the Transaction Templates")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Transaction Templates from a previous call to list Transaction Templates.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, limit, and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, **kwargs) -> PagedResourceListOfTransactionTemplate:  # noqa: E501
+    async def list_transaction_templates(self, as_at : Annotated[Optional[datetime], Field(description="The AsAt time at which to retrieve the Transaction Templates")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Transaction Templates from a previous call to list Transaction Templates.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, limit, and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, **kwargs) -> PagedResourceListOfTransactionTemplate:  # noqa: E501
         ...
 
     @overload
-    def list_transaction_templates(self, as_at : Annotated[Optional[datetime], Field(description="The AsAt time at which to retrieve the Transaction Templates")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Transaction Templates from a previous call to list Transaction Templates.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, limit, and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfTransactionTemplate:  # noqa: E501
+    def list_transaction_templates(self, as_at : Annotated[Optional[datetime], Field(description="The AsAt time at which to retrieve the Transaction Templates")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Transaction Templates from a previous call to list Transaction Templates.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, limit, and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfTransactionTemplate:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_transaction_templates(self, as_at : Annotated[Optional[datetime], Field(description="The AsAt time at which to retrieve the Transaction Templates")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Transaction Templates from a previous call to list Transaction Templates.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, limit, and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfTransactionTemplate, Awaitable[PagedResourceListOfTransactionTemplate]]:  # noqa: E501
+    def list_transaction_templates(self, as_at : Annotated[Optional[datetime], Field(description="The AsAt time at which to retrieve the Transaction Templates")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Transaction Templates from a previous call to list Transaction Templates.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, limit, and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfTransactionTemplate, Awaitable[PagedResourceListOfTransactionTemplate]]:  # noqa: E501
         """ListTransactionTemplates: List Transaction Templates  # noqa: E501
 
         Lists all Transaction Templates.  # noqa: E501
@@ -976,7 +973,7 @@ class InstrumentEventTypesApi:
         return self.list_transaction_templates_with_http_info(as_at, page, limit, filter, sort_by, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_transaction_templates_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The AsAt time at which to retrieve the Transaction Templates")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Transaction Templates from a previous call to list Transaction Templates.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, limit, and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_transaction_templates_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The AsAt time at which to retrieve the Transaction Templates")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Transaction Templates from a previous call to list Transaction Templates.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, limit, and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set. Read more about filtering results from LUSID here:              https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """ListTransactionTemplates: List Transaction Templates  # noqa: E501
 
         Lists all Transaction Templates.  # noqa: E501
@@ -1117,15 +1114,15 @@ class InstrumentEventTypesApi:
 
 
     @overload
-    async def update_transaction_template(self, instrument_event_type : Annotated[StrictStr, Field(..., description="The type of instrument events that the template is applied to.")], instrument_type : Annotated[StrictStr, Field(..., description="The instrument type of the transaction template. The combination of the instrument              event type, instrument type and scope uniquely identifies a transaction template")], scope : Annotated[StrictStr, Field(..., description="The scope in which the template lies.")], transaction_template_request : Annotated[TransactionTemplateRequest, Field(..., description="A request defining the updated values for the transaction template.")], **kwargs) -> TransactionTemplate:  # noqa: E501
+    async def update_transaction_template(self, instrument_event_type : Annotated[StrictStr, Field(..., description="The type of instrument events that the template is applied to.")], instrument_type : Annotated[StrictStr, Field(..., description="The instrument type of the transaction template. The combination of the instrument              event type, instrument type and scope uniquely identifies a transaction template")], scope : Annotated[StrictStr, Field(..., description="The scope in which the template lies.")], transaction_template_request : Annotated[TransactionTemplateRequest, Field(description="A request defining the updated values for the transaction template.")], **kwargs) -> TransactionTemplate:  # noqa: E501
         ...
 
     @overload
-    def update_transaction_template(self, instrument_event_type : Annotated[StrictStr, Field(..., description="The type of instrument events that the template is applied to.")], instrument_type : Annotated[StrictStr, Field(..., description="The instrument type of the transaction template. The combination of the instrument              event type, instrument type and scope uniquely identifies a transaction template")], scope : Annotated[StrictStr, Field(..., description="The scope in which the template lies.")], transaction_template_request : Annotated[TransactionTemplateRequest, Field(..., description="A request defining the updated values for the transaction template.")], async_req: Optional[bool]=True, **kwargs) -> TransactionTemplate:  # noqa: E501
+    def update_transaction_template(self, instrument_event_type : Annotated[StrictStr, Field(..., description="The type of instrument events that the template is applied to.")], instrument_type : Annotated[StrictStr, Field(..., description="The instrument type of the transaction template. The combination of the instrument              event type, instrument type and scope uniquely identifies a transaction template")], scope : Annotated[StrictStr, Field(..., description="The scope in which the template lies.")], transaction_template_request : Annotated[TransactionTemplateRequest, Field(description="A request defining the updated values for the transaction template.")], async_req: Optional[bool]=True, **kwargs) -> TransactionTemplate:  # noqa: E501
         ...
 
     @validate_arguments
-    def update_transaction_template(self, instrument_event_type : Annotated[StrictStr, Field(..., description="The type of instrument events that the template is applied to.")], instrument_type : Annotated[StrictStr, Field(..., description="The instrument type of the transaction template. The combination of the instrument              event type, instrument type and scope uniquely identifies a transaction template")], scope : Annotated[StrictStr, Field(..., description="The scope in which the template lies.")], transaction_template_request : Annotated[TransactionTemplateRequest, Field(..., description="A request defining the updated values for the transaction template.")], async_req: Optional[bool]=None, **kwargs) -> Union[TransactionTemplate, Awaitable[TransactionTemplate]]:  # noqa: E501
+    def update_transaction_template(self, instrument_event_type : Annotated[StrictStr, Field(..., description="The type of instrument events that the template is applied to.")], instrument_type : Annotated[StrictStr, Field(..., description="The instrument type of the transaction template. The combination of the instrument              event type, instrument type and scope uniquely identifies a transaction template")], scope : Annotated[StrictStr, Field(..., description="The scope in which the template lies.")], transaction_template_request : Annotated[TransactionTemplateRequest, Field(description="A request defining the updated values for the transaction template.")], async_req: Optional[bool]=None, **kwargs) -> Union[TransactionTemplate, Awaitable[TransactionTemplate]]:  # noqa: E501
         """UpdateTransactionTemplate: Update Transaction Template  # noqa: E501
 
         Update a transaction template for a particular instrument event type in a scope.  # noqa: E501
@@ -1162,7 +1159,7 @@ class InstrumentEventTypesApi:
         return self.update_transaction_template_with_http_info(instrument_event_type, instrument_type, scope, transaction_template_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def update_transaction_template_with_http_info(self, instrument_event_type : Annotated[StrictStr, Field(..., description="The type of instrument events that the template is applied to.")], instrument_type : Annotated[StrictStr, Field(..., description="The instrument type of the transaction template. The combination of the instrument              event type, instrument type and scope uniquely identifies a transaction template")], scope : Annotated[StrictStr, Field(..., description="The scope in which the template lies.")], transaction_template_request : Annotated[TransactionTemplateRequest, Field(..., description="A request defining the updated values for the transaction template.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def update_transaction_template_with_http_info(self, instrument_event_type : Annotated[StrictStr, Field(..., description="The type of instrument events that the template is applied to.")], instrument_type : Annotated[StrictStr, Field(..., description="The instrument type of the transaction template. The combination of the instrument              event type, instrument type and scope uniquely identifies a transaction template")], scope : Annotated[StrictStr, Field(..., description="The scope in which the template lies.")], transaction_template_request : Annotated[TransactionTemplateRequest, Field(description="A request defining the updated values for the transaction template.")], **kwargs) -> ApiResponse:  # noqa: E501
         """UpdateTransactionTemplate: Update Transaction Template  # noqa: E501
 
         Update a transaction template for a particular instrument event type in a scope.  # noqa: E501

lusid/api/instrument_events_api.py

@@ -19,13 +19,10 @@ import warnings
 from pydantic.v1 import validate_arguments, ValidationError
 from typing import overload, Optional, Union, Awaitable
 
-from typing_extensions import Annotated
 from datetime import datetime
-
-from pydantic.v1 import Field, StrictInt, constr, validator
-
+from pydantic.v1 import Field, StrictInt
 from typing import Optional
-
+from typing_extensions import Annotated
 from lusid.models.bucketed_cash_flow_response import BucketedCashFlowResponse
 from lusid.models.query_applicable_instrument_events_request import QueryApplicableInstrumentEventsRequest
 from lusid.models.query_bucketed_cash_flows_request import QueryBucketedCashFlowsRequest