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

lusid/api/custom_entities_api.py

@@ -19,13 +19,10 @@ import warnings
 from pydantic.v1 import validate_arguments, ValidationError
 from typing import overload, Optional, Union, Awaitable
 
-from typing_extensions import Annotated
 from datetime import datetime
-
-from pydantic.v1 import Field, StrictStr, conint, conlist, constr, validator
-
+from pydantic.v1 import Field, StrictInt, StrictStr
 from typing import Dict, List, Optional
-
+from typing_extensions import Annotated
 from lusid.models.access_metadata_operation import AccessMetadataOperation
 from lusid.models.access_metadata_value import AccessMetadataValue
 from lusid.models.custom_entity_properties import CustomEntityProperties
@@ -833,15 +830,15 @@ class CustomEntitiesApi:
 
 
     @overload
-    async def get_custom_entity(self, entity_type : Annotated[StrictStr, Field(..., description="The type of Custom Entity to retrieve. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], identifier_scope : Annotated[StrictStr, 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustomEntity' domain to decorate onto              the custom entities of any type supported by that property (defined within the property definition CustomEntityTypes).              These must have the format {domain}/{scope}/{code}, for example 'CustomEntity/someScope/id'.")] = None, **kwargs) -> CustomEntityResponse:  # noqa: E501
+    async def get_custom_entity(self, entity_type : Annotated[StrictStr, Field(..., description="The type of Custom Entity to retrieve. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], identifier_scope : Annotated[StrictStr, 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[List[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[List[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, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'CustomEntity' domain to decorate onto              the custom entities of any type supported by that property (defined within the property definition CustomEntityTypes).              These must have the format {domain}/{scope}/{code}, for example 'CustomEntity/someScope/id'.")] = None, **kwargs) -> CustomEntityResponse:  # noqa: E501
         ...
 
     @overload
-    def get_custom_entity(self, entity_type : Annotated[StrictStr, Field(..., description="The type of Custom Entity to retrieve. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], identifier_scope : Annotated[StrictStr, 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustomEntity' domain to decorate onto              the custom entities of any type supported by that property (defined within the property definition CustomEntityTypes).              These must have the format {domain}/{scope}/{code}, for example 'CustomEntity/someScope/id'.")] = None, async_req: Optional[bool]=True, **kwargs) -> CustomEntityResponse:  # noqa: E501
+    def get_custom_entity(self, entity_type : Annotated[StrictStr, Field(..., description="The type of Custom Entity to retrieve. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], identifier_scope : Annotated[StrictStr, 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[List[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[List[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, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'CustomEntity' domain to decorate onto              the custom entities of any type supported by that property (defined within the property definition CustomEntityTypes).              These must have the format {domain}/{scope}/{code}, for example 'CustomEntity/someScope/id'.")] = None, async_req: Optional[bool]=True, **kwargs) -> CustomEntityResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_custom_entity(self, entity_type : Annotated[StrictStr, Field(..., description="The type of Custom Entity to retrieve. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], identifier_scope : Annotated[StrictStr, 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustomEntity' domain to decorate onto              the custom entities of any type supported by that property (defined within the property definition CustomEntityTypes).              These must have the format {domain}/{scope}/{code}, for example 'CustomEntity/someScope/id'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[CustomEntityResponse, Awaitable[CustomEntityResponse]]:  # noqa: E501
+    def get_custom_entity(self, entity_type : Annotated[StrictStr, Field(..., description="The type of Custom Entity to retrieve. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], identifier_scope : Annotated[StrictStr, 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[List[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[List[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, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'CustomEntity' domain to decorate onto              the custom entities of any type supported by that property (defined within the property definition CustomEntityTypes).              These must have the format {domain}/{scope}/{code}, for example 'CustomEntity/someScope/id'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[CustomEntityResponse, Awaitable[CustomEntityResponse]]:  # 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
@@ -888,7 +885,7 @@ class CustomEntitiesApi:
         return self.get_custom_entity_with_http_info(entity_type, identifier_type, identifier_value, identifier_scope, as_at, effective_at, related_entity_property_keys, relationship_definition_ids, property_keys, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_custom_entity_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The type of Custom Entity to retrieve. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], identifier_scope : Annotated[StrictStr, 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustomEntity' domain to decorate onto              the custom entities of any type supported by that property (defined within the property definition CustomEntityTypes).              These must have the format {domain}/{scope}/{code}, for example 'CustomEntity/someScope/id'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_custom_entity_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The type of Custom Entity to retrieve. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], identifier_scope : Annotated[StrictStr, 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[List[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[List[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, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'CustomEntity' domain to decorate onto              the custom entities of any type supported by that property (defined within the property definition CustomEntityTypes).              These must have the format {domain}/{scope}/{code}, for example 'CustomEntity/someScope/id'.")] = None, **kwargs) -> ApiResponse:  # 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
@@ -1258,15 +1255,15 @@ class CustomEntitiesApi:
 
 
     @overload
-    async def get_custom_entity_relationships(self, entity_type : Annotated[StrictStr, Field(..., description="The type of entity get relationships for.")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], effective_at : Annotated[Optional[StrictStr], 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[StrictStr], 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="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 relationships. If not applicable, provide an empty array.")] = None, **kwargs) -> ResourceListOfRelationship:  # noqa: E501
+    async def get_custom_entity_relationships(self, entity_type : Annotated[StrictStr, Field(..., description="The type of entity get relationships for.")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], effective_at : Annotated[Optional[StrictStr], 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[StrictStr], Field( description="Expression to filter relationships. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[List[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 relationships. If not applicable, provide an empty array.")] = None, **kwargs) -> ResourceListOfRelationship:  # noqa: E501
         ...
 
     @overload
-    def get_custom_entity_relationships(self, entity_type : Annotated[StrictStr, Field(..., description="The type of entity get relationships for.")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], effective_at : Annotated[Optional[StrictStr], 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[StrictStr], 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="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 relationships. If not applicable, provide an empty array.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfRelationship:  # noqa: E501
+    def get_custom_entity_relationships(self, entity_type : Annotated[StrictStr, Field(..., description="The type of entity get relationships for.")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], effective_at : Annotated[Optional[StrictStr], 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[StrictStr], Field( description="Expression to filter relationships. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[List[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 relationships. If not applicable, provide an empty array.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfRelationship:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_custom_entity_relationships(self, entity_type : Annotated[StrictStr, Field(..., description="The type of entity get relationships for.")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], effective_at : Annotated[Optional[StrictStr], 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[StrictStr], 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="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 relationships. If not applicable, provide an empty array.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfRelationship, Awaitable[ResourceListOfRelationship]]:  # noqa: E501
+    def get_custom_entity_relationships(self, entity_type : Annotated[StrictStr, Field(..., description="The type of entity get relationships for.")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], effective_at : Annotated[Optional[StrictStr], 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[StrictStr], Field( description="Expression to filter relationships. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[List[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 relationships. If not applicable, provide an empty array.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfRelationship, Awaitable[ResourceListOfRelationship]]:  # noqa: E501
         """[EARLY ACCESS] GetCustomEntityRelationships: Get Relationships for Custom Entity  # noqa: E501
 
         Get relationships for the specified Custom Entity.  # noqa: E501
@@ -1311,7 +1308,7 @@ class CustomEntitiesApi:
         return self.get_custom_entity_relationships_with_http_info(entity_type, identifier_scope, identifier_type, identifier_value, effective_at, as_at, filter, identifier_types, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_custom_entity_relationships_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The type of entity get relationships for.")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], effective_at : Annotated[Optional[StrictStr], 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[StrictStr], 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="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 relationships. If not applicable, provide an empty array.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_custom_entity_relationships_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The type of entity get relationships for.")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], effective_at : Annotated[Optional[StrictStr], 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[StrictStr], Field( description="Expression to filter relationships. Users should provide null or empty string for this field until further notice.")] = None, identifier_types : Annotated[Optional[List[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 relationships. If not applicable, provide an empty array.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] GetCustomEntityRelationships: Get Relationships for Custom Entity  # noqa: E501
 
         Get relationships for the specified Custom Entity.  # noqa: E501
@@ -1470,15 +1467,15 @@ class CustomEntitiesApi:
 
 
     @overload
-    async def list_custom_entities(self, entity_type : Annotated[StrictStr, 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)], 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 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[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, 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustomEntity' domain to decorate onto              the custom entities of any type supported by that property (defined within the property definition CustomEntityTypes).              These must have the format {domain}/{scope}/{code}, for example 'CustomEntity/someScope/id'.")] = None, **kwargs) -> PagedResourceListOfCustomEntityResponse:  # noqa: E501
+    async def list_custom_entities(self, entity_type : Annotated[StrictStr, 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[StrictInt], 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 more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = 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, related_entity_property_keys : Annotated[Optional[List[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[List[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, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'CustomEntity' domain to decorate onto              the custom entities of any type supported by that property (defined within the property definition CustomEntityTypes).              These must have the format {domain}/{scope}/{code}, for example 'CustomEntity/someScope/id'.")] = None, **kwargs) -> PagedResourceListOfCustomEntityResponse:  # noqa: E501
         ...
 
     @overload
-    def list_custom_entities(self, entity_type : Annotated[StrictStr, 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)], 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 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[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, 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustomEntity' domain to decorate onto              the custom entities of any type supported by that property (defined within the property definition CustomEntityTypes).              These must have the format {domain}/{scope}/{code}, for example 'CustomEntity/someScope/id'.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfCustomEntityResponse:  # noqa: E501
+    def list_custom_entities(self, entity_type : Annotated[StrictStr, 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[StrictInt], 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 more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = 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, related_entity_property_keys : Annotated[Optional[List[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[List[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, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'CustomEntity' domain to decorate onto              the custom entities of any type supported by that property (defined within the property definition CustomEntityTypes).              These must have the format {domain}/{scope}/{code}, for example 'CustomEntity/someScope/id'.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfCustomEntityResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_custom_entities(self, entity_type : Annotated[StrictStr, 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)], 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 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[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, 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustomEntity' domain to decorate onto              the custom entities of any type supported by that property (defined within the property definition CustomEntityTypes).              These must have the format {domain}/{scope}/{code}, for example 'CustomEntity/someScope/id'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfCustomEntityResponse, Awaitable[PagedResourceListOfCustomEntityResponse]]:  # noqa: E501
+    def list_custom_entities(self, entity_type : Annotated[StrictStr, 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[StrictInt], 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 more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = 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, related_entity_property_keys : Annotated[Optional[List[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[List[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, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'CustomEntity' domain to decorate onto              the custom entities of any type supported by that property (defined within the property definition CustomEntityTypes).              These must have the format {domain}/{scope}/{code}, for example 'CustomEntity/someScope/id'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfCustomEntityResponse, Awaitable[PagedResourceListOfCustomEntityResponse]]:  # noqa: E501
         """ListCustomEntities: List Custom Entities of the specified entityType.  # noqa: E501
 
         List all the Custom Entities matching particular criteria.  # noqa: E501
@@ -1527,7 +1524,7 @@ class CustomEntitiesApi:
         return self.list_custom_entities_with_http_info(entity_type, effective_at, as_at, limit, filter, sort_by, page, related_entity_property_keys, relationship_definition_ids, property_keys, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_custom_entities_with_http_info(self, entity_type : Annotated[StrictStr, 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)], 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 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[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, 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, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustomEntity' domain to decorate onto              the custom entities of any type supported by that property (defined within the property definition CustomEntityTypes).              These must have the format {domain}/{scope}/{code}, for example 'CustomEntity/someScope/id'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_custom_entities_with_http_info(self, entity_type : Annotated[StrictStr, 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[StrictInt], 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 more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[List[StrictStr]], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\".")] = 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, related_entity_property_keys : Annotated[Optional[List[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[List[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, property_keys : Annotated[Optional[List[StrictStr]], Field(description="A list of property keys from the 'CustomEntity' domain to decorate onto              the custom entities of any type supported by that property (defined within the property definition CustomEntityTypes).              These must have the format {domain}/{scope}/{code}, for example 'CustomEntity/someScope/id'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """ListCustomEntities: List Custom Entities of the specified entityType.  # noqa: E501
 
         List all the Custom Entities matching particular criteria.  # noqa: E501
@@ -1701,15 +1698,15 @@ class CustomEntitiesApi:
 
 
     @overload
-    async def patch_custom_entity_access_metadata(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], access_metadata_operation : Annotated[conlist(AccessMetadataOperation), Field(..., description="The Json Patch document")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which the Access Metadata will be effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, **kwargs) -> Dict[str, List[AccessMetadataValue]]:  # noqa: E501
+    async def patch_custom_entity_access_metadata(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], access_metadata_operation : Annotated[List[AccessMetadataOperation], Field(description="The Json Patch document")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which the Access Metadata will be effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, **kwargs) -> Dict[str, List[AccessMetadataValue]]:  # noqa: E501
         ...
 
     @overload
-    def patch_custom_entity_access_metadata(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], access_metadata_operation : Annotated[conlist(AccessMetadataOperation), Field(..., description="The Json Patch document")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which the Access Metadata will be effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, async_req: Optional[bool]=True, **kwargs) -> Dict[str, List[AccessMetadataValue]]:  # noqa: E501
+    def patch_custom_entity_access_metadata(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], access_metadata_operation : Annotated[List[AccessMetadataOperation], Field(description="The Json Patch document")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which the Access Metadata will be effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, async_req: Optional[bool]=True, **kwargs) -> Dict[str, List[AccessMetadataValue]]:  # noqa: E501
         ...
 
     @validate_arguments
-    def patch_custom_entity_access_metadata(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], access_metadata_operation : Annotated[conlist(AccessMetadataOperation), Field(..., description="The Json Patch document")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which the Access Metadata will be effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Dict[str, List[AccessMetadataValue]], Awaitable[Dict[str, List[AccessMetadataValue]]]]:  # noqa: E501
+    def patch_custom_entity_access_metadata(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], access_metadata_operation : Annotated[List[AccessMetadataOperation], Field(description="The Json Patch document")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which the Access Metadata will be effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Dict[str, List[AccessMetadataValue]], Awaitable[Dict[str, List[AccessMetadataValue]]]]:  # noqa: E501
         """[EARLY ACCESS] PatchCustomEntityAccessMetadata: Patch Access Metadata rules for a Custom Entity.  # noqa: E501
 
         Patch Custom Entity Access Metadata Rules in a single scope.  The behaviour is defined by the JSON Patch specification.                Currently only 'add' is a supported operation on the patch document    Currently only valid metadata keys are supported paths on the patch document                The response will return any affected Custom Entity Access Metadata rules or a failure message if unsuccessful.                It is important to always check to verify success (or failure).                Multiple rules for a metadataKey can exist with different effective at dates, when resources are accessed the rule that is active for the current time will be fetched.  # noqa: E501
@@ -1752,7 +1749,7 @@ class CustomEntitiesApi:
         return self.patch_custom_entity_access_metadata_with_http_info(entity_type, identifier_type, identifier_value, identifier_scope, access_metadata_operation, effective_at, effective_until, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def patch_custom_entity_access_metadata_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], access_metadata_operation : Annotated[conlist(AccessMetadataOperation), Field(..., description="The Json Patch document")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which the Access Metadata will be effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def patch_custom_entity_access_metadata_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], access_metadata_operation : Annotated[List[AccessMetadataOperation], Field(description="The Json Patch document")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which the Access Metadata will be effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] PatchCustomEntityAccessMetadata: Patch Access Metadata rules for a Custom Entity.  # noqa: E501
 
         Patch Custom Entity Access Metadata Rules in a single scope.  The behaviour is defined by the JSON Patch specification.                Currently only 'add' is a supported operation on the patch document    Currently only valid metadata keys are supported paths on the patch document                The response will return any affected Custom Entity Access Metadata rules or a failure message if unsuccessful.                It is important to always check to verify success (or failure).                Multiple rules for a metadataKey can exist with different effective at dates, when resources are accessed the rule that is active for the current time will be fetched.  # noqa: E501
@@ -1911,15 +1908,15 @@ class CustomEntitiesApi:
 
 
     @overload
-    async def upsert_custom_entities(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity to be created. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], success_mode : Annotated[StrictStr, Field(..., description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial")], request_body : Annotated[Dict[str, CustomEntityRequest], Field(..., description="The payload describing the Custom Entity instances")], **kwargs) -> UpsertCustomEntitiesResponse:  # noqa: E501
+    async def upsert_custom_entities(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity to be created. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], success_mode : Annotated[StrictStr, Field(..., description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial")], request_body : Annotated[Dict[str, CustomEntityRequest], Field(description="The payload describing the Custom Entity instances")], **kwargs) -> UpsertCustomEntitiesResponse:  # noqa: E501
         ...
 
     @overload
-    def upsert_custom_entities(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity to be created. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], success_mode : Annotated[StrictStr, Field(..., description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial")], request_body : Annotated[Dict[str, CustomEntityRequest], Field(..., description="The payload describing the Custom Entity instances")], async_req: Optional[bool]=True, **kwargs) -> UpsertCustomEntitiesResponse:  # noqa: E501
+    def upsert_custom_entities(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity to be created. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], success_mode : Annotated[StrictStr, Field(..., description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial")], request_body : Annotated[Dict[str, CustomEntityRequest], Field(description="The payload describing the Custom Entity instances")], async_req: Optional[bool]=True, **kwargs) -> UpsertCustomEntitiesResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def upsert_custom_entities(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity to be created. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], success_mode : Annotated[StrictStr, Field(..., description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial")], request_body : Annotated[Dict[str, CustomEntityRequest], Field(..., description="The payload describing the Custom Entity instances")], async_req: Optional[bool]=None, **kwargs) -> Union[UpsertCustomEntitiesResponse, Awaitable[UpsertCustomEntitiesResponse]]:  # noqa: E501
+    def upsert_custom_entities(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity to be created. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], success_mode : Annotated[StrictStr, Field(..., description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial")], request_body : Annotated[Dict[str, CustomEntityRequest], Field(description="The payload describing the Custom Entity instances")], async_req: Optional[bool]=None, **kwargs) -> Union[UpsertCustomEntitiesResponse, Awaitable[UpsertCustomEntitiesResponse]]:  # noqa: E501
         """[EARLY ACCESS] UpsertCustomEntities: Batch upsert instances of Custom Entities  # noqa: E501
 
         Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code  # noqa: E501
@@ -1954,7 +1951,7 @@ class CustomEntitiesApi:
         return self.upsert_custom_entities_with_http_info(entity_type, success_mode, request_body, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def upsert_custom_entities_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity to be created. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], success_mode : Annotated[StrictStr, Field(..., description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial")], request_body : Annotated[Dict[str, CustomEntityRequest], Field(..., description="The payload describing the Custom Entity instances")], **kwargs) -> ApiResponse:  # noqa: E501
+    def upsert_custom_entities_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity to be created. An entityType can be created using the \"CreateCustomEntityDefinition\" endpoint for CustomEntityDefinitions.")], success_mode : Annotated[StrictStr, Field(..., description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial")], request_body : Annotated[Dict[str, CustomEntityRequest], Field(description="The payload describing the Custom Entity instances")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] UpsertCustomEntities: Batch upsert instances of Custom Entities  # noqa: E501
 
         Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code  # noqa: E501
@@ -2086,15 +2083,15 @@ class CustomEntitiesApi:
 
 
     @overload
-    async def upsert_custom_entity(self, entity_type : Annotated[StrictStr, 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) -> CustomEntityResponse:  # noqa: E501
+    async def upsert_custom_entity(self, entity_type : Annotated[StrictStr, 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) -> CustomEntityResponse:  # noqa: E501
         ...
 
     @overload
-    def upsert_custom_entity(self, entity_type : Annotated[StrictStr, 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]=True, **kwargs) -> CustomEntityResponse:  # noqa: E501
+    def upsert_custom_entity(self, entity_type : Annotated[StrictStr, 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]=True, **kwargs) -> CustomEntityResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def upsert_custom_entity(self, entity_type : Annotated[StrictStr, 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
+    def upsert_custom_entity(self, entity_type : Annotated[StrictStr, 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
         """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
@@ -2127,7 +2124,7 @@ class CustomEntitiesApi:
         return self.upsert_custom_entity_with_http_info(entity_type, custom_entity_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def upsert_custom_entity_with_http_info(self, entity_type : Annotated[StrictStr, 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
+    def upsert_custom_entity_with_http_info(self, entity_type : Annotated[StrictStr, 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
         """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
@@ -2253,15 +2250,15 @@ class CustomEntitiesApi:
 
 
     @overload
-    async def upsert_custom_entity_access_metadata(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], metadata_key : Annotated[StrictStr, Field(..., description="Key of the metadata entry to retrieve")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], upsert_custom_entity_access_metadata_request : Annotated[UpsertCustomEntityAccessMetadataRequest, Field(..., description="The Custom Entity Access Metadata entry to upsert")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which the Access Metadata will be effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, **kwargs) -> List[AccessMetadataValue]:  # noqa: E501
+    async def upsert_custom_entity_access_metadata(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], metadata_key : Annotated[StrictStr, Field(..., description="Key of the metadata entry to retrieve")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], upsert_custom_entity_access_metadata_request : Annotated[UpsertCustomEntityAccessMetadataRequest, Field(description="The Custom Entity Access Metadata entry to upsert")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which the Access Metadata will be effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, **kwargs) -> List[AccessMetadataValue]:  # noqa: E501
         ...
 
     @overload
-    def upsert_custom_entity_access_metadata(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], metadata_key : Annotated[StrictStr, Field(..., description="Key of the metadata entry to retrieve")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], upsert_custom_entity_access_metadata_request : Annotated[UpsertCustomEntityAccessMetadataRequest, Field(..., description="The Custom Entity Access Metadata entry to upsert")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which the Access Metadata will be effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, async_req: Optional[bool]=True, **kwargs) -> List[AccessMetadataValue]:  # noqa: E501
+    def upsert_custom_entity_access_metadata(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], metadata_key : Annotated[StrictStr, Field(..., description="Key of the metadata entry to retrieve")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], upsert_custom_entity_access_metadata_request : Annotated[UpsertCustomEntityAccessMetadataRequest, Field(description="The Custom Entity Access Metadata entry to upsert")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which the Access Metadata will be effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, async_req: Optional[bool]=True, **kwargs) -> List[AccessMetadataValue]:  # noqa: E501
         ...
 
     @validate_arguments
-    def upsert_custom_entity_access_metadata(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], metadata_key : Annotated[StrictStr, Field(..., description="Key of the metadata entry to retrieve")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], upsert_custom_entity_access_metadata_request : Annotated[UpsertCustomEntityAccessMetadataRequest, Field(..., description="The Custom Entity Access Metadata entry to upsert")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which the Access Metadata will be effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[List[AccessMetadataValue], Awaitable[List[AccessMetadataValue]]]:  # noqa: E501
+    def upsert_custom_entity_access_metadata(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], metadata_key : Annotated[StrictStr, Field(..., description="Key of the metadata entry to retrieve")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], upsert_custom_entity_access_metadata_request : Annotated[UpsertCustomEntityAccessMetadataRequest, Field(description="The Custom Entity Access Metadata entry to upsert")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which the Access Metadata will be effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[List[AccessMetadataValue], Awaitable[List[AccessMetadataValue]]]:  # noqa: E501
         """[EARLY ACCESS] UpsertCustomEntityAccessMetadata: Upsert a Custom Entity Access Metadata entry associated with a specific metadataKey. This creates or updates the data in LUSID.  # noqa: E501
 
         Update or insert one Custom Entity Access Metadata entry in a single scope. An item will be updated if it already exists  and inserted if it does not.                The response will return the successfully updated or inserted Custom Entity Access Metadata rule or failure message if unsuccessful.                It is important to always check to verify success (or failure).                Multiple rules for a metadataKey can exist with different effective at dates, when resources are accessed the rule that is active for the current time will be fetched.  # noqa: E501
@@ -2306,7 +2303,7 @@ class CustomEntitiesApi:
         return self.upsert_custom_entity_access_metadata_with_http_info(entity_type, identifier_type, identifier_value, metadata_key, identifier_scope, upsert_custom_entity_access_metadata_request, effective_at, effective_until, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def upsert_custom_entity_access_metadata_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], metadata_key : Annotated[StrictStr, Field(..., description="Key of the metadata entry to retrieve")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], upsert_custom_entity_access_metadata_request : Annotated[UpsertCustomEntityAccessMetadataRequest, Field(..., description="The Custom Entity Access Metadata entry to upsert")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which the Access Metadata will be effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def upsert_custom_entity_access_metadata_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The type of the Custom Entity.")], identifier_type : Annotated[StrictStr, Field(..., description="An identifier type attached to the Custom Entity instance.")], identifier_value : Annotated[StrictStr, Field(..., description="The identifier value.")], metadata_key : Annotated[StrictStr, Field(..., description="Key of the metadata entry to retrieve")], identifier_scope : Annotated[StrictStr, Field(..., description="The identifier scope.")], upsert_custom_entity_access_metadata_request : Annotated[UpsertCustomEntityAccessMetadataRequest, Field(description="The Custom Entity Access Metadata entry to upsert")], effective_at : Annotated[Optional[StrictStr], Field( description="The effectiveAt datetime at which the Access Metadata will be effective from")] = None, effective_until : Annotated[Optional[datetime], Field(description="The effective datetime until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveAt' datetime of the Access Metadata")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] UpsertCustomEntityAccessMetadata: Upsert a Custom Entity Access Metadata entry associated with a specific metadataKey. This creates or updates the data in LUSID.  # noqa: E501
 
         Update or insert one Custom Entity Access Metadata entry in a single scope. An item will be updated if it already exists  and inserted if it does not.                The response will return the successfully updated or inserted Custom Entity Access Metadata rule or failure message if unsuccessful.                It is important to always check to verify success (or failure).                Multiple rules for a metadataKey can exist with different effective at dates, when resources are accessed the rule that is active for the current time will be fetched.  # noqa: E501

lusid/api/custom_entity_definitions_api.py

@@ -19,13 +19,10 @@ import warnings
 from pydantic.v1 import validate_arguments, ValidationError
 from typing import overload, Optional, Union, Awaitable
 
-from typing_extensions import Annotated
 from datetime import datetime
-
-from pydantic.v1 import Field, conint, constr, validator
-
+from pydantic.v1 import Field, StrictInt, StrictStr
 from typing import Optional
-
+from typing_extensions import Annotated
 from lusid.models.custom_entity_definition import CustomEntityDefinition
 from lusid.models.custom_entity_definition_request import CustomEntityDefinitionRequest
 from lusid.models.paged_resource_list_of_custom_entity_definition import PagedResourceListOfCustomEntityDefinition
@@ -58,15 +55,15 @@ class CustomEntityDefinitionsApi:
 
 
     @overload
-    async def create_custom_entity_definition(self, custom_entity_definition_request : Annotated[CustomEntityDefinitionRequest, Field(..., description="The payload containing the description of the Custom Entity type.")], **kwargs) -> CustomEntityDefinition:  # noqa: E501
+    async def create_custom_entity_definition(self, custom_entity_definition_request : Annotated[CustomEntityDefinitionRequest, Field(description="The payload containing the description of the Custom Entity type.")], **kwargs) -> CustomEntityDefinition:  # noqa: E501
         ...
 
     @overload
-    def create_custom_entity_definition(self, custom_entity_definition_request : Annotated[CustomEntityDefinitionRequest, Field(..., description="The payload containing the description of the Custom Entity type.")], async_req: Optional[bool]=True, **kwargs) -> CustomEntityDefinition:  # noqa: E501
+    def create_custom_entity_definition(self, custom_entity_definition_request : Annotated[CustomEntityDefinitionRequest, Field(description="The payload containing the description of the Custom Entity type.")], async_req: Optional[bool]=True, **kwargs) -> CustomEntityDefinition:  # noqa: E501
         ...
 
     @validate_arguments
-    def create_custom_entity_definition(self, custom_entity_definition_request : Annotated[CustomEntityDefinitionRequest, Field(..., description="The payload containing the description of the Custom Entity type.")], async_req: Optional[bool]=None, **kwargs) -> Union[CustomEntityDefinition, Awaitable[CustomEntityDefinition]]:  # noqa: E501
+    def create_custom_entity_definition(self, custom_entity_definition_request : Annotated[CustomEntityDefinitionRequest, Field(description="The payload containing the description of the Custom Entity type.")], async_req: Optional[bool]=None, **kwargs) -> Union[CustomEntityDefinition, Awaitable[CustomEntityDefinition]]:  # noqa: E501
         """[EARLY ACCESS] CreateCustomEntityDefinition: Define a new Custom Entity type.  # noqa: E501
 
         The API will return a Bad Request if the Custom Entity type already exists.  # noqa: E501
@@ -97,7 +94,7 @@ class CustomEntityDefinitionsApi:
         return self.create_custom_entity_definition_with_http_info(custom_entity_definition_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def create_custom_entity_definition_with_http_info(self, custom_entity_definition_request : Annotated[CustomEntityDefinitionRequest, Field(..., description="The payload containing the description of the Custom Entity type.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def create_custom_entity_definition_with_http_info(self, custom_entity_definition_request : Annotated[CustomEntityDefinitionRequest, Field(description="The payload containing the description of the Custom Entity type.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] CreateCustomEntityDefinition: Define a new Custom Entity type.  # noqa: E501
 
         The API will return a Bad Request if the Custom Entity type already exists.  # noqa: E501
@@ -380,15 +377,15 @@ class CustomEntityDefinitionsApi:
 
 
     @overload
-    async def list_custom_entity_definitions(self, 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)], 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 more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = 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, limit              and asAt fields must not have changed since the original request.")] = None, **kwargs) -> PagedResourceListOfCustomEntityDefinition:  # noqa: E501
+    async def list_custom_entity_definitions(self, 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[StrictInt], 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 more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = 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, limit              and asAt fields must not have changed since the original request.")] = None, **kwargs) -> PagedResourceListOfCustomEntityDefinition:  # noqa: E501
         ...
 
     @overload
-    def list_custom_entity_definitions(self, 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)], 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 more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = 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, limit              and asAt fields must not have changed since the original request.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfCustomEntityDefinition:  # noqa: E501
+    def list_custom_entity_definitions(self, 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[StrictInt], 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 more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = 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, limit              and asAt fields must not have changed since the original request.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfCustomEntityDefinition:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_custom_entity_definitions(self, 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)], 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 more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = 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, limit              and asAt fields must not have changed since the original request.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfCustomEntityDefinition, Awaitable[PagedResourceListOfCustomEntityDefinition]]:  # noqa: E501
+    def list_custom_entity_definitions(self, 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[StrictInt], 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 more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = 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, limit              and asAt fields must not have changed since the original request.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfCustomEntityDefinition, Awaitable[PagedResourceListOfCustomEntityDefinition]]:  # noqa: E501
         """[EARLY ACCESS] ListCustomEntityDefinitions: List the Custom Entity type definitions  # noqa: E501
 
         List all Custom Entity type definitions matching particular criteria.  # noqa: E501
@@ -425,7 +422,7 @@ class CustomEntityDefinitionsApi:
         return self.list_custom_entity_definitions_with_http_info(as_at, limit, filter, page, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_custom_entity_definitions_with_http_info(self, 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)], 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 more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = 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, limit              and asAt fields must not have changed since the original request.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_custom_entity_definitions_with_http_info(self, 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[StrictInt], 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 more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = 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, limit              and asAt fields must not have changed since the original request.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] ListCustomEntityDefinitions: List the Custom Entity type definitions  # noqa: E501
 
         List all Custom Entity type definitions matching particular criteria.  # noqa: E501
@@ -559,15 +556,15 @@ class CustomEntityDefinitionsApi:
 
 
     @overload
-    async def update_custom_entity_definition(self, entity_type : Annotated[StrictStr, Field(..., description="The identifier for the Custom Entity type, derived from the \"entityTypeName\" provided on creation.")], update_custom_entity_definition_request : Annotated[UpdateCustomEntityDefinitionRequest, Field(..., description="The payload containing the description of the Custom Entity type.")], **kwargs) -> CustomEntityDefinition:  # noqa: E501
+    async def update_custom_entity_definition(self, entity_type : Annotated[StrictStr, Field(..., description="The identifier for the Custom Entity type, derived from the \"entityTypeName\" provided on creation.")], update_custom_entity_definition_request : Annotated[UpdateCustomEntityDefinitionRequest, Field(description="The payload containing the description of the Custom Entity type.")], **kwargs) -> CustomEntityDefinition:  # noqa: E501
         ...
 
     @overload
-    def update_custom_entity_definition(self, entity_type : Annotated[StrictStr, Field(..., description="The identifier for the Custom Entity type, derived from the \"entityTypeName\" provided on creation.")], update_custom_entity_definition_request : Annotated[UpdateCustomEntityDefinitionRequest, Field(..., description="The payload containing the description of the Custom Entity type.")], async_req: Optional[bool]=True, **kwargs) -> CustomEntityDefinition:  # noqa: E501
+    def update_custom_entity_definition(self, entity_type : Annotated[StrictStr, Field(..., description="The identifier for the Custom Entity type, derived from the \"entityTypeName\" provided on creation.")], update_custom_entity_definition_request : Annotated[UpdateCustomEntityDefinitionRequest, Field(description="The payload containing the description of the Custom Entity type.")], async_req: Optional[bool]=True, **kwargs) -> CustomEntityDefinition:  # noqa: E501
         ...
 
     @validate_arguments
-    def update_custom_entity_definition(self, entity_type : Annotated[StrictStr, Field(..., description="The identifier for the Custom Entity type, derived from the \"entityTypeName\" provided on creation.")], update_custom_entity_definition_request : Annotated[UpdateCustomEntityDefinitionRequest, Field(..., description="The payload containing the description of the Custom Entity type.")], async_req: Optional[bool]=None, **kwargs) -> Union[CustomEntityDefinition, Awaitable[CustomEntityDefinition]]:  # noqa: E501
+    def update_custom_entity_definition(self, entity_type : Annotated[StrictStr, Field(..., description="The identifier for the Custom Entity type, derived from the \"entityTypeName\" provided on creation.")], update_custom_entity_definition_request : Annotated[UpdateCustomEntityDefinitionRequest, Field(description="The payload containing the description of the Custom Entity type.")], async_req: Optional[bool]=None, **kwargs) -> Union[CustomEntityDefinition, Awaitable[CustomEntityDefinition]]:  # noqa: E501
         """[EARLY ACCESS] UpdateCustomEntityDefinition: Modify an existing Custom Entity type.  # noqa: E501
 
         The API will return a Bad Request if the Custom Entity type does not exist.  # noqa: E501
@@ -600,7 +597,7 @@ class CustomEntityDefinitionsApi:
         return self.update_custom_entity_definition_with_http_info(entity_type, update_custom_entity_definition_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def update_custom_entity_definition_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The identifier for the Custom Entity type, derived from the \"entityTypeName\" provided on creation.")], update_custom_entity_definition_request : Annotated[UpdateCustomEntityDefinitionRequest, Field(..., description="The payload containing the description of the Custom Entity type.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def update_custom_entity_definition_with_http_info(self, entity_type : Annotated[StrictStr, Field(..., description="The identifier for the Custom Entity type, derived from the \"entityTypeName\" provided on creation.")], update_custom_entity_definition_request : Annotated[UpdateCustomEntityDefinitionRequest, Field(description="The payload containing the description of the Custom Entity type.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] UpdateCustomEntityDefinition: Modify an existing Custom Entity type.  # noqa: E501
 
         The API will return a Bad Request if the Custom Entity type does not exist.  # noqa: E501