lusid-sdk 2.1.139__py3-none-any.whl → 2.1.141__py3-none-any.whl

lusid/api/aggregation_api.py

@@ -235,7 +235,7 @@ class AggregationApi:
 
     @validate_arguments
     def get_queryable_keys(self, page : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="The pagination token to use to continue listing queryable keys from a previous call to list queryable keys.              This value is returned from the previous call.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], 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[ResourceListOfAggregationQuery, Awaitable[ResourceListOfAggregationQuery]]:  # noqa: E501
-        """[EARLY ACCESS] GetQueryableKeys: Query the set of supported \"addresses\" that can be queried from the aggregation endpoint.  # noqa: E501
+        """GetQueryableKeys: Query the set of supported \"addresses\" that can be queried from the aggregation endpoint.  # noqa: E501
 
         When a request is made for aggregation, the user needs to know what keys can be passed to it for queryable data. This endpoint allows to queries to provide the set of keys,  what they are and what they return.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -271,7 +271,7 @@ class AggregationApi:
 
     @validate_arguments
     def get_queryable_keys_with_http_info(self, page : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="The pagination token to use to continue listing queryable keys from a previous call to list queryable keys.              This value is returned from the previous call.")] = None, limit : Annotated[Optional[StrictInt], Field(description="When paginating, limit the number of returned results to this many.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], 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] GetQueryableKeys: Query the set of supported \"addresses\" that can be queried from the aggregation endpoint.  # noqa: E501
+        """GetQueryableKeys: Query the set of supported \"addresses\" that can be queried from the aggregation endpoint.  # noqa: E501
 
         When a request is made for aggregation, the user needs to know what keys can be passed to it for queryable data. This endpoint allows to queries to provide the set of keys,  what they are and what they return.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/api/allocations_api.py

@@ -596,7 +596,7 @@ class AllocationsApi:
 
     @validate_arguments
     def upsert_allocations(self, allocation_set_request : Annotated[Optional[AllocationSetRequest], Field(description="The collection of allocation requests.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfAllocation, Awaitable[ResourceListOfAllocation]]:  # noqa: E501
-        """[EARLY ACCESS] UpsertAllocations: Upsert Allocations  # noqa: E501
+        """UpsertAllocations: Upsert Allocations  # noqa: E501
 
         Upsert; update existing allocations with given ids, or create new allocations otherwise.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -628,7 +628,7 @@ class AllocationsApi:
 
     @validate_arguments
     def upsert_allocations_with_http_info(self, allocation_set_request : Annotated[Optional[AllocationSetRequest], Field(description="The collection of allocation requests.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] UpsertAllocations: Upsert Allocations  # noqa: E501
+        """UpsertAllocations: Upsert Allocations  # noqa: E501
 
         Upsert; update existing allocations with given ids, or create new allocations otherwise.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/api/calendars_api.py

@@ -234,7 +234,7 @@ class CalendarsApi:
 
     @validate_arguments
     def add_date_to_calendar(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the calendar")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the calendar")], create_date_request : Annotated[CreateDateRequest, Field(..., description="Add date to calendar request")], async_req: Optional[bool]=None, **kwargs) -> Union[CalendarDate, Awaitable[CalendarDate]]:  # noqa: E501
-        """[EARLY ACCESS] AddDateToCalendar: Add a date to a calendar  # noqa: E501
+        """AddDateToCalendar: Add a date to a calendar  # noqa: E501
 
         Add an event to the calendar. These Events can be a maximum of 24 hours and must be specified in UTC.  A local date will be calculated by the system and applied to the calendar before processing.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -270,7 +270,7 @@ class CalendarsApi:
 
     @validate_arguments
     def add_date_to_calendar_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the calendar")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the calendar")], create_date_request : Annotated[CreateDateRequest, Field(..., description="Add date to calendar request")], **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] AddDateToCalendar: Add a date to a calendar  # noqa: E501
+        """AddDateToCalendar: Add a date to a calendar  # noqa: E501
 
         Add an event to the calendar. These Events can be a maximum of 24 hours and must be specified in UTC.  A local date will be calculated by the system and applied to the calendar before processing.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1069,7 +1069,7 @@ class CalendarsApi:
 
     @validate_arguments
     def get_calendar(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the calendar identifier")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the calendar identifier")], property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Calendar\" domain to decorate onto the calendar,               These take the format {domain}/{scope}/{code} e.g. \"Calendar/System/Name\".")] = None, as_at : Annotated[Optional[datetime], Field(description="The AsAt datetime at which to retrieve the calendar")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Calendar, Awaitable[Calendar]]:  # noqa: E501
-        """[EARLY ACCESS] GetCalendar: Get a calendar in its generic form  # noqa: E501
+        """GetCalendar: Get a calendar in its generic form  # noqa: E501
 
         Retrieve a generic calendar by a specific ID at a point in AsAt time  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1107,7 +1107,7 @@ class CalendarsApi:
 
     @validate_arguments
     def get_calendar_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the calendar identifier")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the calendar identifier")], property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Calendar\" domain to decorate onto the calendar,               These take the format {domain}/{scope}/{code} e.g. \"Calendar/System/Name\".")] = None, as_at : Annotated[Optional[datetime], Field(description="The AsAt datetime at which to retrieve the calendar")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] GetCalendar: Get a calendar in its generic form  # noqa: E501
+        """GetCalendar: Get a calendar in its generic form  # noqa: E501
 
         Retrieve a generic calendar by a specific ID at a point in AsAt time  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1811,7 +1811,7 @@ class CalendarsApi:
 
     @validate_arguments
     def list_calendars_in_scope(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the calendars")], as_at : Annotated[Optional[datetime], Field(description="The AsAt datetime at which to retrieve the calendars")] = None, page : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="The pagination token to use to continue listing calendars from a previous call to list calendars.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="When paginating, limit the number of returned results to this many.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Calendar\" domain to decorate onto the calendar,               These take the format {domain}/{scope}/{code} e.g. \"Calendar/System/Name\".")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], 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[PagedResourceListOfCalendar, Awaitable[PagedResourceListOfCalendar]]:  # noqa: E501
-        """[EARLY ACCESS] ListCalendarsInScope: List all calenders in a specified scope  # noqa: E501
+        """ListCalendarsInScope: List all calenders in a specified scope  # noqa: E501
 
         List calendars in a Scope at a point in AsAt time.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1853,7 +1853,7 @@ class CalendarsApi:
 
     @validate_arguments
     def list_calendars_in_scope_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the calendars")], as_at : Annotated[Optional[datetime], Field(description="The AsAt datetime at which to retrieve the calendars")] = None, page : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="The pagination token to use to continue listing calendars from a previous call to list calendars.              This value is returned from the previous call. If a pagination token is provided the sortBy, filter, and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="When paginating, limit the number of returned results to this many.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Calendar\" domain to decorate onto the calendar,               These take the format {domain}/{scope}/{code} e.g. \"Calendar/System/Name\".")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], 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] ListCalendarsInScope: List all calenders in a specified scope  # noqa: E501
+        """ListCalendarsInScope: List all calenders in a specified scope  # noqa: E501
 
         List calendars in a Scope at a point in AsAt time.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/api/complex_market_data_api.py

@@ -576,7 +576,7 @@ class ComplexMarketDataApi:
 
     @validate_arguments
     def upsert_complex_market_data(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope to use when updating or inserting the complex market data.")], request_body : Annotated[Dict[str, UpsertComplexMarketDataRequest], Field(..., description="The set of complex market data items to update or insert keyed by a unique correlation id.")], async_req: Optional[bool]=None, **kwargs) -> Union[UpsertStructuredDataResponse, Awaitable[UpsertStructuredDataResponse]]:  # noqa: E501
-        """[EARLY ACCESS] UpsertComplexMarketData: Upsert a set of complex market data items. This creates or updates the data in Lusid.  # noqa: E501
+        """UpsertComplexMarketData: Upsert a set of complex market data items. This creates or updates the data in Lusid.  # noqa: E501
 
         Update or insert one or more complex market data items in a single scope. An item will be updated if it already exists  and inserted if it does not.                In the request each complex market data item must be keyed by a unique correlation id. This id is ephemeral and is not stored by LUSID.  It serves only as a way to easily identify each complex market data in the response.                The response will return both the collection of successfully updated or inserted complex market data, as well as those that failed.  For the failures a reason will be provided explaining why the item could not be updated or inserted.                It is important to always check the failed set for any unsuccessful results.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -610,7 +610,7 @@ class ComplexMarketDataApi:
 
     @validate_arguments
     def upsert_complex_market_data_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope to use when updating or inserting the complex market data.")], request_body : Annotated[Dict[str, UpsertComplexMarketDataRequest], Field(..., description="The set of complex market data items to update or insert keyed by a unique correlation id.")], **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] UpsertComplexMarketData: Upsert a set of complex market data items. This creates or updates the data in Lusid.  # noqa: E501
+        """UpsertComplexMarketData: Upsert a set of complex market data items. This creates or updates the data in Lusid.  # noqa: E501
 
         Update or insert one or more complex market data items in a single scope. An item will be updated if it already exists  and inserted if it does not.                In the request each complex market data item must be keyed by a unique correlation id. This id is ephemeral and is not stored by LUSID.  It serves only as a way to easily identify each complex market data in the response.                The response will return both the collection of successfully updated or inserted complex market data, as well as those that failed.  For the failures a reason will be provided explaining why the item could not be updated or inserted.                It is important to always check the failed set for any unsuccessful results.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/api/custom_entities_api.py

@@ -637,7 +637,7 @@ class CustomEntitiesApi:
 
     @validate_arguments
     def get_custom_entity(self, entity_type : Annotated[constr(strict=True, max_length=65, min_length=1), Field(..., description="The type of Custom Entity to retrieve. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], identifier_type : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[constr(strict=True, max_length=1024, min_length=1), Field(..., description="The identifier value.")], identifier_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The identifier scope.")], as_at : Annotated[Optional[datetime], Field(description="The AsAt datetime at which to retrieve the Custom Entity instance.")] = None, effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to get the Custom Entity instance. Defaults to the current LUSID system datetime if not specified.")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships              to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the entity in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[CustomEntityResponse, Awaitable[CustomEntityResponse]]:  # noqa: E501
-        """[EARLY ACCESS] GetCustomEntity: Get a Custom Entity instance.  # noqa: E501
+        """GetCustomEntity: Get a Custom Entity instance.  # noqa: E501
 
         Retrieve a Custom Entity instance by a specific entity type at a point in AsAt time.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -683,7 +683,7 @@ class CustomEntitiesApi:
 
     @validate_arguments
     def get_custom_entity_with_http_info(self, entity_type : Annotated[constr(strict=True, max_length=65, min_length=1), Field(..., description="The type of Custom Entity to retrieve. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], identifier_type : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[constr(strict=True, max_length=1024, min_length=1), Field(..., description="The identifier value.")], identifier_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The identifier scope.")], as_at : Annotated[Optional[datetime], Field(description="The AsAt datetime at which to retrieve the Custom Entity instance.")] = None, effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to get the Custom Entity instance. Defaults to the current LUSID system datetime if not specified.")] = None, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships              to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the entity in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] GetCustomEntity: Get a Custom Entity instance.  # noqa: E501
+        """GetCustomEntity: Get a Custom Entity instance.  # noqa: E501
 
         Retrieve a Custom Entity instance by a specific entity type at a point in AsAt time.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1262,7 +1262,7 @@ class CustomEntitiesApi:
 
     @validate_arguments
     def list_custom_entities(self, entity_type : Annotated[constr(strict=True, max_length=65, min_length=1), Field(..., description="The type of Custom Entity to list.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to list the entities. Defaults to the current LUSID              system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the entities. Defaults to returning the latest version              of each portfolio 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[constr(strict=True, max_length=16384, min_length=0)], Field(description="Expression to filter the results. 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, page : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], 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, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships              to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the entities in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfCustomEntityResponse, Awaitable[PagedResourceListOfCustomEntityResponse]]:  # noqa: E501
-        """[EARLY ACCESS] ListCustomEntities: List Custom Entities of the specified entityType.  # noqa: E501
+        """ListCustomEntities: List Custom Entities of the specified entityType.  # noqa: E501
 
         List all the Custom Entities matching particular criteria.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1310,7 +1310,7 @@ class CustomEntitiesApi:
 
     @validate_arguments
     def list_custom_entities_with_http_info(self, entity_type : Annotated[constr(strict=True, max_length=65, min_length=1), Field(..., description="The type of Custom Entity to list.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to list the entities. Defaults to the current LUSID              system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the entities. Defaults to returning the latest version              of each portfolio 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[constr(strict=True, max_length=16384, min_length=0)], Field(description="Expression to filter the results. 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, page : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], 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, related_entity_property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from any domain that supports relationships              to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the entities in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] ListCustomEntities: List Custom Entities of the specified entityType.  # noqa: E501
+        """ListCustomEntities: List Custom Entities of the specified entityType.  # noqa: E501
 
         List all the Custom Entities matching particular criteria.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1866,7 +1866,7 @@ class CustomEntitiesApi:
 
     @validate_arguments
     def upsert_custom_entity(self, entity_type : Annotated[constr(strict=True, max_length=65, min_length=1), Field(..., description="The type of the Custom Entity to be created. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], custom_entity_request : Annotated[CustomEntityRequest, Field(..., description="The payload describing the Custom Entity instance.")], async_req: Optional[bool]=None, **kwargs) -> Union[CustomEntityResponse, Awaitable[CustomEntityResponse]]:  # noqa: E501
-        """[EARLY ACCESS] UpsertCustomEntity: Upsert a Custom Entity instance  # noqa: E501
+        """UpsertCustomEntity: Upsert a Custom Entity instance  # noqa: E501
 
         Insert the Custom Entity if it does not exist or update the Custom Entity with the supplied state if it does exist.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1900,7 +1900,7 @@ class CustomEntitiesApi:
 
     @validate_arguments
     def upsert_custom_entity_with_http_info(self, entity_type : Annotated[constr(strict=True, max_length=65, min_length=1), Field(..., description="The type of the Custom Entity to be created. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], custom_entity_request : Annotated[CustomEntityRequest, Field(..., description="The payload describing the Custom Entity instance.")], **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] UpsertCustomEntity: Upsert a Custom Entity instance  # noqa: E501
+        """UpsertCustomEntity: Upsert a Custom Entity instance  # noqa: E501
 
         Insert the Custom Entity if it does not exist or update the Custom Entity with the supplied state if it does exist.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/api/entities_api.py

@@ -229,7 +229,7 @@ class EntitiesApi:
 
     @validate_arguments
     def get_portfolio_changes(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope")], effective_at : Annotated[constr(strict=True, max_length=256, min_length=0), Field(..., description="The effective date of the origin.")], as_at : Annotated[Optional[datetime], Field(description="The as-at date of the origin.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfChange, Awaitable[ResourceListOfChange]]:  # noqa: E501
-        """[EARLY ACCESS] GetPortfolioChanges: Get the next change to each portfolio in a scope.  # noqa: E501
+        """GetPortfolioChanges: Get the next change to each portfolio in a scope.  # noqa: E501
 
         Gets the time of the next (earliest effective at) modification (correction and/or amendment) to each portfolio in a scope relative to a point in bitemporal time.  Includes changes from parent portfolios in different scopes.  Excludes changes from subscriptions (e.g corporate actions).  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -265,7 +265,7 @@ class EntitiesApi:
 
     @validate_arguments
     def get_portfolio_changes_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope")], effective_at : Annotated[constr(strict=True, max_length=256, min_length=0), Field(..., description="The effective date of the origin.")], as_at : Annotated[Optional[datetime], Field(description="The as-at date of the origin.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] GetPortfolioChanges: Get the next change to each portfolio in a scope.  # noqa: E501
+        """GetPortfolioChanges: Get the next change to each portfolio in a scope.  # noqa: E501
 
         Gets the time of the next (earliest effective at) modification (correction and/or amendment) to each portfolio in a scope relative to a point in bitemporal time.  Includes changes from parent portfolios in different scopes.  Excludes changes from subscriptions (e.g corporate actions).  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/api/executions_api.py

@@ -400,7 +400,7 @@ class ExecutionsApi:
 
     @validate_arguments
     def list_executions(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the execution. Defaults to return the latest version of the execution if not specified.")] = None, page : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="The pagination token to use to continue listing execution from a previous call to list executions.              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 or properties 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[constr(strict=True, max_length=16384, min_length=0)], 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Execution\" domain to decorate onto each execution.                  These take the format {domain}/{scope}/{code} e.g. \"Execution/system/Name\".")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfExecution, Awaitable[PagedResourceListOfExecution]]:  # noqa: E501
-        """[EARLY ACCESS] ListExecutions: List Executions  # noqa: E501
+        """ListExecutions: List Executions  # noqa: E501
 
         Fetch the last pre-AsAt date version of each execution in scope (does not fetch the entire history).  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -442,7 +442,7 @@ class ExecutionsApi:
 
     @validate_arguments
     def list_executions_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the execution. Defaults to return the latest version of the execution if not specified.")] = None, page : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="The pagination token to use to continue listing execution from a previous call to list executions.              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 or properties 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[constr(strict=True, max_length=16384, min_length=0)], 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the \"Execution\" domain to decorate onto each execution.                  These take the format {domain}/{scope}/{code} e.g. \"Execution/system/Name\".")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] ListExecutions: List Executions  # noqa: E501
+        """ListExecutions: List Executions  # noqa: E501
 
         Fetch the last pre-AsAt date version of each execution in scope (does not fetch the entire history).  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -596,7 +596,7 @@ class ExecutionsApi:
 
     @validate_arguments
     def upsert_executions(self, execution_set_request : Annotated[Optional[ExecutionSetRequest], Field(description="The collection of execution requests.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfExecution, Awaitable[ResourceListOfExecution]]:  # noqa: E501
-        """[EARLY ACCESS] UpsertExecutions: Upsert Execution  # noqa: E501
+        """UpsertExecutions: Upsert Execution  # noqa: E501
 
         Upsert; update existing executions with given ids, or create new executions otherwise.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -628,7 +628,7 @@ class ExecutionsApi:
 
     @validate_arguments
     def upsert_executions_with_http_info(self, execution_set_request : Annotated[Optional[ExecutionSetRequest], Field(description="The collection of execution requests.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] UpsertExecutions: Upsert Execution  # noqa: E501
+        """UpsertExecutions: Upsert Execution  # noqa: E501
 
         Upsert; update existing executions with given ids, or create new executions otherwise.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/api/funds_api.py

@@ -403,7 +403,7 @@ class FundsApi:
         }
 
         return self.api_client.call_api(
-            '/api/funds/{scope}/{code}/fee/{feeCode}', 'POST',
+            '/api/funds/{scope}/{code}/fees/{feeCode}', 'POST',
             _path_params,
             _query_params,
             _header_params,
@@ -736,7 +736,7 @@ class FundsApi:
         }
 
         return self.api_client.call_api(
-            '/api/funds/{scope}/{code}/fee/{feeCode}', 'DELETE',
+            '/api/funds/{scope}/{code}/fees/{feeCode}', 'DELETE',
             _path_params,
             _query_params,
             _header_params,
@@ -1431,7 +1431,7 @@ class FundsApi:
         }
 
         return self.api_client.call_api(
-            '/api/funds/{scope}/{code}/fee/{feeCode}', 'GET',
+            '/api/funds/{scope}/{code}/fees/{feeCode}', 'GET',
             _path_params,
             _query_params,
             _header_params,
@@ -2023,7 +2023,7 @@ class FundsApi:
         }
 
         return self.api_client.call_api(
-            '/api/funds/{scope}/{code}/fee', 'GET',
+            '/api/funds/{scope}/{code}/fees', 'GET',
             _path_params,
             _query_params,
             _header_params,
@@ -2409,7 +2409,7 @@ class FundsApi:
         }
 
         return self.api_client.call_api(
-            '/api/funds/{scope}/{code}/fee/{feeCode}', 'PATCH',
+            '/api/funds/{scope}/{code}/fees/{feeCode}', 'PATCH',
             _path_params,
             _query_params,
             _header_params,

lusid/api/instrument_events_api.py

@@ -252,7 +252,7 @@ class InstrumentEventsApi:
 
     @validate_arguments
     def query_bucketed_cash_flows(self, query_bucketed_cash_flows_request : Annotated[Optional[QueryBucketedCashFlowsRequest], Field(description="The Query Information.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BucketedCashFlowResponse, Awaitable[BucketedCashFlowResponse]]:  # noqa: E501
-        """[EXPERIMENTAL] QueryBucketedCashFlows: Returns bucketed cashflows based on the holdings of the portfolios and date range specified in the query.  # noqa: E501
+        """QueryBucketedCashFlows: Returns bucketed cashflows based on the holdings of the portfolios and date range specified in the query.  # noqa: E501
 
         Returns bucketed cashflows based on the holdings of the portfolios and date range specified in the query.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -284,7 +284,7 @@ class InstrumentEventsApi:
 
     @validate_arguments
     def query_bucketed_cash_flows_with_http_info(self, query_bucketed_cash_flows_request : Annotated[Optional[QueryBucketedCashFlowsRequest], Field(description="The Query Information.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] QueryBucketedCashFlows: Returns bucketed cashflows based on the holdings of the portfolios and date range specified in the query.  # noqa: E501
+        """QueryBucketedCashFlows: Returns bucketed cashflows based on the holdings of the portfolios and date range specified in the query.  # noqa: E501
 
         Returns bucketed cashflows based on the holdings of the portfolios and date range specified in the query.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/api/instruments_api.py

@@ -260,7 +260,7 @@ class InstrumentsApi:
 
     @validate_arguments
     def delete_instrument(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[DeleteInstrumentResponse, Awaitable[DeleteInstrumentResponse]]:  # noqa: E501
-        """[EARLY ACCESS] DeleteInstrument: Soft delete a single instrument  # noqa: E501
+        """DeleteInstrument: Soft delete a single instrument  # noqa: E501
 
         Soft delete a particular instrument, as identified by a particular instrument identifier.                Once deleted, an instrument is marked as inactive and can no longer be referenced when creating or updating  transactions or holdings. You can still query existing transactions and holdings related to the  deleted instrument.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -296,7 +296,7 @@ class InstrumentsApi:
 
     @validate_arguments
     def delete_instrument_with_http_info(self, identifier_type : Annotated[StrictStr, Field(..., description="The unique identifier type to search, for example 'Figi'.")], identifier : Annotated[StrictStr, Field(..., description="An <i>identifierType</i> value to use to identify the instrument, for example 'BBG000BLNNV0'.")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the instrument lies. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] DeleteInstrument: Soft delete a single instrument  # noqa: E501
+        """DeleteInstrument: Soft delete a single instrument  # noqa: E501
 
         Soft delete a particular instrument, as identified by a particular instrument identifier.                Once deleted, an instrument is marked as inactive and can no longer be referenced when creating or updating  transactions or holdings. You can still query existing transactions and holdings related to the  deleted instrument.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -617,7 +617,7 @@ class InstrumentsApi:
 
     @validate_arguments
     def delete_instruments(self, request_body : Annotated[conlist(StrictStr), Field(..., description="The list of lusidInstrumentId's to delete.")], delete_mode : Annotated[Optional[StrictStr], Field(description="The delete mode to use (defaults to 'Soft').")] = None, scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the instruments lie. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[DeleteInstrumentsResponse, Awaitable[DeleteInstrumentsResponse]]:  # noqa: E501
-        """[EARLY ACCESS] DeleteInstruments: Soft or hard delete multiple instruments  # noqa: E501
+        """DeleteInstruments: Soft or hard delete multiple instruments  # noqa: E501
 
         Deletes a number of instruments identified by LusidInstrumentId.                Soft deletion marks the instrument as inactive so it can no longer be referenced when creating or updating transactions or holdings. You can still query existing transactions and holdings related to the inactive instrument.                In addition to the above behaviour, hard deletion: (i) completely removes all external identifiers from the instrument; (ii) marks the instrument as 'Deleted'; (iii) prepends the instrument's name with 'DELETED '; (iv) prevents the instrument from being returned in list instruments queries.                Following hard deletion, an instrument may only be retrieved by making a direct get instrument request for the LusidInstrumentId. Instrument deletion cannot be undone. Please note that currency instruments cannot currently be deleted.  The maximum number of instruments that this method can delete per request is 2,000.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -653,7 +653,7 @@ class InstrumentsApi:
 
     @validate_arguments
     def delete_instruments_with_http_info(self, request_body : Annotated[conlist(StrictStr), Field(..., description="The list of lusidInstrumentId's to delete.")], delete_mode : Annotated[Optional[StrictStr], Field(description="The delete mode to use (defaults to 'Soft').")] = None, scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the instruments lie. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] DeleteInstruments: Soft or hard delete multiple instruments  # noqa: E501
+        """DeleteInstruments: Soft or hard delete multiple instruments  # noqa: E501
 
         Deletes a number of instruments identified by LusidInstrumentId.                Soft deletion marks the instrument as inactive so it can no longer be referenced when creating or updating transactions or holdings. You can still query existing transactions and holdings related to the inactive instrument.                In addition to the above behaviour, hard deletion: (i) completely removes all external identifiers from the instrument; (ii) marks the instrument as 'Deleted'; (iii) prepends the instrument's name with 'DELETED '; (iv) prevents the instrument from being returned in list instruments queries.                Following hard deletion, an instrument may only be retrieved by making a direct get instrument request for the LusidInstrumentId. Instrument deletion cannot be undone. Please note that currency instruments cannot currently be deleted.  The maximum number of instruments that this method can delete per request is 2,000.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/api/legal_entities_api.py

@@ -72,7 +72,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def delete_legal_entity(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the legal entity identifier type.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the legal entity identifier type.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity under specified identifier type's scope and code. This together with defined              identifier type uniquely identifies the legal entity to delete.")], async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
-        """[EARLY ACCESS] DeleteLegalEntity: Delete Legal Entity  # noqa: E501
+        """DeleteLegalEntity: Delete Legal Entity  # noqa: E501
 
         Delete a legal entity. Deletion will be valid from the legal entity's creation datetime.  This means that the legal entity will no longer exist at any effective datetime from the asAt datetime of deletion.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -108,7 +108,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def delete_legal_entity_with_http_info(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the legal entity identifier type.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the legal entity identifier type.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity under specified identifier type's scope and code. This together with defined              identifier type uniquely identifies the legal entity to delete.")], **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] DeleteLegalEntity: Delete Legal Entity  # noqa: E501
+        """DeleteLegalEntity: Delete Legal Entity  # noqa: E501
 
         Delete a legal entity. Deletion will be valid from the legal entity's creation datetime.  This means that the legal entity will no longer exist at any effective datetime from the asAt datetime of deletion.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -801,7 +801,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def get_all_legal_entity_access_metadata(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the Legal Entity identifier.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the Legal Entity identifier.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the Legal Entity under specified identifier type's scope and code.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effectiveAt datetime at which to retrieve the Access Metadata")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Access Metadata")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Dict[str, List[AccessMetadataValue]], Awaitable[Dict[str, List[AccessMetadataValue]]]]:  # noqa: E501
-        """[EARLY ACCESS] GetAllLegalEntityAccessMetadata: Get Access Metadata rules for a Legal Entity  # noqa: E501
+        """GetAllLegalEntityAccessMetadata: Get Access Metadata rules for a Legal Entity  # noqa: E501
 
         Pass the Scope and Code of the Legal Entity identifier along with the Legal Entity code parameter to retrieve the associated Access Metadata  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -841,7 +841,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def get_all_legal_entity_access_metadata_with_http_info(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the Legal Entity identifier.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the Legal Entity identifier.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the Legal Entity under specified identifier type's scope and code.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effectiveAt datetime at which to retrieve the Access Metadata")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Access Metadata")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] GetAllLegalEntityAccessMetadata: Get Access Metadata rules for a Legal Entity  # noqa: E501
+        """GetAllLegalEntityAccessMetadata: Get Access Metadata rules for a Legal Entity  # noqa: E501
 
         Pass the Scope and Code of the Legal Entity identifier along with the Legal Entity code parameter to retrieve the associated Access Metadata  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -987,7 +987,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def get_legal_entity(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the legal entity identifier type.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity identifier type.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity under specified identifier type's scope and code. This together with stated identifier type uniquely              identifies the legal entity.")], property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys or identifier types (as property keys) from the \"LegalEntity\" domain              to include for found legal entity, or from any domain that supports relationships to decorate onto related entities.              These take the format {domain}/{scope}/{code} e.g. \"LegalEntity/ContactDetails/Address\".")] = None, effective_at : Annotated[Optional[constr(strict=True, max_length=256, min_length=0)], Field(description="The effective datetime or cut label at which to retrieve the legal entity. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the legal entity. Defaults to return the latest version of the legal entity if not specified.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the legal entity in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[LegalEntity, Awaitable[LegalEntity]]:  # noqa: E501
-        """[EARLY ACCESS] GetLegalEntity: Get Legal Entity  # noqa: E501
+        """GetLegalEntity: Get Legal Entity  # noqa: E501
 
         Retrieve the definition of a legal entity.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1031,7 +1031,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def get_legal_entity_with_http_info(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the legal entity identifier type.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity identifier type.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity under specified identifier type's scope and code. This together with stated identifier type uniquely              identifies the legal entity.")], property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys or identifier types (as property keys) from the \"LegalEntity\" domain              to include for found legal entity, or from any domain that supports relationships to decorate onto related entities.              These take the format {domain}/{scope}/{code} e.g. \"LegalEntity/ContactDetails/Address\".")] = None, effective_at : Annotated[Optional[constr(strict=True, max_length=256, min_length=0)], Field(description="The effective datetime or cut label at which to retrieve the legal entity. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the legal entity. Defaults to return the latest version of the legal entity if not specified.")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto the legal entity in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] GetLegalEntity: Get Legal Entity  # noqa: E501
+        """GetLegalEntity: Get Legal Entity  # noqa: E501
 
         Retrieve the definition of a legal entity.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1385,7 +1385,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def get_legal_entity_property_time_series(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the legal entity identifier type.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity identifier type.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity under specified identifier type's scope and code. This together with stated identifier type uniquely identifies the legal entity.")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property that will have its history shown. These must be in the format {domain}/{scope}/{code} e.g. \"LegalEntity/ContactDetails/Address\".              Each property must be from the \"LegalEntity\" domain.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the person's property history. Defaults to return the current datetime if not supplied.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], 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, page : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="The pagination token to use to continue listing properties from a previous call to get property time series.              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=5000, ge=1)], Field(description="When paginating, limit the number of returned results to this many.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfPropertyInterval, Awaitable[ResourceListOfPropertyInterval]]:  # noqa: E501
-        """[EARLY ACCESS] GetLegalEntityPropertyTimeSeries: Get Legal Entity Property Time Series  # noqa: E501
+        """GetLegalEntityPropertyTimeSeries: Get Legal Entity Property Time Series  # noqa: E501
 
         List the complete time series of a legal entity property.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1431,7 +1431,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def get_legal_entity_property_time_series_with_http_info(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the legal entity identifier type.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity identifier type.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity under specified identifier type's scope and code. This together with stated identifier type uniquely identifies the legal entity.")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property that will have its history shown. These must be in the format {domain}/{scope}/{code} e.g. \"LegalEntity/ContactDetails/Address\".              Each property must be from the \"LegalEntity\" domain.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the person's property history. Defaults to return the current datetime if not supplied.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], 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, page : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="The pagination token to use to continue listing properties from a previous call to get property time series.              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=5000, ge=1)], Field(description="When paginating, limit the number of returned results to this many.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] GetLegalEntityPropertyTimeSeries: Get Legal Entity Property Time Series  # noqa: E501
+        """GetLegalEntityPropertyTimeSeries: Get Legal Entity Property Time Series  # noqa: E501
 
         List the complete time series of a legal entity property.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1595,7 +1595,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def get_legal_entity_relations(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the legal entity identifier type.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity identifier type.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity under specified identifier type's scope and code. This together with stated identifier type uniquely              identifies the legal entity.")], effective_at : Annotated[Optional[constr(strict=True, max_length=256, min_length=0)], Field(description="The effective datetime or cut label at which to get relations. 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 legal entity's relations. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], Field(description="Expression to filter the relations. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifiers types (as property keys) used for referencing Persons or Legal Entities. These take the format              {domain}/{scope}/{code} e.g. \"Person/CompanyDetails/Role\". They must be from the \"Person\" or \"LegalEntity\" domain.              Only identifier types stated will be used to look up relevant entities in relations. If not applicable, provide an empty array.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfRelation, Awaitable[ResourceListOfRelation]]:  # noqa: E501
-        """[EXPERIMENTAL] GetLegalEntityRelations: Get Relations for Legal Entity  # noqa: E501
+        """GetLegalEntityRelations: Get Relations for Legal Entity  # noqa: E501
 
         Get relations for the specified Legal Entity  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1639,7 +1639,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def get_legal_entity_relations_with_http_info(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the legal entity identifier type.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity identifier type.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity under specified identifier type's scope and code. This together with stated identifier type uniquely              identifies the legal entity.")], effective_at : Annotated[Optional[constr(strict=True, max_length=256, min_length=0)], Field(description="The effective datetime or cut label at which to get relations. 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 legal entity's relations. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], Field(description="Expression to filter the relations. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifiers types (as property keys) used for referencing Persons or Legal Entities. These take the format              {domain}/{scope}/{code} e.g. \"Person/CompanyDetails/Role\". They must be from the \"Person\" or \"LegalEntity\" domain.              Only identifier types stated will be used to look up relevant entities in relations. If not applicable, provide an empty array.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] GetLegalEntityRelations: Get Relations for Legal Entity  # noqa: E501
+        """GetLegalEntityRelations: Get Relations for Legal Entity  # noqa: E501
 
         Get relations for the specified Legal Entity  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1798,7 +1798,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def get_legal_entity_relationships(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the legal entity's identifier type.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity's identifier type.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity under specified identifier type's scope and code. This together with stated identifier type uniquely              identifies the legal entity.")], effective_at : Annotated[Optional[constr(strict=True, max_length=256, min_length=0)], Field(description="The effective datetime or cut label at which to get relationships. 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 relationships. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], Field(description="Expression to filter relationships. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifier types (as property keys) used for referencing Persons or Legal Entities.              These can be specified from the 'Person' or 'LegalEntity' domains and have the format {domain}/{scope}/{code}, for example              'Person/CompanyDetails/Role'. An Empty array may be used to return all related Entities.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfRelationship, Awaitable[ResourceListOfRelationship]]:  # noqa: E501
-        """[EARLY ACCESS] GetLegalEntityRelationships: Get Relationships for Legal Entity  # noqa: E501
+        """GetLegalEntityRelationships: Get Relationships for Legal Entity  # noqa: E501
 
         Get Relationships for the specified Legal Entity  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1842,7 +1842,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def get_legal_entity_relationships_with_http_info(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the legal entity's identifier type.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity's identifier type.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity under specified identifier type's scope and code. This together with stated identifier type uniquely              identifies the legal entity.")], effective_at : Annotated[Optional[constr(strict=True, max_length=256, min_length=0)], Field(description="The effective datetime or cut label at which to get relationships. 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 relationships. Defaults to return the latest LUSID AsAt time if not specified.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], Field(description="Expression to filter relationships. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[conlist(StrictStr)], Field(description="Identifier types (as property keys) used for referencing Persons or Legal Entities.              These can be specified from the 'Person' or 'LegalEntity' domains and have the format {domain}/{scope}/{code}, for example              'Person/CompanyDetails/Role'. An Empty array may be used to return all related Entities.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] GetLegalEntityRelationships: Get Relationships for Legal Entity  # noqa: E501
+        """GetLegalEntityRelationships: Get Relationships for Legal Entity  # noqa: E501
 
         Get Relationships for the specified Legal Entity  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -2001,7 +2001,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def list_all_legal_entities(self, effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to list the legal entities. Defaults to the current LUSID              system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the legal entities. Defaults to return the latest version              of each legal entities if not specified.")] = None, page : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="The pagination token to use to continue listing legal entities from a previous call to list legal entities. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="When paginating, limit the number of returned results to this many. Defaults to 5000 if not specified.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], 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 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 or identifier types (as property keys) from the \"LegalEntity\" domain              to include for each legal entity, or from any domain that supports relationships to decorate onto related entities.              These take the format {domain}/{scope}/{code} e.g. \"LegalEntity/ContactDetails/Address\".")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto each portfolio in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfLegalEntity, Awaitable[ResourceListOfLegalEntity]]:  # noqa: E501
-        """[EARLY ACCESS] ListAllLegalEntities: List Legal Entities  # noqa: E501
+        """ListAllLegalEntities: List Legal Entities  # noqa: E501
 
         List all legal entities which the user is entitled to see.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -2047,7 +2047,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def list_all_legal_entities_with_http_info(self, effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to list the legal entities. Defaults to the current LUSID              system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the legal entities. Defaults to return the latest version              of each legal entities if not specified.")] = None, page : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="The pagination token to use to continue listing legal entities from a previous call to list legal entities. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True, le=5000, ge=1)], Field(description="When paginating, limit the number of returned results to this many. Defaults to 5000 if not specified.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], 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 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 or identifier types (as property keys) from the \"LegalEntity\" domain              to include for each legal entity, or from any domain that supports relationships to decorate onto related entities.              These take the format {domain}/{scope}/{code} e.g. \"LegalEntity/ContactDetails/Address\".")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto each portfolio in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] ListAllLegalEntities: List Legal Entities  # noqa: E501
+        """ListAllLegalEntities: List Legal Entities  # noqa: E501
 
         List all legal entities which the user is entitled to see.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -2214,7 +2214,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def list_legal_entities(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the legal entity identifier type.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity identifier type.")], effective_at : Annotated[Optional[constr(strict=True, max_length=256, min_length=0)], Field(description="The effective datetime or cut label at which to list the people. Defaults to the current LUSID              system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the people. Defaults to return the latest version              of each people if not specified.")] = None, page : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="The pagination token to use to continue listing legal entities from a previous call to list legal entities. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True, 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[constr(strict=True, max_length=16384, min_length=0)], 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 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 or identifier types (as property keys) from the \"LegalEntity\" domain              to include for each legal entity, or from any domain that supports relationships to decorate onto related entities.              These take the format {domain}/{scope}/{code} e.g. \"LegalEntity/ContactDetails/Address\".")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto each portfolio in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfLegalEntity, Awaitable[PagedResourceListOfLegalEntity]]:  # noqa: E501
-        """[EARLY ACCESS] ListLegalEntities: List Legal Entities  # noqa: E501
+        """ListLegalEntities: List Legal Entities  # noqa: E501
 
         List legal entities which has identifier of specific identifier type's scope and code, and satisfies filter criteria.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -2264,7 +2264,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def list_legal_entities_with_http_info(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the legal entity identifier type.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity identifier type.")], effective_at : Annotated[Optional[constr(strict=True, max_length=256, min_length=0)], Field(description="The effective datetime or cut label at which to list the people. Defaults to the current LUSID              system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the people. Defaults to return the latest version              of each people if not specified.")] = None, page : Annotated[Optional[constr(strict=True, max_length=500, min_length=1)], Field(description="The pagination token to use to continue listing legal entities from a previous call to list legal entities. This  value is returned from the previous call. If a pagination token is provided the filter, effectiveAt, sortBy  and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True, 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[constr(strict=True, max_length=16384, min_length=0)], 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 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 or identifier types (as property keys) from the \"LegalEntity\" domain              to include for each legal entity, or from any domain that supports relationships to decorate onto related entities.              These take the format {domain}/{scope}/{code} e.g. \"LegalEntity/ContactDetails/Address\".")] = None, relationship_definition_ids : Annotated[Optional[conlist(StrictStr)], Field(description="A list of relationship definitions that are used to decorate related entities              onto each portfolio in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] ListLegalEntities: List Legal Entities  # noqa: E501
+        """ListLegalEntities: List Legal Entities  # noqa: E501
 
         List legal entities which has identifier of specific identifier type's scope and code, and satisfies filter criteria.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -2826,7 +2826,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def set_legal_entity_properties(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the legal entity identifier type.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity identifier type.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity under specified identifier type's scope and code. This together with stated identifier type uniquely              identifies the legal entity.")], set_legal_entity_properties_request : Annotated[SetLegalEntityPropertiesRequest, Field(..., description="Request containing properties to set for the legal entity. Properties not specified in request will not be changed.")], async_req: Optional[bool]=None, **kwargs) -> Union[LegalEntity, Awaitable[LegalEntity]]:  # noqa: E501
-        """[EARLY ACCESS] SetLegalEntityProperties: Set Legal Entity Properties  # noqa: E501
+        """SetLegalEntityProperties: Set Legal Entity Properties  # noqa: E501
 
         Set properties of the legal entity.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -2864,7 +2864,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def set_legal_entity_properties_with_http_info(self, id_type_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Scope of the legal entity identifier type.")], id_type_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity identifier type.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="Code of the legal entity under specified identifier type's scope and code. This together with stated identifier type uniquely              identifies the legal entity.")], set_legal_entity_properties_request : Annotated[SetLegalEntityPropertiesRequest, Field(..., description="Request containing properties to set for the legal entity. Properties not specified in request will not be changed.")], **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] SetLegalEntityProperties: Set Legal Entity Properties  # noqa: E501
+        """SetLegalEntityProperties: Set Legal Entity Properties  # noqa: E501
 
         Set properties of the legal entity.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -3174,7 +3174,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def upsert_legal_entity(self, upsert_legal_entity_request : Annotated[UpsertLegalEntityRequest, Field(..., description="Request to create or update a legal entity.")], async_req: Optional[bool]=None, **kwargs) -> Union[LegalEntity, Awaitable[LegalEntity]]:  # noqa: E501
-        """[EARLY ACCESS] UpsertLegalEntity: Upsert Legal Entity  # noqa: E501
+        """UpsertLegalEntity: Upsert Legal Entity  # noqa: E501
 
         Create or update a legal entity  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -3206,7 +3206,7 @@ class LegalEntitiesApi:
 
     @validate_arguments
     def upsert_legal_entity_with_http_info(self, upsert_legal_entity_request : Annotated[UpsertLegalEntityRequest, Field(..., description="Request to create or update a legal entity.")], **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] UpsertLegalEntity: Upsert Legal Entity  # noqa: E501
+        """UpsertLegalEntity: Upsert Legal Entity  # noqa: E501
 
         Create or update a legal entity  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an