lusid-sdk 2.1.913__py3-none-any.whl → 2.1.915__py3-none-any.whl

lusid/api/property_definitions_api.py

@@ -383,15 +383,15 @@ class PropertyDefinitionsApi:
 
 
     @overload
-    async def delete_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property to be deleted.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property to be deleted.")], code : Annotated[StrictStr, Field(..., description="The code of the property to be deleted. Together with the domain and scope this uniquely             identifies the property.")], **kwargs) -> DeletedEntityResponse:  # noqa: E501
+    async def delete_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property to be deleted.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property to be deleted.")], code : Annotated[StrictStr, Field(..., description="The code of the property to be deleted. Together with the domain and scope this uniquely              identifies the property.")], **kwargs) -> DeletedEntityResponse:  # noqa: E501
         ...
 
     @overload
-    def delete_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property to be deleted.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property to be deleted.")], code : Annotated[StrictStr, Field(..., description="The code of the property to be deleted. Together with the domain and scope this uniquely             identifies the property.")], async_req: Optional[bool]=True, **kwargs) -> DeletedEntityResponse:  # noqa: E501
+    def delete_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property to be deleted.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property to be deleted.")], code : Annotated[StrictStr, Field(..., description="The code of the property to be deleted. Together with the domain and scope this uniquely              identifies the property.")], async_req: Optional[bool]=True, **kwargs) -> DeletedEntityResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def delete_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property to be deleted.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property to be deleted.")], code : Annotated[StrictStr, Field(..., description="The code of the property to be deleted. Together with the domain and scope this uniquely             identifies the property.")], async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
+    def delete_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property to be deleted.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property to be deleted.")], code : Annotated[StrictStr, Field(..., description="The code of the property to be deleted. Together with the domain and scope this uniquely              identifies the property.")], async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
         """DeletePropertyDefinition: Delete property definition  # noqa: E501
 
         Delete the definition of the specified property.  # noqa: E501
@@ -405,7 +405,7 @@ class PropertyDefinitionsApi:
         :type domain: str
         :param scope: The scope of the property to be deleted. (required)
         :type scope: str
-        :param code: The code of the property to be deleted. Together with the domain and scope this uniquely             identifies the property. (required)
+        :param code: The code of the property to be deleted. Together with the domain and scope this uniquely              identifies the property. (required)
         :type code: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -426,7 +426,7 @@ class PropertyDefinitionsApi:
         return self.delete_property_definition_with_http_info(domain, scope, code, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def delete_property_definition_with_http_info(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property to be deleted.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property to be deleted.")], code : Annotated[StrictStr, Field(..., description="The code of the property to be deleted. Together with the domain and scope this uniquely             identifies the property.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def delete_property_definition_with_http_info(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property to be deleted.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property to be deleted.")], code : Annotated[StrictStr, Field(..., description="The code of the property to be deleted. Together with the domain and scope this uniquely              identifies the property.")], **kwargs) -> ApiResponse:  # noqa: E501
         """DeletePropertyDefinition: Delete property definition  # noqa: E501
 
         Delete the definition of the specified property.  # noqa: E501
@@ -440,7 +440,7 @@ class PropertyDefinitionsApi:
         :type domain: str
         :param scope: The scope of the property to be deleted. (required)
         :type scope: str
-        :param code: The code of the property to be deleted. Together with the domain and scope this uniquely             identifies the property. (required)
+        :param code: The code of the property to be deleted. Together with the domain and scope this uniquely              identifies the property. (required)
         :type code: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -551,18 +551,18 @@ class PropertyDefinitionsApi:
 
 
     @overload
-    async def delete_property_definition_properties(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property definition to delete properties from.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property definition to delete properties from.")], code : Annotated[StrictStr, Field(..., description="The code of the property definition to delete properties from.")], request_body : Annotated[conlist(StrictStr), Field(..., description="The property keys of the properties to delete. These must take the format             {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.             The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is before             the time-variant property exists then a failure is returned. Do not specify this parameter if an of the properties to delete are perpetual.")] = None, **kwargs) -> DeletedEntityResponse:  # noqa: E501
+    async def delete_property_definition_properties(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property definition to delete properties from.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property definition to delete properties from.")], code : Annotated[StrictStr, Field(..., description="The code of the property definition to delete properties from.")], request_body : Annotated[conlist(StrictStr), Field(..., description="The property keys of the properties to delete. These must take the format              {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is before              the time-variant property exists then a failure is returned. Do not specify this parameter if an of the properties to delete are perpetual.")] = None, **kwargs) -> DeletedEntityResponse:  # noqa: E501
         ...
 
     @overload
-    def delete_property_definition_properties(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property definition to delete properties from.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property definition to delete properties from.")], code : Annotated[StrictStr, Field(..., description="The code of the property definition to delete properties from.")], request_body : Annotated[conlist(StrictStr), Field(..., description="The property keys of the properties to delete. These must take the format             {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.             The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is before             the time-variant property exists then a failure is returned. Do not specify this parameter if an of the properties to delete are perpetual.")] = None, async_req: Optional[bool]=True, **kwargs) -> DeletedEntityResponse:  # noqa: E501
+    def delete_property_definition_properties(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property definition to delete properties from.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property definition to delete properties from.")], code : Annotated[StrictStr, Field(..., description="The code of the property definition to delete properties from.")], request_body : Annotated[conlist(StrictStr), Field(..., description="The property keys of the properties to delete. These must take the format              {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is before              the time-variant property exists then a failure is returned. Do not specify this parameter if an of the properties to delete are perpetual.")] = None, async_req: Optional[bool]=True, **kwargs) -> DeletedEntityResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def delete_property_definition_properties(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property definition to delete properties from.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property definition to delete properties from.")], code : Annotated[StrictStr, Field(..., description="The code of the property definition to delete properties from.")], request_body : Annotated[conlist(StrictStr), Field(..., description="The property keys of the properties to delete. These must take the format             {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.             The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is before             the time-variant property exists then a failure is returned. Do not specify this parameter if an of the properties to delete are perpetual.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
+    def delete_property_definition_properties(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property definition to delete properties from.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property definition to delete properties from.")], code : Annotated[StrictStr, Field(..., description="The code of the property definition to delete properties from.")], request_body : Annotated[conlist(StrictStr), Field(..., description="The property keys of the properties to delete. These must take the format              {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is before              the time-variant property exists then a failure is returned. Do not specify this parameter if an of the properties to delete are perpetual.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
         """[EARLY ACCESS] DeletePropertyDefinitionProperties: Delete property definition properties  # noqa: E501
 
-        Delete one or more properties from a single property definition. If the properties are time-variant then an effective date time from which the properties will be deleted must be specified. If the properties are perpetual then it is invalid to specify an effective date time for deletion.  # noqa: E501
+        Delete one or more properties from a single property definition. If the properties are time-variant then an effective date time from which the  properties will be deleted must be specified. If the properties are perpetual then it is invalid to specify an effective date time for deletion.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -575,9 +575,9 @@ class PropertyDefinitionsApi:
         :type scope: str
         :param code: The code of the property definition to delete properties from. (required)
         :type code: str
-        :param request_body: The property keys of the properties to delete. These must take the format             {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain. (required)
+        :param request_body: The property keys of the properties to delete. These must take the format              {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain. (required)
         :type request_body: List[str]
-        :param effective_at: The effective datetime or cut label at which to delete time-variant properties from.             The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is before             the time-variant property exists then a failure is returned. Do not specify this parameter if an of the properties to delete are perpetual.
+        :param effective_at: The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is before              the time-variant property exists then a failure is returned. Do not specify this parameter if an of the properties to delete are perpetual.
         :type effective_at: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -598,10 +598,10 @@ class PropertyDefinitionsApi:
         return self.delete_property_definition_properties_with_http_info(domain, scope, code, request_body, effective_at, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def delete_property_definition_properties_with_http_info(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property definition to delete properties from.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property definition to delete properties from.")], code : Annotated[StrictStr, Field(..., description="The code of the property definition to delete properties from.")], request_body : Annotated[conlist(StrictStr), Field(..., description="The property keys of the properties to delete. These must take the format             {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.             The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is before             the time-variant property exists then a failure is returned. Do not specify this parameter if an of the properties to delete are perpetual.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def delete_property_definition_properties_with_http_info(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property definition to delete properties from.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property definition to delete properties from.")], code : Annotated[StrictStr, Field(..., description="The code of the property definition to delete properties from.")], request_body : Annotated[conlist(StrictStr), Field(..., description="The property keys of the properties to delete. These must take the format              {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.")], effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is before              the time-variant property exists then a failure is returned. Do not specify this parameter if an of the properties to delete are perpetual.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] DeletePropertyDefinitionProperties: Delete property definition properties  # noqa: E501
 
-        Delete one or more properties from a single property definition. If the properties are time-variant then an effective date time from which the properties will be deleted must be specified. If the properties are perpetual then it is invalid to specify an effective date time for deletion.  # noqa: E501
+        Delete one or more properties from a single property definition. If the properties are time-variant then an effective date time from which the  properties will be deleted must be specified. If the properties are perpetual then it is invalid to specify an effective date time for deletion.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -614,9 +614,9 @@ class PropertyDefinitionsApi:
         :type scope: str
         :param code: The code of the property definition to delete properties from. (required)
         :type code: str
-        :param request_body: The property keys of the properties to delete. These must take the format             {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain. (required)
+        :param request_body: The property keys of the properties to delete. These must take the format              {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain. (required)
         :type request_body: List[str]
-        :param effective_at: The effective datetime or cut label at which to delete time-variant properties from.             The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is before             the time-variant property exists then a failure is returned. Do not specify this parameter if an of the properties to delete are perpetual.
+        :param effective_at: The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified 'effectiveAt' datetime. If the 'effectiveAt' is not provided or is before              the time-variant property exists then a failure is returned. Do not specify this parameter if an of the properties to delete are perpetual.
         :type effective_at: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -742,15 +742,15 @@ class PropertyDefinitionsApi:
 
 
     @overload
-    async def get_multiple_property_definitions(self, property_keys : Annotated[conlist(StrictStr), Field(..., description="One or more property keys which identify each property that a definition should             be retrieved for. The format for each property key is {domain}/{scope}/{code}, e.g. 'Portfolio/Manager/Id'.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the property definitions. Defaults to return             the latest version of each definition if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Lifetime, use \"lifeTime eq 'Perpetual'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list properties attached to the Property Definition.             Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> ResourceListOfPropertyDefinition:  # noqa: E501
+    async def get_multiple_property_definitions(self, property_keys : Annotated[conlist(StrictStr), Field(..., description="One or more property keys which identify each property that a definition should              be retrieved for. The format for each property key is {domain}/{scope}/{code}, e.g. 'Portfolio/Manager/Id'.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the property definitions. Defaults to return              the latest version of each definition if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               For example, to filter on the Lifetime, use \"lifeTime eq 'Perpetual'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list properties attached to the Property Definition.              Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> ResourceListOfPropertyDefinition:  # noqa: E501
         ...
 
     @overload
-    def get_multiple_property_definitions(self, property_keys : Annotated[conlist(StrictStr), Field(..., description="One or more property keys which identify each property that a definition should             be retrieved for. The format for each property key is {domain}/{scope}/{code}, e.g. 'Portfolio/Manager/Id'.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the property definitions. Defaults to return             the latest version of each definition if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Lifetime, use \"lifeTime eq 'Perpetual'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list properties attached to the Property Definition.             Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfPropertyDefinition:  # noqa: E501
+    def get_multiple_property_definitions(self, property_keys : Annotated[conlist(StrictStr), Field(..., description="One or more property keys which identify each property that a definition should              be retrieved for. The format for each property key is {domain}/{scope}/{code}, e.g. 'Portfolio/Manager/Id'.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the property definitions. Defaults to return              the latest version of each definition if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               For example, to filter on the Lifetime, use \"lifeTime eq 'Perpetual'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list properties attached to the Property Definition.              Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfPropertyDefinition:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_multiple_property_definitions(self, property_keys : Annotated[conlist(StrictStr), Field(..., description="One or more property keys which identify each property that a definition should             be retrieved for. The format for each property key is {domain}/{scope}/{code}, e.g. 'Portfolio/Manager/Id'.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the property definitions. Defaults to return             the latest version of each definition if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Lifetime, use \"lifeTime eq 'Perpetual'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list properties attached to the Property Definition.             Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfPropertyDefinition, Awaitable[ResourceListOfPropertyDefinition]]:  # noqa: E501
+    def get_multiple_property_definitions(self, property_keys : Annotated[conlist(StrictStr), Field(..., description="One or more property keys which identify each property that a definition should              be retrieved for. The format for each property key is {domain}/{scope}/{code}, e.g. 'Portfolio/Manager/Id'.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the property definitions. Defaults to return              the latest version of each definition if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               For example, to filter on the Lifetime, use \"lifeTime eq 'Perpetual'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list properties attached to the Property Definition.              Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfPropertyDefinition, Awaitable[ResourceListOfPropertyDefinition]]:  # noqa: E501
         """GetMultiplePropertyDefinitions: Get multiple property definitions  # noqa: E501
 
         Retrieve the definition of one or more specified properties.  # noqa: E501
@@ -760,13 +760,13 @@ class PropertyDefinitionsApi:
         >>> thread = api.get_multiple_property_definitions(property_keys, as_at, filter, effective_at, async_req=True)
         >>> result = thread.get()
 
-        :param property_keys: One or more property keys which identify each property that a definition should             be retrieved for. The format for each property key is {domain}/{scope}/{code}, e.g. 'Portfolio/Manager/Id'. (required)
+        :param property_keys: One or more property keys which identify each property that a definition should              be retrieved for. The format for each property key is {domain}/{scope}/{code}, e.g. 'Portfolio/Manager/Id'. (required)
         :type property_keys: List[str]
-        :param as_at: The asAt datetime at which to retrieve the property definitions. Defaults to return             the latest version of each definition if not specified.
+        :param as_at: The asAt datetime at which to retrieve the property definitions. Defaults to return              the latest version of each definition if not specified.
         :type as_at: datetime
-        :param filter: Expression to filter the result set.              For example, to filter on the Lifetime, use \"lifeTime eq 'Perpetual'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
+        :param filter: Expression to filter the result set.               For example, to filter on the Lifetime, use \"lifeTime eq 'Perpetual'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
-        :param effective_at: The effective datetime or cut label at which to list properties attached to the Property Definition.             Defaults to the current LUSID system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to list properties attached to the Property Definition.              Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -787,7 +787,7 @@ class PropertyDefinitionsApi:
         return self.get_multiple_property_definitions_with_http_info(property_keys, as_at, filter, effective_at, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_multiple_property_definitions_with_http_info(self, property_keys : Annotated[conlist(StrictStr), Field(..., description="One or more property keys which identify each property that a definition should             be retrieved for. The format for each property key is {domain}/{scope}/{code}, e.g. 'Portfolio/Manager/Id'.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the property definitions. Defaults to return             the latest version of each definition if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.              For example, to filter on the Lifetime, use \"lifeTime eq 'Perpetual'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list properties attached to the Property Definition.             Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_multiple_property_definitions_with_http_info(self, property_keys : Annotated[conlist(StrictStr), Field(..., description="One or more property keys which identify each property that a definition should              be retrieved for. The format for each property key is {domain}/{scope}/{code}, e.g. 'Portfolio/Manager/Id'.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the property definitions. Defaults to return              the latest version of each definition if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the result set.               For example, to filter on the Lifetime, use \"lifeTime eq 'Perpetual'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list properties attached to the Property Definition.              Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """GetMultiplePropertyDefinitions: Get multiple property definitions  # noqa: E501
 
         Retrieve the definition of one or more specified properties.  # noqa: E501
@@ -797,13 +797,13 @@ class PropertyDefinitionsApi:
         >>> thread = api.get_multiple_property_definitions_with_http_info(property_keys, as_at, filter, effective_at, async_req=True)
         >>> result = thread.get()
 
-        :param property_keys: One or more property keys which identify each property that a definition should             be retrieved for. The format for each property key is {domain}/{scope}/{code}, e.g. 'Portfolio/Manager/Id'. (required)
+        :param property_keys: One or more property keys which identify each property that a definition should              be retrieved for. The format for each property key is {domain}/{scope}/{code}, e.g. 'Portfolio/Manager/Id'. (required)
         :type property_keys: List[str]
-        :param as_at: The asAt datetime at which to retrieve the property definitions. Defaults to return             the latest version of each definition if not specified.
+        :param as_at: The asAt datetime at which to retrieve the property definitions. Defaults to return              the latest version of each definition if not specified.
         :type as_at: datetime
-        :param filter: Expression to filter the result set.              For example, to filter on the Lifetime, use \"lifeTime eq 'Perpetual'\"             Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
+        :param filter: Expression to filter the result set.               For example, to filter on the Lifetime, use \"lifeTime eq 'Perpetual'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
-        :param effective_at: The effective datetime or cut label at which to list properties attached to the Property Definition.             Defaults to the current LUSID system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to list properties attached to the Property Definition.              Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -922,15 +922,15 @@ class PropertyDefinitionsApi:
 
 
     @overload
-    async def get_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the specified property.")], scope : Annotated[StrictStr, Field(..., description="The scope of the specified property.")], code : Annotated[StrictStr, Field(..., description="The code of the specified property. Together with the domain and scope this uniquely             identifies the property.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the property definition. Defaults to return             the latest version of the definition if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list properties attached to the Property Definition.             Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> PropertyDefinition:  # noqa: E501
+    async def get_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the specified property.")], scope : Annotated[StrictStr, Field(..., description="The scope of the specified property.")], code : Annotated[StrictStr, Field(..., description="The code of the specified property. Together with the domain and scope this uniquely              identifies the property.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the property definition. Defaults to return              the latest version of the definition if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list properties attached to the Property Definition.              Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> PropertyDefinition:  # noqa: E501
         ...
 
     @overload
-    def get_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the specified property.")], scope : Annotated[StrictStr, Field(..., description="The scope of the specified property.")], code : Annotated[StrictStr, Field(..., description="The code of the specified property. Together with the domain and scope this uniquely             identifies the property.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the property definition. Defaults to return             the latest version of the definition if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list properties attached to the Property Definition.             Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> PropertyDefinition:  # noqa: E501
+    def get_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the specified property.")], scope : Annotated[StrictStr, Field(..., description="The scope of the specified property.")], code : Annotated[StrictStr, Field(..., description="The code of the specified property. Together with the domain and scope this uniquely              identifies the property.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the property definition. Defaults to return              the latest version of the definition if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list properties attached to the Property Definition.              Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=True, **kwargs) -> PropertyDefinition:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the specified property.")], scope : Annotated[StrictStr, Field(..., description="The scope of the specified property.")], code : Annotated[StrictStr, Field(..., description="The code of the specified property. Together with the domain and scope this uniquely             identifies the property.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the property definition. Defaults to return             the latest version of the definition if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list properties attached to the Property Definition.             Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PropertyDefinition, Awaitable[PropertyDefinition]]:  # noqa: E501
+    def get_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the specified property.")], scope : Annotated[StrictStr, Field(..., description="The scope of the specified property.")], code : Annotated[StrictStr, Field(..., description="The code of the specified property. Together with the domain and scope this uniquely              identifies the property.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the property definition. Defaults to return              the latest version of the definition if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list properties attached to the Property Definition.              Defaults to the current LUSID system datetime if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PropertyDefinition, Awaitable[PropertyDefinition]]:  # noqa: E501
         """GetPropertyDefinition: Get property definition  # noqa: E501
 
         Retrieve the definition of a specified property.  # noqa: E501
@@ -944,11 +944,11 @@ class PropertyDefinitionsApi:
         :type domain: str
         :param scope: The scope of the specified property. (required)
         :type scope: str
-        :param code: The code of the specified property. Together with the domain and scope this uniquely             identifies the property. (required)
+        :param code: The code of the specified property. Together with the domain and scope this uniquely              identifies the property. (required)
         :type code: str
-        :param as_at: The asAt datetime at which to retrieve the property definition. Defaults to return             the latest version of the definition if not specified.
+        :param as_at: The asAt datetime at which to retrieve the property definition. Defaults to return              the latest version of the definition if not specified.
         :type as_at: datetime
-        :param effective_at: The effective datetime or cut label at which to list properties attached to the Property Definition.             Defaults to the current LUSID system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to list properties attached to the Property Definition.              Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -969,7 +969,7 @@ class PropertyDefinitionsApi:
         return self.get_property_definition_with_http_info(domain, scope, code, as_at, effective_at, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_property_definition_with_http_info(self, domain : Annotated[StrictStr, Field(..., description="The domain of the specified property.")], scope : Annotated[StrictStr, Field(..., description="The scope of the specified property.")], code : Annotated[StrictStr, Field(..., description="The code of the specified property. Together with the domain and scope this uniquely             identifies the property.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the property definition. Defaults to return             the latest version of the definition if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list properties attached to the Property Definition.             Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_property_definition_with_http_info(self, domain : Annotated[StrictStr, Field(..., description="The domain of the specified property.")], scope : Annotated[StrictStr, Field(..., description="The scope of the specified property.")], code : Annotated[StrictStr, Field(..., description="The code of the specified property. Together with the domain and scope this uniquely              identifies the property.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the property definition. Defaults to return              the latest version of the definition if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list properties attached to the Property Definition.              Defaults to the current LUSID system datetime if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """GetPropertyDefinition: Get property definition  # noqa: E501
 
         Retrieve the definition of a specified property.  # noqa: E501
@@ -983,11 +983,11 @@ class PropertyDefinitionsApi:
         :type domain: str
         :param scope: The scope of the specified property. (required)
         :type scope: str
-        :param code: The code of the specified property. Together with the domain and scope this uniquely             identifies the property. (required)
+        :param code: The code of the specified property. Together with the domain and scope this uniquely              identifies the property. (required)
         :type code: str
-        :param as_at: The asAt datetime at which to retrieve the property definition. Defaults to return             the latest version of the definition if not specified.
+        :param as_at: The asAt datetime at which to retrieve the property definition. Defaults to return              the latest version of the definition if not specified.
         :type as_at: datetime
-        :param effective_at: The effective datetime or cut label at which to list properties attached to the Property Definition.             Defaults to the current LUSID system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to list properties attached to the Property Definition.              Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -1109,15 +1109,15 @@ class PropertyDefinitionsApi:
 
 
     @overload
-    async def get_property_definition_property_time_series(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property definition to which the property is attached")], scope : Annotated[StrictStr, Field(..., description="The scope of the property definition to which the property is attached")], code : Annotated[StrictStr, Field(..., description="The code of the property definition to which the property is attached")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property whose history to show. This must be from the \"Property Definition\" domain and in the format             {domain}/{scope}/{code}, for example \"PropertyDefinition/myScope/someAttributeKey\".")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to show the history. Defaults to the current datetime if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing properties from a previous call to get property time series.             This value is returned from the previous call. If a pagination token is provided the filter and asAt fields             must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, **kwargs) -> ResourceListOfPropertyInterval:  # noqa: E501
+    async def get_property_definition_property_time_series(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property definition to which the property is attached")], scope : Annotated[StrictStr, Field(..., description="The scope of the property definition to which the property is attached")], code : Annotated[StrictStr, Field(..., description="The code of the property definition to which the property is attached")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property whose history to show. This must be from the \"Property Definition\" domain and in the format              {domain}/{scope}/{code}, for example \"PropertyDefinition/myScope/someAttributeKey\".")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to show the history. Defaults to the current datetime if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing properties from a previous call to get property time series.              This value is returned from the previous call. If a pagination token is provided the filter and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, **kwargs) -> ResourceListOfPropertyInterval:  # noqa: E501
         ...
 
     @overload
-    def get_property_definition_property_time_series(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property definition to which the property is attached")], scope : Annotated[StrictStr, Field(..., description="The scope of the property definition to which the property is attached")], code : Annotated[StrictStr, Field(..., description="The code of the property definition to which the property is attached")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property whose history to show. This must be from the \"Property Definition\" domain and in the format             {domain}/{scope}/{code}, for example \"PropertyDefinition/myScope/someAttributeKey\".")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to show the history. Defaults to the current datetime if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing properties from a previous call to get property time series.             This value is returned from the previous call. If a pagination token is provided the filter and asAt fields             must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfPropertyInterval:  # noqa: E501
+    def get_property_definition_property_time_series(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property definition to which the property is attached")], scope : Annotated[StrictStr, Field(..., description="The scope of the property definition to which the property is attached")], code : Annotated[StrictStr, Field(..., description="The code of the property definition to which the property is attached")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property whose history to show. This must be from the \"Property Definition\" domain and in the format              {domain}/{scope}/{code}, for example \"PropertyDefinition/myScope/someAttributeKey\".")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to show the history. Defaults to the current datetime if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing properties from a previous call to get property time series.              This value is returned from the previous call. If a pagination token is provided the filter and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfPropertyInterval:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_property_definition_property_time_series(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property definition to which the property is attached")], scope : Annotated[StrictStr, Field(..., description="The scope of the property definition to which the property is attached")], code : Annotated[StrictStr, Field(..., description="The code of the property definition to which the property is attached")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property whose history to show. This must be from the \"Property Definition\" domain and in the format             {domain}/{scope}/{code}, for example \"PropertyDefinition/myScope/someAttributeKey\".")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to show the history. Defaults to the current datetime if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing properties from a previous call to get property time series.             This value is returned from the previous call. If a pagination token is provided the filter and asAt fields             must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfPropertyInterval, Awaitable[ResourceListOfPropertyInterval]]:  # noqa: E501
+    def get_property_definition_property_time_series(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property definition to which the property is attached")], scope : Annotated[StrictStr, Field(..., description="The scope of the property definition to which the property is attached")], code : Annotated[StrictStr, Field(..., description="The code of the property definition to which the property is attached")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property whose history to show. This must be from the \"Property Definition\" domain and in the format              {domain}/{scope}/{code}, for example \"PropertyDefinition/myScope/someAttributeKey\".")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to show the history. Defaults to the current datetime if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing properties from a previous call to get property time series.              This value is returned from the previous call. If a pagination token is provided the filter and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfPropertyInterval, Awaitable[ResourceListOfPropertyInterval]]:  # noqa: E501
         """[EARLY ACCESS] GetPropertyDefinitionPropertyTimeSeries: Get Property Definition Property Time Series  # noqa: E501
 
         List the complete time series of a property definition property.  # noqa: E501
@@ -1133,13 +1133,13 @@ class PropertyDefinitionsApi:
         :type scope: str
         :param code: The code of the property definition to which the property is attached (required)
         :type code: str
-        :param property_key: The property key of the property whose history to show. This must be from the \"Property Definition\" domain and in the format             {domain}/{scope}/{code}, for example \"PropertyDefinition/myScope/someAttributeKey\". (required)
+        :param property_key: The property key of the property whose history to show. This must be from the \"Property Definition\" domain and in the format              {domain}/{scope}/{code}, for example \"PropertyDefinition/myScope/someAttributeKey\". (required)
         :type property_key: str
         :param as_at: The asAt datetime at which to show the history. Defaults to the current datetime if not specified.
         :type as_at: datetime
         :param filter: Expression to filter the results. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
-        :param page: The pagination token to use to continue listing properties from a previous call to get property time series.             This value is returned from the previous call. If a pagination token is provided the filter and asAt fields             must not have changed since the original request.
+        :param page: The pagination token to use to continue listing properties from a previous call to get property time series.              This value is returned from the previous call. If a pagination token is provided the filter and asAt fields              must not have changed since the original request.
         :type page: str
         :param limit: When paginating, limit the number of returned results to this many.
         :type limit: int
@@ -1162,7 +1162,7 @@ class PropertyDefinitionsApi:
         return self.get_property_definition_property_time_series_with_http_info(domain, scope, code, property_key, as_at, filter, page, limit, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_property_definition_property_time_series_with_http_info(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property definition to which the property is attached")], scope : Annotated[StrictStr, Field(..., description="The scope of the property definition to which the property is attached")], code : Annotated[StrictStr, Field(..., description="The code of the property definition to which the property is attached")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property whose history to show. This must be from the \"Property Definition\" domain and in the format             {domain}/{scope}/{code}, for example \"PropertyDefinition/myScope/someAttributeKey\".")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to show the history. Defaults to the current datetime if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing properties from a previous call to get property time series.             This value is returned from the previous call. If a pagination token is provided the filter and asAt fields             must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_property_definition_property_time_series_with_http_info(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property definition to which the property is attached")], scope : Annotated[StrictStr, Field(..., description="The scope of the property definition to which the property is attached")], code : Annotated[StrictStr, Field(..., description="The code of the property definition to which the property is attached")], property_key : Annotated[StrictStr, Field(..., description="The property key of the property whose history to show. This must be from the \"Property Definition\" domain and in the format              {domain}/{scope}/{code}, for example \"PropertyDefinition/myScope/someAttributeKey\".")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to show the history. Defaults to the current datetime if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing properties from a previous call to get property time series.              This value is returned from the previous call. If a pagination token is provided the filter and asAt fields              must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the number of returned results to this many.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] GetPropertyDefinitionPropertyTimeSeries: Get Property Definition Property Time Series  # noqa: E501
 
         List the complete time series of a property definition property.  # noqa: E501
@@ -1178,13 +1178,13 @@ class PropertyDefinitionsApi:
         :type scope: str
         :param code: The code of the property definition to which the property is attached (required)
         :type code: str
-        :param property_key: The property key of the property whose history to show. This must be from the \"Property Definition\" domain and in the format             {domain}/{scope}/{code}, for example \"PropertyDefinition/myScope/someAttributeKey\". (required)
+        :param property_key: The property key of the property whose history to show. This must be from the \"Property Definition\" domain and in the format              {domain}/{scope}/{code}, for example \"PropertyDefinition/myScope/someAttributeKey\". (required)
         :type property_key: str
         :param as_at: The asAt datetime at which to show the history. Defaults to the current datetime if not specified.
         :type as_at: datetime
         :param filter: Expression to filter the results. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
         :type filter: str
-        :param page: The pagination token to use to continue listing properties from a previous call to get property time series.             This value is returned from the previous call. If a pagination token is provided the filter and asAt fields             must not have changed since the original request.
+        :param page: The pagination token to use to continue listing properties from a previous call to get property time series.              This value is returned from the previous call. If a pagination token is provided the filter and asAt fields              must not have changed since the original request.
         :type page: str
         :param limit: When paginating, limit the number of returned results to this many.
         :type limit: int
@@ -1320,15 +1320,15 @@ class PropertyDefinitionsApi:
 
 
     @overload
-    async def list_property_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the property definitions. Defaults to the current LUSID             system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the property definitions. Defaults to returning the latest version             of each property definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Property Definition' domain to decorate onto             property definitions. These must take the format             {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing property definitions; this             value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt             and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.             For example, to filter on the display name, specify \"DisplayName eq 'DisplayName'\". 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, **kwargs) -> PagedResourceListOfPropertyDefinition:  # noqa: E501
+    async def list_property_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the property definitions. Defaults to the current LUSID              system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the property definitions. Defaults to returning the latest version              of each property definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Property Definition' domain to decorate onto              property definitions. These must take the format              {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing property definitions; this              value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the display name, specify \"DisplayName eq 'DisplayName'\". 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, **kwargs) -> PagedResourceListOfPropertyDefinition:  # noqa: E501
         ...
 
     @overload
-    def list_property_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the property definitions. Defaults to the current LUSID             system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the property definitions. Defaults to returning the latest version             of each property definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Property Definition' domain to decorate onto             property definitions. These must take the format             {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing property definitions; this             value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt             and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.             For example, to filter on the display name, specify \"DisplayName eq 'DisplayName'\". 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, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfPropertyDefinition:  # noqa: E501
+    def list_property_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the property definitions. Defaults to the current LUSID              system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the property definitions. Defaults to returning the latest version              of each property definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Property Definition' domain to decorate onto              property definitions. These must take the format              {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing property definitions; this              value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the display name, specify \"DisplayName eq 'DisplayName'\". 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, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfPropertyDefinition:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_property_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the property definitions. Defaults to the current LUSID             system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the property definitions. Defaults to returning the latest version             of each property definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Property Definition' domain to decorate onto             property definitions. These must take the format             {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing property definitions; this             value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt             and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.             For example, to filter on the display name, specify \"DisplayName eq 'DisplayName'\". 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, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfPropertyDefinition, Awaitable[PagedResourceListOfPropertyDefinition]]:  # noqa: E501
+    def list_property_definitions(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the property definitions. Defaults to the current LUSID              system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the property definitions. Defaults to returning the latest version              of each property definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Property Definition' domain to decorate onto              property definitions. These must take the format              {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing property definitions; this              value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the display name, specify \"DisplayName eq 'DisplayName'\". 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, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfPropertyDefinition, Awaitable[PagedResourceListOfPropertyDefinition]]:  # noqa: E501
         """ListPropertyDefinitions: List property definitions  # noqa: E501
 
         List all the property definitions matching particular criteria.  # noqa: E501
@@ -1338,17 +1338,17 @@ class PropertyDefinitionsApi:
         >>> thread = api.list_property_definitions(effective_at, as_at, property_keys, page, limit, filter, sort_by, async_req=True)
         >>> result = thread.get()
 
-        :param effective_at: The effective datetime or cut label at which to list the property definitions. Defaults to the current LUSID             system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to list the property definitions. Defaults to the current LUSID              system datetime if not specified.
         :type effective_at: str
-        :param as_at: The asAt datetime at which to list the property definitions. Defaults to returning the latest version             of each property definition if not specified.
+        :param as_at: The asAt datetime at which to list the property definitions. Defaults to returning the latest version              of each property definition if not specified.
         :type as_at: datetime
-        :param property_keys: A list of property keys from the 'Property Definition' domain to decorate onto             property definitions. These must take the format             {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.
+        :param property_keys: A list of property keys from the 'Property Definition' domain to decorate onto              property definitions. These must take the format              {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.
         :type property_keys: List[str]
-        :param page: The pagination token to use to continue listing property definitions; 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.
+        :param page: The pagination token to use to continue listing property definitions; 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.
         :type page: str
         :param limit: When paginating, limit the results to this number. Defaults to 100 if not specified.
         :type limit: int
-        :param filter: Expression to filter the results.             For example, to filter on the display name, specify \"DisplayName eq 'DisplayName'\". For more information about filtering             results, see https://support.lusid.com/knowledgebase/article/KA-01914.
+        :param filter: Expression to filter the results.              For example, to filter on the display name, specify \"DisplayName eq 'DisplayName'\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.
         :type filter: str
         :param sort_by: A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"
         :type sort_by: List[str]
@@ -1371,7 +1371,7 @@ class PropertyDefinitionsApi:
         return self.list_property_definitions_with_http_info(effective_at, as_at, property_keys, page, limit, filter, sort_by, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_property_definitions_with_http_info(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the property definitions. Defaults to the current LUSID             system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the property definitions. Defaults to returning the latest version             of each property definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Property Definition' domain to decorate onto             property definitions. These must take the format             {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing property definitions; this             value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt             and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.             For example, to filter on the display name, specify \"DisplayName eq 'DisplayName'\". 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, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_property_definitions_with_http_info(self, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the property definitions. Defaults to the current LUSID              system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the property definitions. Defaults to returning the latest version              of each property definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Property Definition' domain to decorate onto              property definitions. These must take the format              {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing property definitions; this              value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the display name, specify \"DisplayName eq 'DisplayName'\". 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, **kwargs) -> ApiResponse:  # noqa: E501
         """ListPropertyDefinitions: List property definitions  # noqa: E501
 
         List all the property definitions matching particular criteria.  # noqa: E501
@@ -1381,17 +1381,17 @@ class PropertyDefinitionsApi:
         >>> thread = api.list_property_definitions_with_http_info(effective_at, as_at, property_keys, page, limit, filter, sort_by, async_req=True)
         >>> result = thread.get()
 
-        :param effective_at: The effective datetime or cut label at which to list the property definitions. Defaults to the current LUSID             system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to list the property definitions. Defaults to the current LUSID              system datetime if not specified.
         :type effective_at: str
-        :param as_at: The asAt datetime at which to list the property definitions. Defaults to returning the latest version             of each property definition if not specified.
+        :param as_at: The asAt datetime at which to list the property definitions. Defaults to returning the latest version              of each property definition if not specified.
         :type as_at: datetime
-        :param property_keys: A list of property keys from the 'Property Definition' domain to decorate onto             property definitions. These must take the format             {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.
+        :param property_keys: A list of property keys from the 'Property Definition' domain to decorate onto              property definitions. These must take the format              {domain}/{scope}/{code} e.g \"PropertyDefinition/myScope/someAttributeKey\". Each property must be from the \"PropertyDefinition\" domain.
         :type property_keys: List[str]
-        :param page: The pagination token to use to continue listing property definitions; 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.
+        :param page: The pagination token to use to continue listing property definitions; 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.
         :type page: str
         :param limit: When paginating, limit the results to this number. Defaults to 100 if not specified.
         :type limit: int
-        :param filter: Expression to filter the results.             For example, to filter on the display name, specify \"DisplayName eq 'DisplayName'\". For more information about filtering             results, see https://support.lusid.com/knowledgebase/article/KA-01914.
+        :param filter: Expression to filter the results.              For example, to filter on the display name, specify \"DisplayName eq 'DisplayName'\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.
         :type filter: str
         :param sort_by: A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"
         :type sort_by: List[str]
@@ -1708,18 +1708,18 @@ class PropertyDefinitionsApi:
 
 
     @overload
-    async def update_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property being updated.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property being updated.")], code : Annotated[StrictStr, Field(..., description="The code of the property being updated. Together with the domain and scope this uniquely             identifies the property.")], update_property_definition_request : Annotated[UpdatePropertyDefinitionRequest, Field(..., description="The updated definition of the property.")], **kwargs) -> PropertyDefinition:  # noqa: E501
+    async def update_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property being updated.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property being updated.")], code : Annotated[StrictStr, Field(..., description="The code of the property being updated. Together with the domain and scope this uniquely              identifies the property.")], update_property_definition_request : Annotated[UpdatePropertyDefinitionRequest, Field(..., description="The updated definition of the property.")], **kwargs) -> PropertyDefinition:  # noqa: E501
         ...
 
     @overload
-    def update_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property being updated.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property being updated.")], code : Annotated[StrictStr, Field(..., description="The code of the property being updated. Together with the domain and scope this uniquely             identifies the property.")], update_property_definition_request : Annotated[UpdatePropertyDefinitionRequest, Field(..., description="The updated definition of the property.")], async_req: Optional[bool]=True, **kwargs) -> PropertyDefinition:  # noqa: E501
+    def update_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property being updated.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property being updated.")], code : Annotated[StrictStr, Field(..., description="The code of the property being updated. Together with the domain and scope this uniquely              identifies the property.")], update_property_definition_request : Annotated[UpdatePropertyDefinitionRequest, Field(..., description="The updated definition of the property.")], async_req: Optional[bool]=True, **kwargs) -> PropertyDefinition:  # noqa: E501
         ...
 
     @validate_arguments
-    def update_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property being updated.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property being updated.")], code : Annotated[StrictStr, Field(..., description="The code of the property being updated. Together with the domain and scope this uniquely             identifies the property.")], update_property_definition_request : Annotated[UpdatePropertyDefinitionRequest, Field(..., description="The updated definition of the property.")], async_req: Optional[bool]=None, **kwargs) -> Union[PropertyDefinition, Awaitable[PropertyDefinition]]:  # noqa: E501
+    def update_property_definition(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property being updated.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property being updated.")], code : Annotated[StrictStr, Field(..., description="The code of the property being updated. Together with the domain and scope this uniquely              identifies the property.")], update_property_definition_request : Annotated[UpdatePropertyDefinitionRequest, Field(..., description="The updated definition of the property.")], async_req: Optional[bool]=None, **kwargs) -> Union[PropertyDefinition, Awaitable[PropertyDefinition]]:  # noqa: E501
         """UpdatePropertyDefinition: Update property definition  # noqa: E501
 
-        Update the definition of a specified existing property. Not all elements within a property definition are modifiable due to the potential implications for values already stored against the property.  # noqa: E501
+        Update the definition of a specified existing property. Not all elements within a property definition  are modifiable due to the potential implications for values already stored against the property.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -1730,7 +1730,7 @@ class PropertyDefinitionsApi:
         :type domain: str
         :param scope: The scope of the property being updated. (required)
         :type scope: str
-        :param code: The code of the property being updated. Together with the domain and scope this uniquely             identifies the property. (required)
+        :param code: The code of the property being updated. Together with the domain and scope this uniquely              identifies the property. (required)
         :type code: str
         :param update_property_definition_request: The updated definition of the property. (required)
         :type update_property_definition_request: UpdatePropertyDefinitionRequest
@@ -1753,10 +1753,10 @@ class PropertyDefinitionsApi:
         return self.update_property_definition_with_http_info(domain, scope, code, update_property_definition_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def update_property_definition_with_http_info(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property being updated.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property being updated.")], code : Annotated[StrictStr, Field(..., description="The code of the property being updated. Together with the domain and scope this uniquely             identifies the property.")], update_property_definition_request : Annotated[UpdatePropertyDefinitionRequest, Field(..., description="The updated definition of the property.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def update_property_definition_with_http_info(self, domain : Annotated[StrictStr, Field(..., description="The domain of the property being updated.")], scope : Annotated[StrictStr, Field(..., description="The scope of the property being updated.")], code : Annotated[StrictStr, Field(..., description="The code of the property being updated. Together with the domain and scope this uniquely              identifies the property.")], update_property_definition_request : Annotated[UpdatePropertyDefinitionRequest, Field(..., description="The updated definition of the property.")], **kwargs) -> ApiResponse:  # noqa: E501
         """UpdatePropertyDefinition: Update property definition  # noqa: E501
 
-        Update the definition of a specified existing property. Not all elements within a property definition are modifiable due to the potential implications for values already stored against the property.  # noqa: E501
+        Update the definition of a specified existing property. Not all elements within a property definition  are modifiable due to the potential implications for values already stored against the property.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -1767,7 +1767,7 @@ class PropertyDefinitionsApi:
         :type domain: str
         :param scope: The scope of the property being updated. (required)
         :type scope: str
-        :param code: The code of the property being updated. Together with the domain and scope this uniquely             identifies the property. (required)
+        :param code: The code of the property being updated. Together with the domain and scope this uniquely              identifies the property. (required)
         :type code: str
         :param update_property_definition_request: The updated definition of the property. (required)
         :type update_property_definition_request: UpdatePropertyDefinitionRequest
@@ -1891,15 +1891,15 @@ class PropertyDefinitionsApi:
 
 
     @overload
-    async def upsert_property_definition_properties(self, domain : Annotated[StrictStr, Field(..., description="The domain of the specified property.")], scope : Annotated[StrictStr, Field(..., description="The scope of the specified property.")], code : Annotated[StrictStr, Field(..., description="The code of the specified property. Together with the domain and scope this uniquely")], request_body : Annotated[Dict[str, ModelProperty], Field(..., description="The properties to be created or updated. Each property in             the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code}, for example             'PropertyDefinition/Manager/Id'.")], success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, **kwargs) -> BatchUpsertPropertyDefinitionPropertiesResponse:  # noqa: E501
+    async def upsert_property_definition_properties(self, domain : Annotated[StrictStr, Field(..., description="The domain of the specified property.")], scope : Annotated[StrictStr, Field(..., description="The scope of the specified property.")], code : Annotated[StrictStr, Field(..., description="The code of the specified property. Together with the domain and scope this uniquely")], request_body : Annotated[Dict[str, ModelProperty], Field(..., description="The properties to be created or updated. Each property in              the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code}, for example              'PropertyDefinition/Manager/Id'.")], success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, **kwargs) -> BatchUpsertPropertyDefinitionPropertiesResponse:  # noqa: E501
         ...
 
     @overload
-    def upsert_property_definition_properties(self, domain : Annotated[StrictStr, Field(..., description="The domain of the specified property.")], scope : Annotated[StrictStr, Field(..., description="The scope of the specified property.")], code : Annotated[StrictStr, Field(..., description="The code of the specified property. Together with the domain and scope this uniquely")], request_body : Annotated[Dict[str, ModelProperty], Field(..., description="The properties to be created or updated. Each property in             the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code}, for example             'PropertyDefinition/Manager/Id'.")], success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, async_req: Optional[bool]=True, **kwargs) -> BatchUpsertPropertyDefinitionPropertiesResponse:  # noqa: E501
+    def upsert_property_definition_properties(self, domain : Annotated[StrictStr, Field(..., description="The domain of the specified property.")], scope : Annotated[StrictStr, Field(..., description="The scope of the specified property.")], code : Annotated[StrictStr, Field(..., description="The code of the specified property. Together with the domain and scope this uniquely")], request_body : Annotated[Dict[str, ModelProperty], Field(..., description="The properties to be created or updated. Each property in              the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code}, for example              'PropertyDefinition/Manager/Id'.")], success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, async_req: Optional[bool]=True, **kwargs) -> BatchUpsertPropertyDefinitionPropertiesResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def upsert_property_definition_properties(self, domain : Annotated[StrictStr, Field(..., description="The domain of the specified property.")], scope : Annotated[StrictStr, Field(..., description="The scope of the specified property.")], code : Annotated[StrictStr, Field(..., description="The code of the specified property. Together with the domain and scope this uniquely")], request_body : Annotated[Dict[str, ModelProperty], Field(..., description="The properties to be created or updated. Each property in             the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code}, for example             'PropertyDefinition/Manager/Id'.")], success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BatchUpsertPropertyDefinitionPropertiesResponse, Awaitable[BatchUpsertPropertyDefinitionPropertiesResponse]]:  # noqa: E501
+    def upsert_property_definition_properties(self, domain : Annotated[StrictStr, Field(..., description="The domain of the specified property.")], scope : Annotated[StrictStr, Field(..., description="The scope of the specified property.")], code : Annotated[StrictStr, Field(..., description="The code of the specified property. Together with the domain and scope this uniquely")], request_body : Annotated[Dict[str, ModelProperty], Field(..., description="The properties to be created or updated. Each property in              the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code}, for example              'PropertyDefinition/Manager/Id'.")], success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[BatchUpsertPropertyDefinitionPropertiesResponse, Awaitable[BatchUpsertPropertyDefinitionPropertiesResponse]]:  # noqa: E501
         """UpsertPropertyDefinitionProperties: Upsert properties to a property definition  # noqa: E501
 
         Create or update properties for a particular property definition  # noqa: E501
@@ -1915,7 +1915,7 @@ class PropertyDefinitionsApi:
         :type scope: str
         :param code: The code of the specified property. Together with the domain and scope this uniquely (required)
         :type code: str
-        :param request_body: The properties to be created or updated. Each property in             the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code}, for example             'PropertyDefinition/Manager/Id'. (required)
+        :param request_body: The properties to be created or updated. Each property in              the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code}, for example              'PropertyDefinition/Manager/Id'. (required)
         :type request_body: Dict[str, ModelProperty]
         :param success_mode: Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.
         :type success_mode: str
@@ -1938,7 +1938,7 @@ class PropertyDefinitionsApi:
         return self.upsert_property_definition_properties_with_http_info(domain, scope, code, request_body, success_mode, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def upsert_property_definition_properties_with_http_info(self, domain : Annotated[StrictStr, Field(..., description="The domain of the specified property.")], scope : Annotated[StrictStr, Field(..., description="The scope of the specified property.")], code : Annotated[StrictStr, Field(..., description="The code of the specified property. Together with the domain and scope this uniquely")], request_body : Annotated[Dict[str, ModelProperty], Field(..., description="The properties to be created or updated. Each property in             the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code}, for example             'PropertyDefinition/Manager/Id'.")], success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def upsert_property_definition_properties_with_http_info(self, domain : Annotated[StrictStr, Field(..., description="The domain of the specified property.")], scope : Annotated[StrictStr, Field(..., description="The scope of the specified property.")], code : Annotated[StrictStr, Field(..., description="The code of the specified property. Together with the domain and scope this uniquely")], request_body : Annotated[Dict[str, ModelProperty], Field(..., description="The properties to be created or updated. Each property in              the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code}, for example              'PropertyDefinition/Manager/Id'.")], success_mode : Annotated[Optional[StrictStr], Field( description="Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """UpsertPropertyDefinitionProperties: Upsert properties to a property definition  # noqa: E501
 
         Create or update properties for a particular property definition  # noqa: E501
@@ -1954,7 +1954,7 @@ class PropertyDefinitionsApi:
         :type scope: str
         :param code: The code of the specified property. Together with the domain and scope this uniquely (required)
         :type code: str
-        :param request_body: The properties to be created or updated. Each property in             the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code}, for example             'PropertyDefinition/Manager/Id'. (required)
+        :param request_body: The properties to be created or updated. Each property in              the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code}, for example              'PropertyDefinition/Manager/Id'. (required)
         :type request_body: Dict[str, ModelProperty]
         :param success_mode: Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.
         :type success_mode: str