lusid-sdk 2.1.729__py3-none-any.whl → 2.1.730__py3-none-any.whl

lusid/api/scopes_api.py

@@ -55,15 +55,15 @@ class ScopesApi:
 
 
     @overload
-    async def list_entity_scopes(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type to list scopes for.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve scopes. Defaults to latest datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing scopes from a previous call to list scopes.              This value is returned from the previous call. If a pagination token is provided, the limit and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="When paginating, limit the number of returned results to this number. Defaults to 100 if not specified.")] = None, **kwargs) -> ResourceListOfScopeDefinition:  # noqa: E501
+    async def list_entity_scopes(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type to list scopes for.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve scopes. Defaults to latest datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing scopes from a previous call to list scopes.              This value is returned from the previous call. If a pagination token is provided, the 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 number. Defaults to 100 if not specified.")] = None, **kwargs) -> ResourceListOfScopeDefinition:  # noqa: E501
         ...
 
     @overload
-    def list_entity_scopes(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type to list scopes for.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve scopes. Defaults to latest datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing scopes from a previous call to list scopes.              This value is returned from the previous call. If a pagination token is provided, the limit and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="When paginating, limit the number of returned results to this number. Defaults to 100 if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfScopeDefinition:  # noqa: E501
+    def list_entity_scopes(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type to list scopes for.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve scopes. Defaults to latest datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing scopes from a previous call to list scopes.              This value is returned from the previous call. If a pagination token is provided, the 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 number. Defaults to 100 if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfScopeDefinition:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_entity_scopes(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type to list scopes for.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve scopes. Defaults to latest datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing scopes from a previous call to list scopes.              This value is returned from the previous call. If a pagination token is provided, the limit and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="When paginating, limit the number of returned results to this number. Defaults to 100 if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfScopeDefinition, Awaitable[ResourceListOfScopeDefinition]]:  # noqa: E501
+    def list_entity_scopes(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type to list scopes for.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve scopes. Defaults to latest datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing scopes from a previous call to list scopes.              This value is returned from the previous call. If a pagination token is provided, the 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 number. Defaults to 100 if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfScopeDefinition, Awaitable[ResourceListOfScopeDefinition]]:  # noqa: E501
         """ListEntityScopes: List Entity Scopes  # noqa: E501
 
         List all the scopes for a given entity type that contain data.  # noqa: E501
@@ -100,7 +100,7 @@ class ScopesApi:
         return self.list_entity_scopes_with_http_info(entity_type, as_at, page, limit, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_entity_scopes_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type to list scopes for.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve scopes. Defaults to latest datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing scopes from a previous call to list scopes.              This value is returned from the previous call. If a pagination token is provided, the limit and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="When paginating, limit the number of returned results to this number. Defaults to 100 if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_entity_scopes_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The entity type to list scopes for.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve scopes. Defaults to latest datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing scopes from a previous call to list scopes.              This value is returned from the previous call. If a pagination token is provided, the 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 number. Defaults to 100 if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """ListEntityScopes: List Entity Scopes  # noqa: E501
 
         List all the scopes for a given entity type that contain data.  # noqa: E501

lusid/api/scripted_translation_api.py

@@ -445,15 +445,15 @@ class ScriptedTranslationApi:
 
 
     @overload
-    async def list_dialect_ids(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the dialects.              Defaults to return the latest version of the dialect if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing dialect IDs from a previous call to list dialect IDs.              This value is returned from the previous call. If a pagination token is provided the filter and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True, le=100, ge=1)], 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) -> PagedResourceListOfDialectId:  # noqa: E501
+    async def list_dialect_ids(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the dialects.              Defaults to return the latest version of the dialect if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing dialect IDs from a previous call to list dialect IDs.              This value is returned from the previous call. If a pagination token is provided the 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, **kwargs) -> PagedResourceListOfDialectId:  # noqa: E501
         ...
 
     @overload
-    def list_dialect_ids(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the dialects.              Defaults to return the latest version of the dialect if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing dialect IDs from a previous call to list dialect IDs.              This value is returned from the previous call. If a pagination token is provided the filter and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True, le=100, ge=1)], 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) -> PagedResourceListOfDialectId:  # noqa: E501
+    def list_dialect_ids(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the dialects.              Defaults to return the latest version of the dialect if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing dialect IDs from a previous call to list dialect IDs.              This value is returned from the previous call. If a pagination token is provided the 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, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfDialectId:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_dialect_ids(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the dialects.              Defaults to return the latest version of the dialect if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing dialect IDs from a previous call to list dialect IDs.              This value is returned from the previous call. If a pagination token is provided the filter and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True, le=100, ge=1)], 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[PagedResourceListOfDialectId, Awaitable[PagedResourceListOfDialectId]]:  # noqa: E501
+    def list_dialect_ids(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the dialects.              Defaults to return the latest version of the dialect if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing dialect IDs from a previous call to list dialect IDs.              This value is returned from the previous call. If a pagination token is provided the 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, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfDialectId, Awaitable[PagedResourceListOfDialectId]]:  # noqa: E501
         """[EARLY ACCESS] ListDialectIds: List dialect identifiers matching an optional filter.  # noqa: E501
 
         List the stored dialects' identifiers with pagination and filtering at the specified asAt time.  # noqa: E501
@@ -490,7 +490,7 @@ class ScriptedTranslationApi:
         return self.list_dialect_ids_with_http_info(as_at, page, limit, filter, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_dialect_ids_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the dialects.              Defaults to return the latest version of the dialect if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing dialect IDs from a previous call to list dialect IDs.              This value is returned from the previous call. If a pagination token is provided the filter and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True, le=100, ge=1)], 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_dialect_ids_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the dialects.              Defaults to return the latest version of the dialect if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing dialect IDs from a previous call to list dialect IDs.              This value is returned from the previous call. If a pagination token is provided the 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, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] ListDialectIds: List dialect identifiers matching an optional filter.  # noqa: E501
 
         List the stored dialects' identifiers with pagination and filtering at the specified asAt time.  # noqa: E501
@@ -624,15 +624,15 @@ class ScriptedTranslationApi:
 
 
     @overload
-    async def list_translation_script_ids(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the script identifiers. Defaults to latest.")] = None, limit : Annotated[Optional[conint(strict=True, le=100, ge=1)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results. For example, Id.Version.Major eq 1 to list IDs with major version 1              or Id.Scope eq 'my-scripts' to list result only for a particular scope.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing translation script IDs; this              value is returned from the previous call. If a pagination token is provided, the filter field              must not have changed since the original request.")] = None, **kwargs) -> PagedResourceListOfTranslationScriptId:  # noqa: E501
+    async def list_translation_script_ids(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the script identifiers. Defaults to latest.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results. For example, Id.Version.Major eq 1 to list IDs with major version 1              or Id.Scope eq 'my-scripts' to list result only for a particular scope.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing translation script IDs; this              value is returned from the previous call. If a pagination token is provided, the filter field              must not have changed since the original request.")] = None, **kwargs) -> PagedResourceListOfTranslationScriptId:  # noqa: E501
         ...
 
     @overload
-    def list_translation_script_ids(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the script identifiers. Defaults to latest.")] = None, limit : Annotated[Optional[conint(strict=True, le=100, ge=1)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results. For example, Id.Version.Major eq 1 to list IDs with major version 1              or Id.Scope eq 'my-scripts' to list result only for a particular scope.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing translation script IDs; this              value is returned from the previous call. If a pagination token is provided, the filter field              must not have changed since the original request.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfTranslationScriptId:  # noqa: E501
+    def list_translation_script_ids(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the script identifiers. Defaults to latest.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results. For example, Id.Version.Major eq 1 to list IDs with major version 1              or Id.Scope eq 'my-scripts' to list result only for a particular scope.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing translation script IDs; this              value is returned from the previous call. If a pagination token is provided, the filter field              must not have changed since the original request.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfTranslationScriptId:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_translation_script_ids(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the script identifiers. Defaults to latest.")] = None, limit : Annotated[Optional[conint(strict=True, le=100, ge=1)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results. For example, Id.Version.Major eq 1 to list IDs with major version 1              or Id.Scope eq 'my-scripts' to list result only for a particular scope.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing translation script IDs; this              value is returned from the previous call. If a pagination token is provided, the filter field              must not have changed since the original request.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfTranslationScriptId, Awaitable[PagedResourceListOfTranslationScriptId]]:  # noqa: E501
+    def list_translation_script_ids(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the script identifiers. Defaults to latest.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results. For example, Id.Version.Major eq 1 to list IDs with major version 1              or Id.Scope eq 'my-scripts' to list result only for a particular scope.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing translation script IDs; this              value is returned from the previous call. If a pagination token is provided, the filter field              must not have changed since the original request.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfTranslationScriptId, Awaitable[PagedResourceListOfTranslationScriptId]]:  # noqa: E501
         """[EARLY ACCESS] ListTranslationScriptIds: List translation script identifiers.  # noqa: E501
 
         List translation script ids.  # noqa: E501
@@ -669,7 +669,7 @@ class ScriptedTranslationApi:
         return self.list_translation_script_ids_with_http_info(as_at, limit, filter, page, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_translation_script_ids_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the script identifiers. Defaults to latest.")] = None, limit : Annotated[Optional[conint(strict=True, le=100, ge=1)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results. For example, Id.Version.Major eq 1 to list IDs with major version 1              or Id.Scope eq 'my-scripts' to list result only for a particular scope.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing translation script IDs; this              value is returned from the previous call. If a pagination token is provided, the filter field              must not have changed since the original request.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_translation_script_ids_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the script identifiers. Defaults to latest.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results. For example, Id.Version.Major eq 1 to list IDs with major version 1              or Id.Scope eq 'my-scripts' to list result only for a particular scope.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing translation script IDs; this              value is returned from the previous call. If a pagination token is provided, the filter field              must not have changed since the original request.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] ListTranslationScriptIds: List translation script identifiers.  # noqa: E501
 
         List translation script ids.  # noqa: E501

lusid/api/sequences_api.py

@@ -383,15 +383,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, le=5000, ge=1)], 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[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
         ...
 
     @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, le=5000, ge=1)], 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[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
         ...
 
     @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, le=5000, ge=1)], 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[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
         """[EARLY ACCESS] ListSequences: List Sequences  # noqa: E501
 
         List sequences which satisfies filtering criteria.  # noqa: E501
@@ -426,7 +426,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, le=5000, ge=1)], 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[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
         """[EARLY ACCESS] ListSequences: List Sequences  # noqa: E501
 
         List sequences which satisfies filtering criteria.  # noqa: E501
@@ -551,15 +551,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, le=5000, ge=1)], 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[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
         ...
 
     @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, le=5000, ge=1)], 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[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
         ...
 
     @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, le=5000, ge=1)], 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[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
         """[EARLY ACCESS] Next: Get next values from sequence  # noqa: E501
 
         Get the next set of values from a specified sequence  # noqa: E501
@@ -594,7 +594,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, le=5000, ge=1)], 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[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
         """[EARLY ACCESS] Next: Get next values from sequence  # noqa: E501
 
         Get the next set of values from a specified sequence  # noqa: E501

lusid/api/staged_modifications_api.py

@@ -388,15 +388,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, le=5000, ge=1)], 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[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
         ...
 
     @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, le=5000, ge=1)], 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[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
         ...
 
     @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, le=5000, ge=1)], 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[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
         """[EXPERIMENTAL] ListRequestedChanges: ListRequestedChanges  # noqa: E501
 
         List the requested changes for a staged modification.  # noqa: E501
@@ -437,7 +437,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, le=5000, ge=1)], 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[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
         """[EXPERIMENTAL] ListRequestedChanges: ListRequestedChanges  # noqa: E501
 
         List the requested changes for a staged modification.  # noqa: E501
@@ -584,15 +584,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, le=5000, ge=1)], 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[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
         ...
 
     @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, le=5000, ge=1)], 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[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
         ...
 
     @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, le=5000, ge=1)], 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[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
         """[EXPERIMENTAL] ListStagedModifications: ListStagedModifications  # noqa: E501
 
         List summaries of the staged modifications.  # noqa: E501
@@ -631,7 +631,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, le=5000, ge=1)], 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[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
         """[EXPERIMENTAL] ListStagedModifications: ListStagedModifications  # noqa: E501
 
         List summaries of the staged modifications.  # noqa: E501

lusid/api/staging_rule_set_api.py

@@ -541,15 +541,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, le=5000, ge=1)], 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[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
         ...
 
     @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, le=5000, ge=1)], 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[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
         ...
 
     @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, le=5000, ge=1)], 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[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
         """[EXPERIMENTAL] ListStagingRuleSets: List StagingRuleSets  # noqa: E501
 
         List all the staging rule sets matching particular criteria.  # noqa: E501
@@ -588,7 +588,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, le=5000, ge=1)], 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[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
         """[EXPERIMENTAL] ListStagingRuleSets: List StagingRuleSets  # noqa: E501
 
         List all the staging rule sets matching particular criteria.  # noqa: E501

lusid/api/structured_result_data_api.py

@@ -1126,15 +1126,15 @@ class StructuredResultDataApi:
 
 
     @overload
-    async def get_virtual_document_rows(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[StrictStr, Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[StrictStr, Field(..., description="The source of the virtual document to retrieve.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the virtual document to retrieve.")], effective_at : Annotated[StrictStr, Field(..., description="The effectiveAt datetime at which to retrieve the virtual document.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the virtual document. Defaults to returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing virtual document rows from a previous               call to list virtual document rows. 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, le=5000, ge=1)], 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) -> PagedResourceListOfVirtualRow:  # noqa: E501
+    async def get_virtual_document_rows(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[StrictStr, Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[StrictStr, Field(..., description="The source of the virtual document to retrieve.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the virtual document to retrieve.")], effective_at : Annotated[StrictStr, Field(..., description="The effectiveAt datetime at which to retrieve the virtual document.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the virtual document. Defaults to returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing virtual document rows from a previous               call to list virtual document rows. This value is returned from the previous call. If a pagination token is               provided the filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, 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) -> PagedResourceListOfVirtualRow:  # noqa: E501
         ...
 
     @overload
-    def get_virtual_document_rows(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[StrictStr, Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[StrictStr, Field(..., description="The source of the virtual document to retrieve.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the virtual document to retrieve.")], effective_at : Annotated[StrictStr, Field(..., description="The effectiveAt datetime at which to retrieve the virtual document.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the virtual document. Defaults to returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing virtual document rows from a previous               call to list virtual document rows. 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, le=5000, ge=1)], 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) -> PagedResourceListOfVirtualRow:  # noqa: E501
+    def get_virtual_document_rows(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[StrictStr, Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[StrictStr, Field(..., description="The source of the virtual document to retrieve.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the virtual document to retrieve.")], effective_at : Annotated[StrictStr, Field(..., description="The effectiveAt datetime at which to retrieve the virtual document.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the virtual document. Defaults to returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing virtual document rows from a previous               call to list virtual document rows. This value is returned from the previous call. If a pagination token is               provided the filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, 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) -> PagedResourceListOfVirtualRow:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_virtual_document_rows(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[StrictStr, Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[StrictStr, Field(..., description="The source of the virtual document to retrieve.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the virtual document to retrieve.")], effective_at : Annotated[StrictStr, Field(..., description="The effectiveAt datetime at which to retrieve the virtual document.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the virtual document. Defaults to returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing virtual document rows from a previous               call to list virtual document rows. 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, le=5000, ge=1)], 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[PagedResourceListOfVirtualRow, Awaitable[PagedResourceListOfVirtualRow]]:  # noqa: E501
+    def get_virtual_document_rows(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[StrictStr, Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[StrictStr, Field(..., description="The source of the virtual document to retrieve.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the virtual document to retrieve.")], effective_at : Annotated[StrictStr, Field(..., description="The effectiveAt datetime at which to retrieve the virtual document.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the virtual document. Defaults to returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing virtual document rows from a previous               call to list virtual document rows. This value is returned from the previous call. If a pagination token is               provided the filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, 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[PagedResourceListOfVirtualRow, Awaitable[PagedResourceListOfVirtualRow]]:  # noqa: E501
         """[EARLY ACCESS] GetVirtualDocumentRows: Get Virtual Document Rows  # noqa: E501
 
         Retrieve the rows of the virtual document with the specified identifiers and the given effectiveAt date time.    Get virtual document rows merges multiple StructuredResultData items upserted with UpsertStructuredResultData  for a single StructuredResultDataId.                Since an item of StructuredResultData is always upserted with a StructuredResultDataId, of which  effectiveAt is a part, then merging across the asAt dimension is supported but not merging across the  effectiveAt dimension.  # noqa: E501
@@ -1181,7 +1181,7 @@ class StructuredResultDataApi:
         return self.get_virtual_document_rows_with_http_info(scope, code, source, result_type, effective_at, as_at, page, limit, filter, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_virtual_document_rows_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[StrictStr, Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[StrictStr, Field(..., description="The source of the virtual document to retrieve.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the virtual document to retrieve.")], effective_at : Annotated[StrictStr, Field(..., description="The effectiveAt datetime at which to retrieve the virtual document.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the virtual document. Defaults to returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing virtual document rows from a previous               call to list virtual document rows. 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, le=5000, ge=1)], 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 get_virtual_document_rows_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope in which to retrieve the virtual document.")], code : Annotated[StrictStr, Field(..., description="The code of the virtual document to retrieve.")], source : Annotated[StrictStr, Field(..., description="The source of the virtual document to retrieve.")], result_type : Annotated[StrictStr, Field(..., description="The result type of the virtual document to retrieve.")], effective_at : Annotated[StrictStr, Field(..., description="The effectiveAt datetime at which to retrieve the virtual document.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the virtual document. Defaults to returning the latest version if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing virtual document rows from a previous               call to list virtual document rows. This value is returned from the previous call. If a pagination token is               provided the filter, effectiveAt, and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, 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] GetVirtualDocumentRows: Get Virtual Document Rows  # noqa: E501
 
         Retrieve the rows of the virtual document with the specified identifiers and the given effectiveAt date time.    Get virtual document rows merges multiple StructuredResultData items upserted with UpsertStructuredResultData  for a single StructuredResultDataId.                Since an item of StructuredResultData is always upserted with a StructuredResultDataId, of which  effectiveAt is a part, then merging across the asAt dimension is supported but not merging across the  effectiveAt dimension.  # noqa: E501

lusid/api/timelines_api.py

@@ -931,15 +931,15 @@ class TimelinesApi:
 
 
     @overload
-    async def list_closed_periods(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing ClosedPeriods; 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, le=5000, ge=1)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.              These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.")] = None, **kwargs) -> PagedResourceListOfClosedPeriod:  # noqa: E501
+    async def list_closed_periods(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing ClosedPeriods; 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 results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.              These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.")] = None, **kwargs) -> PagedResourceListOfClosedPeriod:  # noqa: E501
         ...
 
     @overload
-    def list_closed_periods(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing ClosedPeriods; 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, le=5000, ge=1)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.              These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfClosedPeriod:  # noqa: E501
+    def list_closed_periods(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing ClosedPeriods; 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 results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.              These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfClosedPeriod:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_closed_periods(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing ClosedPeriods; 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, le=5000, ge=1)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.              These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfClosedPeriod, Awaitable[PagedResourceListOfClosedPeriod]]:  # noqa: E501
+    def list_closed_periods(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing ClosedPeriods; 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 results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.              These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfClosedPeriod, Awaitable[PagedResourceListOfClosedPeriod]]:  # noqa: E501
         """[EXPERIMENTAL] ListClosedPeriods: List ClosedPeriods for a specified Timeline.  # noqa: E501
 
         List all the ClosedPeriods matching a particular criteria.  # noqa: E501
@@ -984,7 +984,7 @@ class TimelinesApi:
         return self.list_closed_periods_with_http_info(scope, code, as_at, page, limit, filter, sort_by, property_keys, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_closed_periods_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing ClosedPeriods; 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, le=5000, ge=1)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.              These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_closed_periods_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing ClosedPeriods; 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 results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.              These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] ListClosedPeriods: List ClosedPeriods for a specified Timeline.  # noqa: E501
 
         List all the ClosedPeriods matching a particular criteria.  # noqa: E501

lusid/api/transaction_fees_api.py

@@ -592,15 +592,15 @@ class TransactionFeesApi:
 
 
     @overload
-    async def list_transaction_fee_rules(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule definitions. Defaults to the current LUSID  system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the rule definitions. Defaults to returning the latest version if not  specified.")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing entities; this value is returned from the previous call. If  a pagination token is provided, the filter, effectiveAt and asAt fields must not have changed since the  original request.")] = None, **kwargs) -> ResourceListOfFeeRule:  # noqa: E501
+    async def list_transaction_fee_rules(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule definitions. Defaults to the current LUSID  system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the rule definitions. Defaults to returning the latest version if not  specified.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing entities; this value is returned from the previous call. If  a pagination token is provided, the filter, effectiveAt and asAt fields must not have changed since the  original request.")] = None, **kwargs) -> ResourceListOfFeeRule:  # noqa: E501
         ...
 
     @overload
-    def list_transaction_fee_rules(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule definitions. Defaults to the current LUSID  system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the rule definitions. Defaults to returning the latest version if not  specified.")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing entities; this value is returned from the previous call. If  a pagination token is provided, the filter, effectiveAt and asAt fields must not have changed since the  original request.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfFeeRule:  # noqa: E501
+    def list_transaction_fee_rules(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule definitions. Defaults to the current LUSID  system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the rule definitions. Defaults to returning the latest version if not  specified.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing entities; this value is returned from the previous call. If  a pagination token is provided, the filter, effectiveAt and asAt fields must not have changed since the  original request.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfFeeRule:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_transaction_fee_rules(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule definitions. Defaults to the current LUSID  system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the rule definitions. Defaults to returning the latest version if not  specified.")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing entities; this value is returned from the previous call. If  a pagination token is provided, the filter, effectiveAt and asAt fields must not have changed since the  original request.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfFeeRule, Awaitable[ResourceListOfFeeRule]]:  # noqa: E501
+    def list_transaction_fee_rules(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule definitions. Defaults to the current LUSID  system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the rule definitions. Defaults to returning the latest version if not  specified.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing entities; this value is returned from the previous call. If  a pagination token is provided, the filter, effectiveAt and asAt fields must not have changed since the  original request.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfFeeRule, Awaitable[ResourceListOfFeeRule]]:  # noqa: E501
         """[EXPERIMENTAL] ListTransactionFeeRules: List fee rules, with optional filtering.  # noqa: E501
 
         For more information about filtering results,  see https://support.lusid.com/knowledgebase/article/KA-01914.  # noqa: E501
@@ -639,7 +639,7 @@ class TransactionFeesApi:
         return self.list_transaction_fee_rules_with_http_info(effective_at, as_at, limit, filter, page, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_transaction_fee_rules_with_http_info(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule definitions. Defaults to the current LUSID  system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the rule definitions. Defaults to returning the latest version if not  specified.")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing entities; this value is returned from the previous call. If  a pagination token is provided, the filter, effectiveAt and asAt fields must not have changed since the  original request.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_transaction_fee_rules_with_http_info(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to retrieve the rule definitions. Defaults to the current LUSID  system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the rule definitions. Defaults to returning the latest version if not  specified.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing entities; this value is returned from the previous call. If  a pagination token is provided, the filter, effectiveAt and asAt fields must not have changed since the  original request.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] ListTransactionFeeRules: List fee rules, with optional filtering.  # noqa: E501
 
         For more information about filtering results,  see https://support.lusid.com/knowledgebase/article/KA-01914.  # noqa: E501