lusid-sdk 2.1.990__py3-none-any.whl → 2.2.1__py3-none-any.whl

lusid/api/search_api.py

@@ -19,11 +19,9 @@ import warnings
 from pydantic.v1 import validate_arguments, ValidationError
 from typing import overload, Optional, Union, Awaitable
 
-from typing_extensions import Annotated
-from pydantic.v1 import Field, StrictBool, StrictInt, StrictStr, conlist, constr, validator
-
+from pydantic.v1 import Field, StrictBool, StrictInt, StrictStr
 from typing import List, Optional
-
+from typing_extensions import Annotated
 from lusid.models.instrument_match import InstrumentMatch
 from lusid.models.instrument_search_property import InstrumentSearchProperty
 from lusid.models.paged_resource_list_of_portfolio_group_search_result import PagedResourceListOfPortfolioGroupSearchResult
@@ -57,15 +55,15 @@ class SearchApi:
 
 
     @overload
-    async def instruments_search(self, instrument_search_property : Annotated[conlist(InstrumentSearchProperty), Field(..., description="A collection of instrument properties to search for. LUSID will return instruments for any matched              properties.")], mastered_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label to use when searching mastered instruments. This parameter has no effect on instruments that  have not been mastered within LUSID. Defaults to the current LUSID system datetime if not specified.")] = None, mastered_only : Annotated[Optional[StrictBool], Field(description="If set to true, only search over instruments that have been mastered within LUSID. Defaults to false.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies.")] = None, **kwargs) -> List[InstrumentMatch]:  # noqa: E501
+    async def instruments_search(self, instrument_search_property : Annotated[List[InstrumentSearchProperty], Field(description="A collection of instrument properties to search for. LUSID will return instruments for any matched              properties.")], mastered_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label to use when searching mastered instruments. This parameter has no effect on instruments that  have not been mastered within LUSID. Defaults to the current LUSID system datetime if not specified.")] = None, mastered_only : Annotated[Optional[StrictBool], Field(description="If set to true, only search over instruments that have been mastered within LUSID. Defaults to false.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies.")] = None, **kwargs) -> List[InstrumentMatch]:  # noqa: E501
         ...
 
     @overload
-    def instruments_search(self, instrument_search_property : Annotated[conlist(InstrumentSearchProperty), Field(..., description="A collection of instrument properties to search for. LUSID will return instruments for any matched              properties.")], mastered_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label to use when searching mastered instruments. This parameter has no effect on instruments that  have not been mastered within LUSID. Defaults to the current LUSID system datetime if not specified.")] = None, mastered_only : Annotated[Optional[StrictBool], Field(description="If set to true, only search over instruments that have been mastered within LUSID. Defaults to false.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies.")] = None, async_req: Optional[bool]=True, **kwargs) -> List[InstrumentMatch]:  # noqa: E501
+    def instruments_search(self, instrument_search_property : Annotated[List[InstrumentSearchProperty], Field(description="A collection of instrument properties to search for. LUSID will return instruments for any matched              properties.")], mastered_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label to use when searching mastered instruments. This parameter has no effect on instruments that  have not been mastered within LUSID. Defaults to the current LUSID system datetime if not specified.")] = None, mastered_only : Annotated[Optional[StrictBool], Field(description="If set to true, only search over instruments that have been mastered within LUSID. Defaults to false.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies.")] = None, async_req: Optional[bool]=True, **kwargs) -> List[InstrumentMatch]:  # noqa: E501
         ...
 
     @validate_arguments
-    def instruments_search(self, instrument_search_property : Annotated[conlist(InstrumentSearchProperty), Field(..., description="A collection of instrument properties to search for. LUSID will return instruments for any matched              properties.")], mastered_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label to use when searching mastered instruments. This parameter has no effect on instruments that  have not been mastered within LUSID. Defaults to the current LUSID system datetime if not specified.")] = None, mastered_only : Annotated[Optional[StrictBool], Field(description="If set to true, only search over instruments that have been mastered within LUSID. Defaults to false.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[List[InstrumentMatch], Awaitable[List[InstrumentMatch]]]:  # noqa: E501
+    def instruments_search(self, instrument_search_property : Annotated[List[InstrumentSearchProperty], Field(description="A collection of instrument properties to search for. LUSID will return instruments for any matched              properties.")], mastered_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label to use when searching mastered instruments. This parameter has no effect on instruments that  have not been mastered within LUSID. Defaults to the current LUSID system datetime if not specified.")] = None, mastered_only : Annotated[Optional[StrictBool], Field(description="If set to true, only search over instruments that have been mastered within LUSID. Defaults to false.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[List[InstrumentMatch], Awaitable[List[InstrumentMatch]]]:  # noqa: E501
         """[EARLY ACCESS] InstrumentsSearch: Instruments search  # noqa: E501
 
         Search across all instruments that have been mastered in LUSID. Optionally augment the results with instruments from an external symbology service,  currently OpenFIGI.  # noqa: E501
@@ -102,7 +100,7 @@ class SearchApi:
         return self.instruments_search_with_http_info(instrument_search_property, mastered_effective_at, mastered_only, scope, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def instruments_search_with_http_info(self, instrument_search_property : Annotated[conlist(InstrumentSearchProperty), Field(..., description="A collection of instrument properties to search for. LUSID will return instruments for any matched              properties.")], mastered_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label to use when searching mastered instruments. This parameter has no effect on instruments that  have not been mastered within LUSID. Defaults to the current LUSID system datetime if not specified.")] = None, mastered_only : Annotated[Optional[StrictBool], Field(description="If set to true, only search over instruments that have been mastered within LUSID. Defaults to false.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def instruments_search_with_http_info(self, instrument_search_property : Annotated[List[InstrumentSearchProperty], Field(description="A collection of instrument properties to search for. LUSID will return instruments for any matched              properties.")], mastered_effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label to use when searching mastered instruments. This parameter has no effect on instruments that  have not been mastered within LUSID. Defaults to the current LUSID system datetime if not specified.")] = None, mastered_only : Annotated[Optional[StrictBool], Field(description="If set to true, only search over instruments that have been mastered within LUSID. Defaults to false.")] = None, scope : Annotated[Optional[StrictStr], Field( description="The scope in which the instrument lies.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] InstrumentsSearch: Instruments search  # noqa: E501
 
         Search across all instruments that have been mastered in LUSID. Optionally augment the results with instruments from an external symbology service,  currently OpenFIGI.  # noqa: E501

lusid/api/sequences_api.py

@@ -19,11 +19,9 @@ import warnings
 from pydantic.v1 import validate_arguments, ValidationError
 from typing import overload, Optional, Union, Awaitable
 
-from typing_extensions import Annotated
-from pydantic.v1 import Field, conint, constr, validator
-
+from pydantic.v1 import Field, StrictInt
 from typing import Optional
-
+from typing_extensions import Annotated
 from lusid.models.create_sequence_request import CreateSequenceRequest
 from lusid.models.next_value_in_sequence_response import NextValueInSequenceResponse
 from lusid.models.paged_resource_list_of_sequence_definition import PagedResourceListOfSequenceDefinition
@@ -56,15 +54,15 @@ class SequencesApi:
 
 
     @overload
-    async def create_sequence(self, scope : Annotated[StrictStr, Field(..., description="Scope of the sequence.")], create_sequence_request : Annotated[CreateSequenceRequest, Field(..., description="Request to create sequence")], **kwargs) -> SequenceDefinition:  # noqa: E501
+    async def create_sequence(self, scope : Annotated[StrictStr, Field(..., description="Scope of the sequence.")], create_sequence_request : Annotated[CreateSequenceRequest, Field(description="Request to create sequence")], **kwargs) -> SequenceDefinition:  # noqa: E501
         ...
 
     @overload
-    def create_sequence(self, scope : Annotated[StrictStr, Field(..., description="Scope of the sequence.")], create_sequence_request : Annotated[CreateSequenceRequest, Field(..., description="Request to create sequence")], async_req: Optional[bool]=True, **kwargs) -> SequenceDefinition:  # noqa: E501
+    def create_sequence(self, scope : Annotated[StrictStr, Field(..., description="Scope of the sequence.")], create_sequence_request : Annotated[CreateSequenceRequest, Field(description="Request to create sequence")], async_req: Optional[bool]=True, **kwargs) -> SequenceDefinition:  # noqa: E501
         ...
 
     @validate_arguments
-    def create_sequence(self, scope : Annotated[StrictStr, Field(..., description="Scope of the sequence.")], create_sequence_request : Annotated[CreateSequenceRequest, Field(..., description="Request to create sequence")], async_req: Optional[bool]=None, **kwargs) -> Union[SequenceDefinition, Awaitable[SequenceDefinition]]:  # noqa: E501
+    def create_sequence(self, scope : Annotated[StrictStr, Field(..., description="Scope of the sequence.")], create_sequence_request : Annotated[CreateSequenceRequest, Field(description="Request to create sequence")], async_req: Optional[bool]=None, **kwargs) -> Union[SequenceDefinition, Awaitable[SequenceDefinition]]:  # noqa: E501
         """[EARLY ACCESS] CreateSequence: Create a new sequence  # noqa: E501
 
         Create a new sequence  # noqa: E501
@@ -97,7 +95,7 @@ class SequencesApi:
         return self.create_sequence_with_http_info(scope, create_sequence_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def create_sequence_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="Scope of the sequence.")], create_sequence_request : Annotated[CreateSequenceRequest, Field(..., description="Request to create sequence")], **kwargs) -> ApiResponse:  # noqa: E501
+    def create_sequence_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="Scope of the sequence.")], create_sequence_request : Annotated[CreateSequenceRequest, Field(description="Request to create sequence")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] CreateSequence: Create a new sequence  # noqa: E501
 
         Create a new sequence  # noqa: E501
@@ -383,15 +381,15 @@ class SequencesApi:
 
 
     @overload
-    async def list_sequences(self, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing sequences from a previous call to list sequences. This  value is returned from the previous call.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to 500 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> PagedResourceListOfSequenceDefinition:  # noqa: E501
+    async def list_sequences(self, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing sequences from a previous call to list sequences. This  value is returned from the previous call.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 500 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> PagedResourceListOfSequenceDefinition:  # noqa: E501
         ...
 
     @overload
-    def list_sequences(self, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing sequences from a previous call to list sequences. This  value is returned from the previous call.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to 500 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfSequenceDefinition:  # noqa: E501
+    def list_sequences(self, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing sequences from a previous call to list sequences. This  value is returned from the previous call.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 500 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfSequenceDefinition:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_sequences(self, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing sequences from a previous call to list sequences. This  value is returned from the previous call.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to 500 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfSequenceDefinition, Awaitable[PagedResourceListOfSequenceDefinition]]:  # noqa: E501
+    def list_sequences(self, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing sequences from a previous call to list sequences. This  value is returned from the previous call.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 500 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfSequenceDefinition, Awaitable[PagedResourceListOfSequenceDefinition]]:  # noqa: E501
         """[EARLY ACCESS] ListSequences: List Sequences  # noqa: E501
 
         List sequences which satisfies filtering criteria.  # noqa: E501
@@ -426,7 +424,7 @@ class SequencesApi:
         return self.list_sequences_with_http_info(page, limit, filter, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_sequences_with_http_info(self, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing sequences from a previous call to list sequences. This  value is returned from the previous call.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to 500 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_sequences_with_http_info(self, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing sequences from a previous call to list sequences. This  value is returned from the previous call.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 500 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] ListSequences: List Sequences  # noqa: E501
 
         List sequences which satisfies filtering criteria.  # noqa: E501
@@ -551,15 +549,15 @@ class SequencesApi:
 
 
     @overload
-    async def next(self, scope : Annotated[StrictStr, Field(..., description="Scope of the sequence.")], code : Annotated[StrictStr, Field(..., description="Code of the sequence. This together with stated scope uniquely              identifies the sequence.")], batch : Annotated[Optional[conint(strict=True)], Field(description="Number of sequences items to return for the specified sequence. Default to 1 if not specified.")] = None, **kwargs) -> NextValueInSequenceResponse:  # noqa: E501
+    async def next(self, scope : Annotated[StrictStr, Field(..., description="Scope of the sequence.")], code : Annotated[StrictStr, Field(..., description="Code of the sequence. This together with stated scope uniquely              identifies the sequence.")], batch : Annotated[Optional[StrictInt], Field(description="Number of sequences items to return for the specified sequence. Default to 1 if not specified.")] = None, **kwargs) -> NextValueInSequenceResponse:  # noqa: E501
         ...
 
     @overload
-    def next(self, scope : Annotated[StrictStr, Field(..., description="Scope of the sequence.")], code : Annotated[StrictStr, Field(..., description="Code of the sequence. This together with stated scope uniquely              identifies the sequence.")], batch : Annotated[Optional[conint(strict=True)], Field(description="Number of sequences items to return for the specified sequence. Default to 1 if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> NextValueInSequenceResponse:  # noqa: E501
+    def next(self, scope : Annotated[StrictStr, Field(..., description="Scope of the sequence.")], code : Annotated[StrictStr, Field(..., description="Code of the sequence. This together with stated scope uniquely              identifies the sequence.")], batch : Annotated[Optional[StrictInt], Field(description="Number of sequences items to return for the specified sequence. Default to 1 if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> NextValueInSequenceResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def next(self, scope : Annotated[StrictStr, Field(..., description="Scope of the sequence.")], code : Annotated[StrictStr, Field(..., description="Code of the sequence. This together with stated scope uniquely              identifies the sequence.")], batch : Annotated[Optional[conint(strict=True)], Field(description="Number of sequences items to return for the specified sequence. Default to 1 if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[NextValueInSequenceResponse, Awaitable[NextValueInSequenceResponse]]:  # noqa: E501
+    def next(self, scope : Annotated[StrictStr, Field(..., description="Scope of the sequence.")], code : Annotated[StrictStr, Field(..., description="Code of the sequence. This together with stated scope uniquely              identifies the sequence.")], batch : Annotated[Optional[StrictInt], Field(description="Number of sequences items to return for the specified sequence. Default to 1 if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[NextValueInSequenceResponse, Awaitable[NextValueInSequenceResponse]]:  # noqa: E501
         """[EARLY ACCESS] Next: Get next values from sequence  # noqa: E501
 
         Get the next set of values from a specified sequence  # noqa: E501
@@ -594,7 +592,7 @@ class SequencesApi:
         return self.next_with_http_info(scope, code, batch, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def next_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="Scope of the sequence.")], code : Annotated[StrictStr, Field(..., description="Code of the sequence. This together with stated scope uniquely              identifies the sequence.")], batch : Annotated[Optional[conint(strict=True)], Field(description="Number of sequences items to return for the specified sequence. Default to 1 if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def next_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="Scope of the sequence.")], code : Annotated[StrictStr, Field(..., description="Code of the sequence. This together with stated scope uniquely              identifies the sequence.")], batch : Annotated[Optional[StrictInt], Field(description="Number of sequences items to return for the specified sequence. Default to 1 if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] Next: Get next values from sequence  # noqa: E501
 
         Get the next set of values from a specified sequence  # noqa: E501

lusid/api/simple_position_portfolios_api.py

@@ -19,9 +19,8 @@ import warnings
 from pydantic.v1 import validate_arguments, ValidationError
 from typing import overload, Optional, Union, Awaitable
 
+from pydantic.v1 import Field
 from typing_extensions import Annotated
-from pydantic.v1 import Field, constr, validator
-
 from lusid.models.create_simple_position_portfolio_request import CreateSimplePositionPortfolioRequest
 from lusid.models.portfolio import Portfolio
 
@@ -52,15 +51,15 @@ class SimplePositionPortfoliosApi:
 
 
     @overload
-    async def create_simple_position_portfolio(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create the simple position portfolio.")], create_simple_position_portfolio_request : Annotated[CreateSimplePositionPortfolioRequest, Field(..., description="The definition of the simple position portfolio.")], **kwargs) -> Portfolio:  # noqa: E501
+    async def create_simple_position_portfolio(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create the simple position portfolio.")], create_simple_position_portfolio_request : Annotated[CreateSimplePositionPortfolioRequest, Field(description="The definition of the simple position portfolio.")], **kwargs) -> Portfolio:  # noqa: E501
         ...
 
     @overload
-    def create_simple_position_portfolio(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create the simple position portfolio.")], create_simple_position_portfolio_request : Annotated[CreateSimplePositionPortfolioRequest, Field(..., description="The definition of the simple position portfolio.")], async_req: Optional[bool]=True, **kwargs) -> Portfolio:  # noqa: E501
+    def create_simple_position_portfolio(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create the simple position portfolio.")], create_simple_position_portfolio_request : Annotated[CreateSimplePositionPortfolioRequest, Field(description="The definition of the simple position portfolio.")], async_req: Optional[bool]=True, **kwargs) -> Portfolio:  # noqa: E501
         ...
 
     @validate_arguments
-    def create_simple_position_portfolio(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create the simple position portfolio.")], create_simple_position_portfolio_request : Annotated[CreateSimplePositionPortfolioRequest, Field(..., description="The definition of the simple position portfolio.")], async_req: Optional[bool]=None, **kwargs) -> Union[Portfolio, Awaitable[Portfolio]]:  # noqa: E501
+    def create_simple_position_portfolio(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create the simple position portfolio.")], create_simple_position_portfolio_request : Annotated[CreateSimplePositionPortfolioRequest, Field(description="The definition of the simple position portfolio.")], async_req: Optional[bool]=None, **kwargs) -> Union[Portfolio, Awaitable[Portfolio]]:  # noqa: E501
         """[EARLY ACCESS] CreateSimplePositionPortfolio: Create simple position portfolio  # noqa: E501
 
         Create a simple position portfolio in a particular scope.  # noqa: E501
@@ -93,7 +92,7 @@ class SimplePositionPortfoliosApi:
         return self.create_simple_position_portfolio_with_http_info(scope, create_simple_position_portfolio_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def create_simple_position_portfolio_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create the simple position portfolio.")], create_simple_position_portfolio_request : Annotated[CreateSimplePositionPortfolioRequest, Field(..., description="The definition of the simple position portfolio.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def create_simple_position_portfolio_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to create the simple position portfolio.")], create_simple_position_portfolio_request : Annotated[CreateSimplePositionPortfolioRequest, Field(description="The definition of the simple position portfolio.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] CreateSimplePositionPortfolio: Create simple position portfolio  # noqa: E501
 
         Create a simple position portfolio in a particular scope.  # noqa: E501

lusid/api/staged_modifications_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_staged_modification import PagedResourceListOfStagedModification
 from lusid.models.paged_resource_list_of_staged_modifications_requested_change_interval import PagedResourceListOfStagedModificationsRequestedChangeInterval
 from lusid.models.staged_modification import StagedModification
@@ -58,15 +55,15 @@ class StagedModificationsApi:
 
 
     @overload
-    async def add_decision(self, id : Annotated[StrictStr, Field(..., description="Unique Id for a staged modification..")], staged_modification_decision_request : Annotated[StagedModificationDecisionRequest, Field(..., description="The decision on the requested staged modification, \"Approve\" or \"Reject\".")], **kwargs) -> StagedModification:  # noqa: E501
+    async def add_decision(self, id : Annotated[StrictStr, Field(..., description="Unique Id for a staged modification..")], staged_modification_decision_request : Annotated[StagedModificationDecisionRequest, Field(description="The decision on the requested staged modification, \"Approve\" or \"Reject\".")], **kwargs) -> StagedModification:  # noqa: E501
         ...
 
     @overload
-    def add_decision(self, id : Annotated[StrictStr, Field(..., description="Unique Id for a staged modification..")], staged_modification_decision_request : Annotated[StagedModificationDecisionRequest, Field(..., description="The decision on the requested staged modification, \"Approve\" or \"Reject\".")], async_req: Optional[bool]=True, **kwargs) -> StagedModification:  # noqa: E501
+    def add_decision(self, id : Annotated[StrictStr, Field(..., description="Unique Id for a staged modification..")], staged_modification_decision_request : Annotated[StagedModificationDecisionRequest, Field(description="The decision on the requested staged modification, \"Approve\" or \"Reject\".")], async_req: Optional[bool]=True, **kwargs) -> StagedModification:  # noqa: E501
         ...
 
     @validate_arguments
-    def add_decision(self, id : Annotated[StrictStr, Field(..., description="Unique Id for a staged modification..")], staged_modification_decision_request : Annotated[StagedModificationDecisionRequest, Field(..., description="The decision on the requested staged modification, \"Approve\" or \"Reject\".")], async_req: Optional[bool]=None, **kwargs) -> Union[StagedModification, Awaitable[StagedModification]]:  # noqa: E501
+    def add_decision(self, id : Annotated[StrictStr, Field(..., description="Unique Id for a staged modification..")], staged_modification_decision_request : Annotated[StagedModificationDecisionRequest, Field(description="The decision on the requested staged modification, \"Approve\" or \"Reject\".")], async_req: Optional[bool]=None, **kwargs) -> Union[StagedModification, Awaitable[StagedModification]]:  # noqa: E501
         """AddDecision: AddDecision  # noqa: E501
 
         Add decision to staged modification, Approve or Reject.  # noqa: E501
@@ -99,7 +96,7 @@ class StagedModificationsApi:
         return self.add_decision_with_http_info(id, staged_modification_decision_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def add_decision_with_http_info(self, id : Annotated[StrictStr, Field(..., description="Unique Id for a staged modification..")], staged_modification_decision_request : Annotated[StagedModificationDecisionRequest, Field(..., description="The decision on the requested staged modification, \"Approve\" or \"Reject\".")], **kwargs) -> ApiResponse:  # noqa: E501
+    def add_decision_with_http_info(self, id : Annotated[StrictStr, Field(..., description="Unique Id for a staged modification..")], staged_modification_decision_request : Annotated[StagedModificationDecisionRequest, Field(description="The decision on the requested staged modification, \"Approve\" or \"Reject\".")], **kwargs) -> ApiResponse:  # noqa: E501
         """AddDecision: AddDecision  # noqa: E501
 
         Add decision to staged modification, Approve or Reject.  # noqa: E501
@@ -388,15 +385,15 @@ class StagedModificationsApi:
 
 
     @overload
-    async def list_requested_changes(self, id : Annotated[StrictStr, Field(..., description="Unique Id for a staged modification..")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list changes. Defaults to return the latest version              of each staged change if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing requested staged modification changes from a previous call to list requested              staged modifications. This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names suffixed by \" ASC\" or \" DESC\"")] = None, **kwargs) -> PagedResourceListOfStagedModificationsRequestedChangeInterval:  # noqa: E501
+    async def list_requested_changes(self, id : Annotated[StrictStr, Field(..., description="Unique Id for a staged modification..")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list changes. Defaults to return the latest version              of each staged change if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing requested staged modification changes from a previous call to list requested              staged modifications. This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names suffixed by \" ASC\" or \" DESC\"")] = None, **kwargs) -> PagedResourceListOfStagedModificationsRequestedChangeInterval:  # noqa: E501
         ...
 
     @overload
-    def list_requested_changes(self, id : Annotated[StrictStr, Field(..., description="Unique Id for a staged modification..")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list changes. Defaults to return the latest version              of each staged change if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing requested staged modification changes from a previous call to list requested              staged modifications. This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names suffixed by \" ASC\" or \" DESC\"")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfStagedModificationsRequestedChangeInterval:  # noqa: E501
+    def list_requested_changes(self, id : Annotated[StrictStr, Field(..., description="Unique Id for a staged modification..")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list changes. Defaults to return the latest version              of each staged change if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing requested staged modification changes from a previous call to list requested              staged modifications. This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names suffixed by \" ASC\" or \" DESC\"")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfStagedModificationsRequestedChangeInterval:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_requested_changes(self, id : Annotated[StrictStr, Field(..., description="Unique Id for a staged modification..")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list changes. Defaults to return the latest version              of each staged change if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing requested staged modification changes from a previous call to list requested              staged modifications. This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names suffixed by \" ASC\" or \" DESC\"")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfStagedModificationsRequestedChangeInterval, Awaitable[PagedResourceListOfStagedModificationsRequestedChangeInterval]]:  # noqa: E501
+    def list_requested_changes(self, id : Annotated[StrictStr, Field(..., description="Unique Id for a staged modification..")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list changes. Defaults to return the latest version              of each staged change if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing requested staged modification changes from a previous call to list requested              staged modifications. This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names suffixed by \" ASC\" or \" DESC\"")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfStagedModificationsRequestedChangeInterval, Awaitable[PagedResourceListOfStagedModificationsRequestedChangeInterval]]:  # noqa: E501
         """ListRequestedChanges: ListRequestedChanges  # noqa: E501
 
         List the requested changes for a staged modification.  # noqa: E501
@@ -437,7 +434,7 @@ class StagedModificationsApi:
         return self.list_requested_changes_with_http_info(id, as_at, page, limit, filter, sort_by, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_requested_changes_with_http_info(self, id : Annotated[StrictStr, Field(..., description="Unique Id for a staged modification..")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list changes. Defaults to return the latest version              of each staged change if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing requested staged modification changes from a previous call to list requested              staged modifications. This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names suffixed by \" ASC\" or \" DESC\"")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_requested_changes_with_http_info(self, id : Annotated[StrictStr, Field(..., description="Unique Id for a staged modification..")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list changes. Defaults to return the latest version              of each staged change if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing requested staged modification changes from a previous call to list requested              staged modifications. This value is returned from the previous call. If a pagination token is provided the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names suffixed by \" ASC\" or \" DESC\"")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """ListRequestedChanges: ListRequestedChanges  # noqa: E501
 
         List the requested changes for a staged modification.  # noqa: E501
@@ -584,15 +581,15 @@ class StagedModificationsApi:
 
 
     @overload
-    async def list_staged_modifications(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list staged modifications. Defaults to return the latest version              of each staged modification if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing staged modifications from a previous call to list staged modifications. This              value is returned from the previous call. If a pagination token is provided the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names suffixed by \" ASC\" or \" DESC\"")] = None, **kwargs) -> PagedResourceListOfStagedModification:  # noqa: E501
+    async def list_staged_modifications(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list staged modifications. Defaults to return the latest version              of each staged modification if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing staged modifications from a previous call to list staged modifications. This              value is returned from the previous call. If a pagination token is provided the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names suffixed by \" ASC\" or \" DESC\"")] = None, **kwargs) -> PagedResourceListOfStagedModification:  # noqa: E501
         ...
 
     @overload
-    def list_staged_modifications(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list staged modifications. Defaults to return the latest version              of each staged modification if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing staged modifications from a previous call to list staged modifications. This              value is returned from the previous call. If a pagination token is provided the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names suffixed by \" ASC\" or \" DESC\"")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfStagedModification:  # noqa: E501
+    def list_staged_modifications(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list staged modifications. Defaults to return the latest version              of each staged modification if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing staged modifications from a previous call to list staged modifications. This              value is returned from the previous call. If a pagination token is provided the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names suffixed by \" ASC\" or \" DESC\"")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfStagedModification:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_staged_modifications(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list staged modifications. Defaults to return the latest version              of each staged modification if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing staged modifications from a previous call to list staged modifications. This              value is returned from the previous call. If a pagination token is provided the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names suffixed by \" ASC\" or \" DESC\"")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfStagedModification, Awaitable[PagedResourceListOfStagedModification]]:  # noqa: E501
+    def list_staged_modifications(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list staged modifications. Defaults to return the latest version              of each staged modification if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing staged modifications from a previous call to list staged modifications. This              value is returned from the previous call. If a pagination token is provided the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names suffixed by \" ASC\" or \" DESC\"")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfStagedModification, Awaitable[PagedResourceListOfStagedModification]]:  # noqa: E501
         """ListStagedModifications: ListStagedModifications  # noqa: E501
 
         List summaries of the staged modifications.  # noqa: E501
@@ -631,7 +628,7 @@ class StagedModificationsApi:
         return self.list_staged_modifications_with_http_info(as_at, page, limit, filter, sort_by, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_staged_modifications_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list staged modifications. Defaults to return the latest version              of each staged modification if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing staged modifications from a previous call to list staged modifications. This              value is returned from the previous call. If a pagination token is provided the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names suffixed by \" ASC\" or \" DESC\"")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_staged_modifications_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list staged modifications. Defaults to return the latest version              of each staged modification if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing staged modifications from a previous call to list staged modifications. This              value is returned from the previous call. If a pagination token is provided the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names suffixed by \" ASC\" or \" DESC\"")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """ListStagedModifications: ListStagedModifications  # noqa: E501
 
         List summaries of the staged modifications.  # noqa: E501

lusid/api/staging_rule_set_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_staging_rule_set_request import CreateStagingRuleSetRequest
 from lusid.models.deleted_entity_response import DeletedEntityResponse
 from lusid.models.paged_resource_list_of_staging_rule_set import PagedResourceListOfStagingRuleSet
@@ -59,15 +56,15 @@ class StagingRuleSetApi:
 
 
     @overload
-    async def create_staging_rule_set(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type for which to create the staging rule set.")], create_staging_rule_set_request : Annotated[CreateStagingRuleSetRequest, Field(..., description="Request to create a staging rule set.")], **kwargs) -> StagingRuleSet:  # noqa: E501
+    async def create_staging_rule_set(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type for which to create the staging rule set.")], create_staging_rule_set_request : Annotated[CreateStagingRuleSetRequest, Field(description="Request to create a staging rule set.")], **kwargs) -> StagingRuleSet:  # noqa: E501
         ...
 
     @overload
-    def create_staging_rule_set(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type for which to create the staging rule set.")], create_staging_rule_set_request : Annotated[CreateStagingRuleSetRequest, Field(..., description="Request to create a staging rule set.")], async_req: Optional[bool]=True, **kwargs) -> StagingRuleSet:  # noqa: E501
+    def create_staging_rule_set(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type for which to create the staging rule set.")], create_staging_rule_set_request : Annotated[CreateStagingRuleSetRequest, Field(description="Request to create a staging rule set.")], async_req: Optional[bool]=True, **kwargs) -> StagingRuleSet:  # noqa: E501
         ...
 
     @validate_arguments
-    def create_staging_rule_set(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type for which to create the staging rule set.")], create_staging_rule_set_request : Annotated[CreateStagingRuleSetRequest, Field(..., description="Request to create a staging rule set.")], async_req: Optional[bool]=None, **kwargs) -> Union[StagingRuleSet, Awaitable[StagingRuleSet]]:  # noqa: E501
+    def create_staging_rule_set(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type for which to create the staging rule set.")], create_staging_rule_set_request : Annotated[CreateStagingRuleSetRequest, Field(description="Request to create a staging rule set.")], async_req: Optional[bool]=None, **kwargs) -> Union[StagingRuleSet, Awaitable[StagingRuleSet]]:  # noqa: E501
         """CreateStagingRuleSet: Create a StagingRuleSet  # noqa: E501
 
         Create a new staging rule set.  # noqa: E501
@@ -100,7 +97,7 @@ class StagingRuleSetApi:
         return self.create_staging_rule_set_with_http_info(entity_type, create_staging_rule_set_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def create_staging_rule_set_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type for which to create the staging rule set.")], create_staging_rule_set_request : Annotated[CreateStagingRuleSetRequest, Field(..., description="Request to create a staging rule set.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def create_staging_rule_set_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type for which to create the staging rule set.")], create_staging_rule_set_request : Annotated[CreateStagingRuleSetRequest, Field(description="Request to create a staging rule set.")], **kwargs) -> ApiResponse:  # noqa: E501
         """CreateStagingRuleSet: Create a StagingRuleSet  # noqa: E501
 
         Create a new staging rule set.  # noqa: E501
@@ -541,15 +538,15 @@ class StagingRuleSetApi:
 
 
     @overload
-    async def list_staging_rule_sets(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the staging rule sets. Defaults to return the latest              version of the staging rule sets if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing staging rule sets from a previous call to list              staging rule sets. 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.")] = 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) -> PagedResourceListOfStagingRuleSet:  # noqa: E501
+    async def list_staging_rule_sets(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the staging rule sets. Defaults to return the latest              version of the staging rule sets if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing staging rule sets from a previous call to list              staging rule sets. 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.")] = 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) -> PagedResourceListOfStagingRuleSet:  # noqa: E501
         ...
 
     @overload
-    def list_staging_rule_sets(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the staging rule sets. Defaults to return the latest              version of the staging rule sets if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing staging rule sets from a previous call to list              staging rule sets. 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.")] = 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) -> PagedResourceListOfStagingRuleSet:  # noqa: E501
+    def list_staging_rule_sets(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the staging rule sets. Defaults to return the latest              version of the staging rule sets if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing staging rule sets from a previous call to list              staging rule sets. 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.")] = 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) -> PagedResourceListOfStagingRuleSet:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_staging_rule_sets(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the staging rule sets. Defaults to return the latest              version of the staging rule sets if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing staging rule sets from a previous call to list              staging rule sets. 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.")] = 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[PagedResourceListOfStagingRuleSet, Awaitable[PagedResourceListOfStagingRuleSet]]:  # noqa: E501
+    def list_staging_rule_sets(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the staging rule sets. Defaults to return the latest              version of the staging rule sets if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing staging rule sets from a previous call to list              staging rule sets. 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.")] = 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[PagedResourceListOfStagingRuleSet, Awaitable[PagedResourceListOfStagingRuleSet]]:  # noqa: E501
         """ListStagingRuleSets: List StagingRuleSets  # noqa: E501
 
         List all the staging rule sets matching particular criteria.  # noqa: E501
@@ -588,7 +585,7 @@ class StagingRuleSetApi:
         return self.list_staging_rule_sets_with_http_info(as_at, page, sort_by, limit, filter, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_staging_rule_sets_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the staging rule sets. Defaults to return the latest              version of the staging rule sets if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing staging rule sets from a previous call to list              staging rule sets. 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.")] = 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_staging_rule_sets_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the staging rule sets. Defaults to return the latest              version of the staging rule sets if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing staging rule sets from a previous call to list              staging rule sets. 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.")] = 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
         """ListStagingRuleSets: List StagingRuleSets  # noqa: E501
 
         List all the staging rule sets matching particular criteria.  # noqa: E501
@@ -729,15 +726,15 @@ class StagingRuleSetApi:
 
 
     @overload
-    async def update_staging_rule_set(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type for which to update the staging rule set.")], update_staging_rule_set_request : Annotated[UpdateStagingRuleSetRequest, Field(..., description="Request to update a staging rule set.")], **kwargs) -> StagingRuleSet:  # noqa: E501
+    async def update_staging_rule_set(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type for which to update the staging rule set.")], update_staging_rule_set_request : Annotated[UpdateStagingRuleSetRequest, Field(description="Request to update a staging rule set.")], **kwargs) -> StagingRuleSet:  # noqa: E501
         ...
 
     @overload
-    def update_staging_rule_set(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type for which to update the staging rule set.")], update_staging_rule_set_request : Annotated[UpdateStagingRuleSetRequest, Field(..., description="Request to update a staging rule set.")], async_req: Optional[bool]=True, **kwargs) -> StagingRuleSet:  # noqa: E501
+    def update_staging_rule_set(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type for which to update the staging rule set.")], update_staging_rule_set_request : Annotated[UpdateStagingRuleSetRequest, Field(description="Request to update a staging rule set.")], async_req: Optional[bool]=True, **kwargs) -> StagingRuleSet:  # noqa: E501
         ...
 
     @validate_arguments
-    def update_staging_rule_set(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type for which to update the staging rule set.")], update_staging_rule_set_request : Annotated[UpdateStagingRuleSetRequest, Field(..., description="Request to update a staging rule set.")], async_req: Optional[bool]=None, **kwargs) -> Union[StagingRuleSet, Awaitable[StagingRuleSet]]:  # noqa: E501
+    def update_staging_rule_set(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type for which to update the staging rule set.")], update_staging_rule_set_request : Annotated[UpdateStagingRuleSetRequest, Field(description="Request to update a staging rule set.")], async_req: Optional[bool]=None, **kwargs) -> Union[StagingRuleSet, Awaitable[StagingRuleSet]]:  # noqa: E501
         """UpdateStagingRuleSet: Update a StagingRuleSet  # noqa: E501
 
         Update an existing staging rule set.  # noqa: E501
@@ -770,7 +767,7 @@ class StagingRuleSetApi:
         return self.update_staging_rule_set_with_http_info(entity_type, update_staging_rule_set_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def update_staging_rule_set_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type for which to update the staging rule set.")], update_staging_rule_set_request : Annotated[UpdateStagingRuleSetRequest, Field(..., description="Request to update a staging rule set.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def update_staging_rule_set_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type for which to update the staging rule set.")], update_staging_rule_set_request : Annotated[UpdateStagingRuleSetRequest, Field(description="Request to update a staging rule set.")], **kwargs) -> ApiResponse:  # noqa: E501
         """UpdateStagingRuleSet: Update a StagingRuleSet  # noqa: E501
 
         Update an existing staging rule set.  # noqa: E501