lusid-sdk 2.1.910__py3-none-any.whl → 2.1.912__py3-none-any.whl

lusid/api/timelines_api.py

@@ -74,7 +74,7 @@ class TimelinesApi:
     def create_closed_period(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the domain and scope this uniquely identifies the Timeline.")], create_closed_period_request : Annotated[Optional[CreateClosedPeriodRequest], Field(description="The request containing the details of the Closed Period")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ClosedPeriod, Awaitable[ClosedPeriod]]:  # noqa: E501
         """[EXPERIMENTAL] CreateClosedPeriod: Create a new closed period against a timeline entity  # noqa: E501
 
-        Creates a new closed period against a timeline entity  Returns the newly created closed period entity with properties  # noqa: E501
+        Creates a new closed period against a timeline entity Returns the newly created closed period entity with properties  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -109,7 +109,7 @@ class TimelinesApi:
     def create_closed_period_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the domain and scope this uniquely identifies the Timeline.")], create_closed_period_request : Annotated[Optional[CreateClosedPeriodRequest], Field(description="The request containing the details of the Closed Period")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] CreateClosedPeriod: Create a new closed period against a timeline entity  # noqa: E501
 
-        Creates a new closed period against a timeline entity  Returns the newly created closed period entity with properties  # noqa: E501
+        Creates a new closed period against a timeline entity Returns the newly created closed period entity with properties  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -249,7 +249,7 @@ class TimelinesApi:
     def create_timeline(self, create_timeline_request : Annotated[Optional[CreateTimelineRequest], Field(description="The request containing the details of the Timeline")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Timeline, Awaitable[Timeline]]:  # noqa: E501
         """[EXPERIMENTAL] CreateTimeline: Create a Timeline  # noqa: E501
 
-        Creates a Timeline. Returns the created Timeline at the current effectiveAt.  Note that Timelines are mono-temporal, however they can have Time-Variant Properties.  Upserted Properties will be returned at the latest AsAt and EffectiveAt  # noqa: E501
+        Creates a Timeline. Returns the created Timeline at the current effectiveAt. Note that Timelines are mono-temporal, however they can have Time-Variant Properties. Upserted Properties will be returned at the latest AsAt and EffectiveAt  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -280,7 +280,7 @@ class TimelinesApi:
     def create_timeline_with_http_info(self, create_timeline_request : Annotated[Optional[CreateTimelineRequest], Field(description="The request containing the details of the Timeline")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] CreateTimeline: Create a Timeline  # noqa: E501
 
-        Creates a Timeline. Returns the created Timeline at the current effectiveAt.  Note that Timelines are mono-temporal, however they can have Time-Variant Properties.  Upserted Properties will be returned at the latest AsAt and EffectiveAt  # noqa: E501
+        Creates a Timeline. Returns the created Timeline at the current effectiveAt. Note that Timelines are mono-temporal, however they can have Time-Variant Properties. Upserted Properties will be returned at the latest AsAt and EffectiveAt  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -397,18 +397,18 @@ class TimelinesApi:
 
 
     @overload
-    async def delete_timeline(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the domain and scope this uniquely              identifies the Timeline.")], **kwargs) -> DeletedEntityResponse:  # noqa: E501
+    async def delete_timeline(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the domain and scope this uniquely             identifies the Timeline.")], **kwargs) -> DeletedEntityResponse:  # noqa: E501
         ...
 
     @overload
-    def delete_timeline(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the domain and scope this uniquely              identifies the Timeline.")], async_req: Optional[bool]=True, **kwargs) -> DeletedEntityResponse:  # noqa: E501
+    def delete_timeline(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the domain and scope this uniquely             identifies the Timeline.")], async_req: Optional[bool]=True, **kwargs) -> DeletedEntityResponse:  # noqa: E501
         ...
 
     @validate_arguments
-    def delete_timeline(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the domain and scope this uniquely              identifies the Timeline.")], async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
+    def delete_timeline(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the domain and scope this uniquely             identifies the Timeline.")], async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
         """[EXPERIMENTAL] DeleteTimeline: Deletes a particular Timeline  # noqa: E501
 
-        The deletion will take effect from the Timeline deletion datetime.  i.e. will no longer exist at any asAt datetime after the asAt datetime of deletion.  # noqa: E501
+        The deletion will take effect from the Timeline deletion datetime. i.e. will no longer exist at any asAt datetime after the asAt datetime of deletion.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -417,7 +417,7 @@ class TimelinesApi:
 
         :param scope: The scope of the specified Timeline. (required)
         :type scope: str
-        :param code: The code of the specified Timeline. Together with the domain and scope this uniquely              identifies the Timeline. (required)
+        :param code: The code of the specified Timeline. Together with the domain and scope this uniquely             identifies the Timeline. (required)
         :type code: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -438,10 +438,10 @@ class TimelinesApi:
         return self.delete_timeline_with_http_info(scope, code, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def delete_timeline_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the domain and scope this uniquely              identifies the Timeline.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def delete_timeline_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the domain and scope this uniquely             identifies the Timeline.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] DeleteTimeline: Deletes a particular Timeline  # noqa: E501
 
-        The deletion will take effect from the Timeline deletion datetime.  i.e. will no longer exist at any asAt datetime after the asAt datetime of deletion.  # noqa: E501
+        The deletion will take effect from the Timeline deletion datetime. i.e. will no longer exist at any asAt datetime after the asAt datetime of deletion.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -450,7 +450,7 @@ class TimelinesApi:
 
         :param scope: The scope of the specified Timeline. (required)
         :type scope: str
-        :param code: The code of the specified Timeline. Together with the domain and scope this uniquely              identifies the Timeline. (required)
+        :param code: The code of the specified Timeline. Together with the domain and scope this uniquely             identifies the Timeline. (required)
         :type code: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -557,15 +557,15 @@ class TimelinesApi:
 
 
     @overload
-    async def get_closed_period(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline. Together with the scope this uniquely              identifies the Timeline.")], closed_period_id : Annotated[StrictStr, Field(..., description="The id of the Closed Period. Together with the scope and code of the Timeline,              this uniquely identifies the ClosedPeriod")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the ClosedPeriod definition. Defaults to return              the latest version of the definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto              the ClosedPeriod.              These must have the format {domain}/{scope}/{code}, for example 'ClosedPeriod/system/Name'.")] = None, **kwargs) -> ClosedPeriod:  # noqa: E501
+    async def get_closed_period(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline. Together with the scope this uniquely             identifies the Timeline.")], closed_period_id : Annotated[StrictStr, Field(..., description="The id of the Closed Period. Together with the scope and code of the Timeline,             this uniquely identifies the ClosedPeriod")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the ClosedPeriod definition. Defaults to return             the latest version of the definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto             the ClosedPeriod.             These must have the format {domain}/{scope}/{code}, for example 'ClosedPeriod/system/Name'.")] = None, **kwargs) -> ClosedPeriod:  # noqa: E501
         ...
 
     @overload
-    def get_closed_period(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline. Together with the scope this uniquely              identifies the Timeline.")], closed_period_id : Annotated[StrictStr, Field(..., description="The id of the Closed Period. Together with the scope and code of the Timeline,              this uniquely identifies the ClosedPeriod")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the ClosedPeriod definition. Defaults to return              the latest version of the definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto              the ClosedPeriod.              These must have the format {domain}/{scope}/{code}, for example 'ClosedPeriod/system/Name'.")] = None, async_req: Optional[bool]=True, **kwargs) -> ClosedPeriod:  # noqa: E501
+    def get_closed_period(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline. Together with the scope this uniquely             identifies the Timeline.")], closed_period_id : Annotated[StrictStr, Field(..., description="The id of the Closed Period. Together with the scope and code of the Timeline,             this uniquely identifies the ClosedPeriod")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the ClosedPeriod definition. Defaults to return             the latest version of the definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto             the ClosedPeriod.             These must have the format {domain}/{scope}/{code}, for example 'ClosedPeriod/system/Name'.")] = None, async_req: Optional[bool]=True, **kwargs) -> ClosedPeriod:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_closed_period(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline. Together with the scope this uniquely              identifies the Timeline.")], closed_period_id : Annotated[StrictStr, Field(..., description="The id of the Closed Period. Together with the scope and code of the Timeline,              this uniquely identifies the ClosedPeriod")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the ClosedPeriod definition. Defaults to return              the latest version of the definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto              the ClosedPeriod.              These must have the format {domain}/{scope}/{code}, for example 'ClosedPeriod/system/Name'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ClosedPeriod, Awaitable[ClosedPeriod]]:  # noqa: E501
+    def get_closed_period(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline. Together with the scope this uniquely             identifies the Timeline.")], closed_period_id : Annotated[StrictStr, Field(..., description="The id of the Closed Period. Together with the scope and code of the Timeline,             this uniquely identifies the ClosedPeriod")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the ClosedPeriod definition. Defaults to return             the latest version of the definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto             the ClosedPeriod.             These must have the format {domain}/{scope}/{code}, for example 'ClosedPeriod/system/Name'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ClosedPeriod, Awaitable[ClosedPeriod]]:  # noqa: E501
         """[EXPERIMENTAL] GetClosedPeriod: Gets a Closed Period entity.  # noqa: E501
 
         Retrieves one ClosedPeriod uniquely defined by the Timelines Scope/Code and a ClosedPeriodId.  # noqa: E501
@@ -577,13 +577,13 @@ class TimelinesApi:
 
         :param scope: The scope of the Timeline. (required)
         :type scope: str
-        :param code: The code of the Timeline. Together with the scope this uniquely              identifies the Timeline. (required)
+        :param code: The code of the Timeline. Together with the scope this uniquely             identifies the Timeline. (required)
         :type code: str
-        :param closed_period_id: The id of the Closed Period. Together with the scope and code of the Timeline,              this uniquely identifies the ClosedPeriod (required)
+        :param closed_period_id: The id of the Closed Period. Together with the scope and code of the Timeline,             this uniquely identifies the ClosedPeriod (required)
         :type closed_period_id: str
-        :param as_at: The asAt datetime at which to retrieve the ClosedPeriod definition. Defaults to return              the latest version of the definition if not specified.
+        :param as_at: The asAt datetime at which to retrieve the ClosedPeriod definition. Defaults to return             the latest version of the definition if not specified.
         :type as_at: datetime
-        :param property_keys: A list of property keys from the 'ClosedPeriod' domain to decorate onto              the ClosedPeriod.              These must have the format {domain}/{scope}/{code}, for example 'ClosedPeriod/system/Name'.
+        :param property_keys: A list of property keys from the 'ClosedPeriod' domain to decorate onto             the ClosedPeriod.             These must have the format {domain}/{scope}/{code}, for example 'ClosedPeriod/system/Name'.
         :type property_keys: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -604,7 +604,7 @@ class TimelinesApi:
         return self.get_closed_period_with_http_info(scope, code, closed_period_id, as_at, property_keys, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_closed_period_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline. Together with the scope this uniquely              identifies the Timeline.")], closed_period_id : Annotated[StrictStr, Field(..., description="The id of the Closed Period. Together with the scope and code of the Timeline,              this uniquely identifies the ClosedPeriod")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the ClosedPeriod definition. Defaults to return              the latest version of the definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto              the ClosedPeriod.              These must have the format {domain}/{scope}/{code}, for example 'ClosedPeriod/system/Name'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_closed_period_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline. Together with the scope this uniquely             identifies the Timeline.")], closed_period_id : Annotated[StrictStr, Field(..., description="The id of the Closed Period. Together with the scope and code of the Timeline,             this uniquely identifies the ClosedPeriod")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the ClosedPeriod definition. Defaults to return             the latest version of the definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto             the ClosedPeriod.             These must have the format {domain}/{scope}/{code}, for example 'ClosedPeriod/system/Name'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] GetClosedPeriod: Gets a Closed Period entity.  # noqa: E501
 
         Retrieves one ClosedPeriod uniquely defined by the Timelines Scope/Code and a ClosedPeriodId.  # noqa: E501
@@ -616,13 +616,13 @@ class TimelinesApi:
 
         :param scope: The scope of the Timeline. (required)
         :type scope: str
-        :param code: The code of the Timeline. Together with the scope this uniquely              identifies the Timeline. (required)
+        :param code: The code of the Timeline. Together with the scope this uniquely             identifies the Timeline. (required)
         :type code: str
-        :param closed_period_id: The id of the Closed Period. Together with the scope and code of the Timeline,              this uniquely identifies the ClosedPeriod (required)
+        :param closed_period_id: The id of the Closed Period. Together with the scope and code of the Timeline,             this uniquely identifies the ClosedPeriod (required)
         :type closed_period_id: str
-        :param as_at: The asAt datetime at which to retrieve the ClosedPeriod definition. Defaults to return              the latest version of the definition if not specified.
+        :param as_at: The asAt datetime at which to retrieve the ClosedPeriod definition. Defaults to return             the latest version of the definition if not specified.
         :type as_at: datetime
-        :param property_keys: A list of property keys from the 'ClosedPeriod' domain to decorate onto              the ClosedPeriod.              These must have the format {domain}/{scope}/{code}, for example 'ClosedPeriod/system/Name'.
+        :param property_keys: A list of property keys from the 'ClosedPeriod' domain to decorate onto             the ClosedPeriod.             These must have the format {domain}/{scope}/{code}, for example 'ClosedPeriod/system/Name'.
         :type property_keys: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -745,18 +745,18 @@ class TimelinesApi:
 
 
     @overload
-    async def get_timeline(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the scope this uniquely              identifies the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Timeline 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 retrieve the timeline properties.              Defaults to the current LUSID system datetime if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Timeline' domain to decorate onto              the Timeline.              These must have the format {domain}/{scope}/{code}, for example 'Timeline/system/Name'.")] = None, **kwargs) -> Timeline:  # noqa: E501
+    async def get_timeline(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the scope this uniquely             identifies the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Timeline 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 retrieve the timeline properties.             Defaults to the current LUSID system datetime if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Timeline' domain to decorate onto             the Timeline.             These must have the format {domain}/{scope}/{code}, for example 'Timeline/system/Name'.")] = None, **kwargs) -> Timeline:  # noqa: E501
         ...
 
     @overload
-    def get_timeline(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the scope this uniquely              identifies the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Timeline 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 retrieve the timeline properties.              Defaults to the current LUSID system datetime if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Timeline' domain to decorate onto              the Timeline.              These must have the format {domain}/{scope}/{code}, for example 'Timeline/system/Name'.")] = None, async_req: Optional[bool]=True, **kwargs) -> Timeline:  # noqa: E501
+    def get_timeline(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the scope this uniquely             identifies the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Timeline 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 retrieve the timeline properties.             Defaults to the current LUSID system datetime if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Timeline' domain to decorate onto             the Timeline.             These must have the format {domain}/{scope}/{code}, for example 'Timeline/system/Name'.")] = None, async_req: Optional[bool]=True, **kwargs) -> Timeline:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_timeline(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the scope this uniquely              identifies the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Timeline 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 retrieve the timeline properties.              Defaults to the current LUSID system datetime if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Timeline' domain to decorate onto              the Timeline.              These must have the format {domain}/{scope}/{code}, for example 'Timeline/system/Name'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Timeline, Awaitable[Timeline]]:  # noqa: E501
+    def get_timeline(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the scope this uniquely             identifies the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Timeline 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 retrieve the timeline properties.             Defaults to the current LUSID system datetime if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Timeline' domain to decorate onto             the Timeline.             These must have the format {domain}/{scope}/{code}, for example 'Timeline/system/Name'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Timeline, Awaitable[Timeline]]:  # noqa: E501
         """[EXPERIMENTAL] GetTimeline: Get a single Timeline by scope and code.  # noqa: E501
 
-        Retrieves one Timeline by scope and code.  Timelines are mono-temporal. The EffectiveAt is only applied to Time-Variant Properties.  # noqa: E501
+        Retrieves one Timeline by scope and code. Timelines are mono-temporal. The EffectiveAt is only applied to Time-Variant Properties.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -765,13 +765,13 @@ class TimelinesApi:
 
         :param scope: The scope of the specified Timeline. (required)
         :type scope: str
-        :param code: The code of the specified Timeline. Together with the scope this uniquely              identifies the Timeline. (required)
+        :param code: The code of the specified Timeline. Together with the scope this uniquely             identifies the Timeline. (required)
         :type code: str
-        :param as_at: The asAt datetime at which to retrieve the Timeline definition. Defaults to return              the latest version of the definition if not specified.
+        :param as_at: The asAt datetime at which to retrieve the Timeline 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 retrieve the timeline properties.              Defaults to the current LUSID system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to retrieve the timeline properties.             Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
-        :param property_keys: A list of property keys from the 'Timeline' domain to decorate onto              the Timeline.              These must have the format {domain}/{scope}/{code}, for example 'Timeline/system/Name'.
+        :param property_keys: A list of property keys from the 'Timeline' domain to decorate onto             the Timeline.             These must have the format {domain}/{scope}/{code}, for example 'Timeline/system/Name'.
         :type property_keys: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -792,10 +792,10 @@ class TimelinesApi:
         return self.get_timeline_with_http_info(scope, code, as_at, effective_at, property_keys, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_timeline_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the scope this uniquely              identifies the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Timeline 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 retrieve the timeline properties.              Defaults to the current LUSID system datetime if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Timeline' domain to decorate onto              the Timeline.              These must have the format {domain}/{scope}/{code}, for example 'Timeline/system/Name'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_timeline_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the scope this uniquely             identifies the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Timeline 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 retrieve the timeline properties.             Defaults to the current LUSID system datetime if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Timeline' domain to decorate onto             the Timeline.             These must have the format {domain}/{scope}/{code}, for example 'Timeline/system/Name'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] GetTimeline: Get a single Timeline by scope and code.  # noqa: E501
 
-        Retrieves one Timeline by scope and code.  Timelines are mono-temporal. The EffectiveAt is only applied to Time-Variant Properties.  # noqa: E501
+        Retrieves one Timeline by scope and code. Timelines are mono-temporal. The EffectiveAt is only applied to Time-Variant Properties.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -804,13 +804,13 @@ class TimelinesApi:
 
         :param scope: The scope of the specified Timeline. (required)
         :type scope: str
-        :param code: The code of the specified Timeline. Together with the scope this uniquely              identifies the Timeline. (required)
+        :param code: The code of the specified Timeline. Together with the scope this uniquely             identifies the Timeline. (required)
         :type code: str
-        :param as_at: The asAt datetime at which to retrieve the Timeline definition. Defaults to return              the latest version of the definition if not specified.
+        :param as_at: The asAt datetime at which to retrieve the Timeline 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 retrieve the timeline properties.              Defaults to the current LUSID system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to retrieve the timeline properties.             Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
-        :param property_keys: A list of property keys from the 'Timeline' domain to decorate onto              the Timeline.              These must have the format {domain}/{scope}/{code}, for example 'Timeline/system/Name'.
+        :param property_keys: A list of property keys from the 'Timeline' domain to decorate onto             the Timeline.             These must have the format {domain}/{scope}/{code}, for example 'Timeline/system/Name'.
         :type property_keys: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -933,15 +933,15 @@ class TimelinesApi:
 
 
     @overload
-    async def list_closed_periods(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing ClosedPeriods; this              value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.              These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.")] = None, **kwargs) -> PagedResourceListOfClosedPeriod:  # noqa: E501
+    async def list_closed_periods(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing ClosedPeriods; this             value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt             and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.             For example, to filter on the effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". For more information about filtering             results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.             These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.")] = None, **kwargs) -> PagedResourceListOfClosedPeriod:  # noqa: E501
         ...
 
     @overload
-    def list_closed_periods(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing ClosedPeriods; this              value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.              These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfClosedPeriod:  # noqa: E501
+    def list_closed_periods(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing ClosedPeriods; this             value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt             and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.             For example, to filter on the effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". For more information about filtering             results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.             These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfClosedPeriod:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_closed_periods(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing ClosedPeriods; this              value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.              These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfClosedPeriod, Awaitable[PagedResourceListOfClosedPeriod]]:  # noqa: E501
+    def list_closed_periods(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing ClosedPeriods; this             value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt             and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.             For example, to filter on the effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". For more information about filtering             results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.             These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfClosedPeriod, Awaitable[PagedResourceListOfClosedPeriod]]:  # noqa: E501
         """[EXPERIMENTAL] ListClosedPeriods: List ClosedPeriods for a specified Timeline.  # noqa: E501
 
         List all the ClosedPeriods matching a particular criteria.  # noqa: E501
@@ -957,15 +957,15 @@ class TimelinesApi:
         :type code: str
         :param as_at: The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.
         :type as_at: datetime
-        :param page: The pagination token to use to continue listing ClosedPeriods; this              value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt              and asAt fields must not have changed since the original request.
+        :param page: The pagination token to use to continue listing ClosedPeriods; this             value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt             and asAt fields must not have changed since the original request.
         :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 effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". 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 effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". 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]
-        :param property_keys: A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.              These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.
+        :param property_keys: A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.             These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.
         :type property_keys: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -986,7 +986,7 @@ class TimelinesApi:
         return self.list_closed_periods_with_http_info(scope, code, as_at, page, limit, filter, sort_by, property_keys, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_closed_periods_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing ClosedPeriods; this              value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt              and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.              For example, to filter on the effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.              These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_closed_periods_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing ClosedPeriods; this             value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt             and asAt fields must not have changed since the original request.")] = None, limit : Annotated[Optional[conint(strict=True)], Field(description="When paginating, limit the results to this number. Defaults to 100 if not specified.")] = None, filter : Annotated[Optional[StrictStr], Field( description="Expression to filter the results.             For example, to filter on the effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". For more information about filtering             results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.             These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] ListClosedPeriods: List ClosedPeriods for a specified Timeline.  # noqa: E501
 
         List all the ClosedPeriods matching a particular criteria.  # noqa: E501
@@ -1002,15 +1002,15 @@ class TimelinesApi:
         :type code: str
         :param as_at: The asAt datetime at which to list the ClosedPeriods. Defaults to returning the latest version of each ClosedPeriod if not specified.
         :type as_at: datetime
-        :param page: The pagination token to use to continue listing ClosedPeriods; this              value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt              and asAt fields must not have changed since the original request.
+        :param page: The pagination token to use to continue listing ClosedPeriods; this             value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt             and asAt fields must not have changed since the original request.
         :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 effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". 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 effectiveEnd, specify \"effectiveEnd gt 2019-01-15T10:00:00\". 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]
-        :param property_keys: A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.              These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.
+        :param property_keys: A list of property keys from the 'ClosedPeriod' domain to decorate onto each ClosedPeriod.             These must take the format {domain}/{scope}/{code}, for example 'ClosedPeriod/Account/id'.
         :type property_keys: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -1146,15 +1146,15 @@ class TimelinesApi:
 
 
     @overload
-    async def list_timelines(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the Timelines. Defaults to returning the latest version of each Timeline if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the Timelines.              Note that Timelines are monotemporal, the effectiveAt is for Timevariant Properties on the Timeline only.              Defaults to the current LUSID system datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Timelines; 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 displayName, specify \"displayName eq 'AccountingTimeline'\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Timeline' domain to decorate onto each Timeline.              These must take the format {domain}/{scope}/{code}, for example 'Timeline/Account/id'.")] = None, **kwargs) -> PagedResourceListOfTimeline:  # noqa: E501
+    async def list_timelines(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the Timelines. Defaults to returning the latest version of each Timeline if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the Timelines.             Note that Timelines are monotemporal, the effectiveAt is for Timevariant Properties on the Timeline only.             Defaults to the current LUSID system datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Timelines; 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 displayName, specify \"displayName eq 'AccountingTimeline'\". For more information about filtering             results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Timeline' domain to decorate onto each Timeline.             These must take the format {domain}/{scope}/{code}, for example 'Timeline/Account/id'.")] = None, **kwargs) -> PagedResourceListOfTimeline:  # noqa: E501
         ...
 
     @overload
-    def list_timelines(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the Timelines. Defaults to returning the latest version of each Timeline if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the Timelines.              Note that Timelines are monotemporal, the effectiveAt is for Timevariant Properties on the Timeline only.              Defaults to the current LUSID system datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Timelines; 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 displayName, specify \"displayName eq 'AccountingTimeline'\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Timeline' domain to decorate onto each Timeline.              These must take the format {domain}/{scope}/{code}, for example 'Timeline/Account/id'.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfTimeline:  # noqa: E501
+    def list_timelines(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the Timelines. Defaults to returning the latest version of each Timeline if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the Timelines.             Note that Timelines are monotemporal, the effectiveAt is for Timevariant Properties on the Timeline only.             Defaults to the current LUSID system datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Timelines; 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 displayName, specify \"displayName eq 'AccountingTimeline'\". For more information about filtering             results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Timeline' domain to decorate onto each Timeline.             These must take the format {domain}/{scope}/{code}, for example 'Timeline/Account/id'.")] = None, async_req: Optional[bool]=True, **kwargs) -> PagedResourceListOfTimeline:  # noqa: E501
         ...
 
     @validate_arguments
-    def list_timelines(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the Timelines. Defaults to returning the latest version of each Timeline if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the Timelines.              Note that Timelines are monotemporal, the effectiveAt is for Timevariant Properties on the Timeline only.              Defaults to the current LUSID system datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Timelines; 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 displayName, specify \"displayName eq 'AccountingTimeline'\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Timeline' domain to decorate onto each Timeline.              These must take the format {domain}/{scope}/{code}, for example 'Timeline/Account/id'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfTimeline, Awaitable[PagedResourceListOfTimeline]]:  # noqa: E501
+    def list_timelines(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the Timelines. Defaults to returning the latest version of each Timeline if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the Timelines.             Note that Timelines are monotemporal, the effectiveAt is for Timevariant Properties on the Timeline only.             Defaults to the current LUSID system datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Timelines; 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 displayName, specify \"displayName eq 'AccountingTimeline'\". For more information about filtering             results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Timeline' domain to decorate onto each Timeline.             These must take the format {domain}/{scope}/{code}, for example 'Timeline/Account/id'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PagedResourceListOfTimeline, Awaitable[PagedResourceListOfTimeline]]:  # noqa: E501
         """[EXPERIMENTAL] ListTimelines: List Timelines  # noqa: E501
 
         List all the Timelines matching a particular criteria.  # noqa: E501
@@ -1166,17 +1166,17 @@ class TimelinesApi:
 
         :param as_at: The asAt datetime at which to list the Timelines. Defaults to returning the latest version of each Timeline if not specified.
         :type as_at: datetime
-        :param effective_at: The effective datetime or cut label at which to list the Timelines.              Note that Timelines are monotemporal, the effectiveAt is for Timevariant Properties on the Timeline only.              Defaults to the current LUSID system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to list the Timelines.             Note that Timelines are monotemporal, the effectiveAt is for Timevariant Properties on the Timeline only.             Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
-        :param page: The pagination token to use to continue listing Timelines; 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 Timelines; 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 displayName, specify \"displayName eq 'AccountingTimeline'\". 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 displayName, specify \"displayName eq 'AccountingTimeline'\". 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]
-        :param property_keys: A list of property keys from the 'Timeline' domain to decorate onto each Timeline.              These must take the format {domain}/{scope}/{code}, for example 'Timeline/Account/id'.
+        :param property_keys: A list of property keys from the 'Timeline' domain to decorate onto each Timeline.             These must take the format {domain}/{scope}/{code}, for example 'Timeline/Account/id'.
         :type property_keys: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -1197,7 +1197,7 @@ class TimelinesApi:
         return self.list_timelines_with_http_info(as_at, effective_at, page, limit, filter, sort_by, property_keys, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def list_timelines_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the Timelines. Defaults to returning the latest version of each Timeline if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the Timelines.              Note that Timelines are monotemporal, the effectiveAt is for Timevariant Properties on the Timeline only.              Defaults to the current LUSID system datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Timelines; 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 displayName, specify \"displayName eq 'AccountingTimeline'\". For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Timeline' domain to decorate onto each Timeline.              These must take the format {domain}/{scope}/{code}, for example 'Timeline/Account/id'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def list_timelines_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to list the Timelines. Defaults to returning the latest version of each Timeline if not specified.")] = None, effective_at : Annotated[Optional[StrictStr], Field( description="The effective datetime or cut label at which to list the Timelines.             Note that Timelines are monotemporal, the effectiveAt is for Timevariant Properties on the Timeline only.             Defaults to the current LUSID system datetime if not specified.")] = None, page : Annotated[Optional[StrictStr], Field( description="The pagination token to use to continue listing Timelines; 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 displayName, specify \"displayName eq 'AccountingTimeline'\". For more information about filtering             results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\"")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'Timeline' domain to decorate onto each Timeline.             These must take the format {domain}/{scope}/{code}, for example 'Timeline/Account/id'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] ListTimelines: List Timelines  # noqa: E501
 
         List all the Timelines matching a particular criteria.  # noqa: E501
@@ -1209,17 +1209,17 @@ class TimelinesApi:
 
         :param as_at: The asAt datetime at which to list the Timelines. Defaults to returning the latest version of each Timeline if not specified.
         :type as_at: datetime
-        :param effective_at: The effective datetime or cut label at which to list the Timelines.              Note that Timelines are monotemporal, the effectiveAt is for Timevariant Properties on the Timeline only.              Defaults to the current LUSID system datetime if not specified.
+        :param effective_at: The effective datetime or cut label at which to list the Timelines.             Note that Timelines are monotemporal, the effectiveAt is for Timevariant Properties on the Timeline only.             Defaults to the current LUSID system datetime if not specified.
         :type effective_at: str
-        :param page: The pagination token to use to continue listing Timelines; 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 Timelines; 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 displayName, specify \"displayName eq 'AccountingTimeline'\". 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 displayName, specify \"displayName eq 'AccountingTimeline'\". 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]
-        :param property_keys: A list of property keys from the 'Timeline' domain to decorate onto each Timeline.              These must take the format {domain}/{scope}/{code}, for example 'Timeline/Account/id'.
+        :param property_keys: A list of property keys from the 'Timeline' domain to decorate onto each Timeline.             These must take the format {domain}/{scope}/{code}, for example 'Timeline/Account/id'.
         :type property_keys: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -1351,15 +1351,15 @@ class TimelinesApi:
 
 
     @overload
-    async def set_post_close_activity(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], closed_period_id : Annotated[StrictStr, Field(..., description="The id of the Closed Period. Together with the scope and code of the Timeline,              this uniquely identifies the ClosedPeriod")], post_close_activities_request : Annotated[Optional[PostCloseActivitiesRequest], Field(description="Specifies collection of post close activities")] = None, **kwargs) -> ClosedPeriod:  # noqa: E501
+    async def set_post_close_activity(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], closed_period_id : Annotated[StrictStr, Field(..., description="The id of the Closed Period. Together with the scope and code of the Timeline,             this uniquely identifies the ClosedPeriod")], post_close_activities_request : Annotated[Optional[PostCloseActivitiesRequest], Field(description="Specifies collection of post close activities")] = None, **kwargs) -> ClosedPeriod:  # noqa: E501
         ...
 
     @overload
-    def set_post_close_activity(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], closed_period_id : Annotated[StrictStr, Field(..., description="The id of the Closed Period. Together with the scope and code of the Timeline,              this uniquely identifies the ClosedPeriod")], post_close_activities_request : Annotated[Optional[PostCloseActivitiesRequest], Field(description="Specifies collection of post close activities")] = None, async_req: Optional[bool]=True, **kwargs) -> ClosedPeriod:  # noqa: E501
+    def set_post_close_activity(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], closed_period_id : Annotated[StrictStr, Field(..., description="The id of the Closed Period. Together with the scope and code of the Timeline,             this uniquely identifies the ClosedPeriod")], post_close_activities_request : Annotated[Optional[PostCloseActivitiesRequest], Field(description="Specifies collection of post close activities")] = None, async_req: Optional[bool]=True, **kwargs) -> ClosedPeriod:  # noqa: E501
         ...
 
     @validate_arguments
-    def set_post_close_activity(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], closed_period_id : Annotated[StrictStr, Field(..., description="The id of the Closed Period. Together with the scope and code of the Timeline,              this uniquely identifies the ClosedPeriod")], post_close_activities_request : Annotated[Optional[PostCloseActivitiesRequest], Field(description="Specifies collection of post close activities")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ClosedPeriod, Awaitable[ClosedPeriod]]:  # noqa: E501
+    def set_post_close_activity(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], closed_period_id : Annotated[StrictStr, Field(..., description="The id of the Closed Period. Together with the scope and code of the Timeline,             this uniquely identifies the ClosedPeriod")], post_close_activities_request : Annotated[Optional[PostCloseActivitiesRequest], Field(description="Specifies collection of post close activities")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ClosedPeriod, Awaitable[ClosedPeriod]]:  # noqa: E501
         """[EXPERIMENTAL] SetPostCloseActivity: Sets post close activities to a closed period.  # noqa: E501
 
         Sets empty or more post close activities to the specific closed period.  # noqa: E501
@@ -1373,7 +1373,7 @@ class TimelinesApi:
         :type scope: str
         :param code: The code of the Timeline. (required)
         :type code: str
-        :param closed_period_id: The id of the Closed Period. Together with the scope and code of the Timeline,              this uniquely identifies the ClosedPeriod (required)
+        :param closed_period_id: The id of the Closed Period. Together with the scope and code of the Timeline,             this uniquely identifies the ClosedPeriod (required)
         :type closed_period_id: str
         :param post_close_activities_request: Specifies collection of post close activities
         :type post_close_activities_request: PostCloseActivitiesRequest
@@ -1396,7 +1396,7 @@ class TimelinesApi:
         return self.set_post_close_activity_with_http_info(scope, code, closed_period_id, post_close_activities_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def set_post_close_activity_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], closed_period_id : Annotated[StrictStr, Field(..., description="The id of the Closed Period. Together with the scope and code of the Timeline,              this uniquely identifies the ClosedPeriod")], post_close_activities_request : Annotated[Optional[PostCloseActivitiesRequest], Field(description="Specifies collection of post close activities")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def set_post_close_activity_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the Timeline.")], closed_period_id : Annotated[StrictStr, Field(..., description="The id of the Closed Period. Together with the scope and code of the Timeline,             this uniquely identifies the ClosedPeriod")], post_close_activities_request : Annotated[Optional[PostCloseActivitiesRequest], Field(description="Specifies collection of post close activities")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] SetPostCloseActivity: Sets post close activities to a closed period.  # noqa: E501
 
         Sets empty or more post close activities to the specific closed period.  # noqa: E501
@@ -1410,7 +1410,7 @@ class TimelinesApi:
         :type scope: str
         :param code: The code of the Timeline. (required)
         :type code: str
-        :param closed_period_id: The id of the Closed Period. Together with the scope and code of the Timeline,              this uniquely identifies the ClosedPeriod (required)
+        :param closed_period_id: The id of the Closed Period. Together with the scope and code of the Timeline,             this uniquely identifies the ClosedPeriod (required)
         :type closed_period_id: str
         :param post_close_activities_request: Specifies collection of post close activities
         :type post_close_activities_request: PostCloseActivitiesRequest
@@ -1545,7 +1545,7 @@ class TimelinesApi:
     def update_timeline(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the domain and scope this uniquely identifies the Timeline.")], update_timeline_request : Annotated[Optional[UpdateTimelineRequest], Field(description="The request containing the updated details of the Timeline")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Timeline, Awaitable[Timeline]]:  # noqa: E501
         """[EXPERIMENTAL] UpdateTimeline: Update Timeline defined by scope and code  # noqa: E501
 
-        Overwrites an existing Timeline  Update request has the same required fields as Create apart from the id.  Returns the updated Timeline at the current effectiveAt.  Note that Timelines are mono-temporal, however they can have Time-Variant Properties.  Updated Properties will be returned at the latest AsAt and EffectiveAt  # noqa: E501
+        Overwrites an existing Timeline Update request has the same required fields as Create apart from the id. Returns the updated Timeline at the current effectiveAt. Note that Timelines are mono-temporal, however they can have Time-Variant Properties. Updated Properties will be returned at the latest AsAt and EffectiveAt  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -1580,7 +1580,7 @@ class TimelinesApi:
     def update_timeline_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the specified Timeline.")], code : Annotated[StrictStr, Field(..., description="The code of the specified Timeline. Together with the domain and scope this uniquely identifies the Timeline.")], update_timeline_request : Annotated[Optional[UpdateTimelineRequest], Field(description="The request containing the updated details of the Timeline")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] UpdateTimeline: Update Timeline defined by scope and code  # noqa: E501
 
-        Overwrites an existing Timeline  Update request has the same required fields as Create apart from the id.  Returns the updated Timeline at the current effectiveAt.  Note that Timelines are mono-temporal, however they can have Time-Variant Properties.  Updated Properties will be returned at the latest AsAt and EffectiveAt  # noqa: E501
+        Overwrites an existing Timeline Update request has the same required fields as Create apart from the id. Returns the updated Timeline at the current effectiveAt. Note that Timelines are mono-temporal, however they can have Time-Variant Properties. Updated Properties will be returned at the latest AsAt and EffectiveAt  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True