lusid-sdk 2.1.590__py3-none-any.whl → 2.1.603__py3-none-any.whl

lusid/api/transaction_portfolios_api.py

@@ -2893,15 +2893,15 @@ class TransactionPortfoliosApi:
             _request_auth=_params.get('_request_auth'))
 
     @overload
-    async def get_custodian_account(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Transaction Portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Transaction Portfolio. Together with the scope this uniquely identifies the Transaction Portfolio.")], custodian_account_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Custodian Account.")], custodian_account_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Custodian Account.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to retrieve the Custodian Account properties. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Custodian Account definition. Defaults to returning the latest version of the Custodian Account definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustodianAccount' domain to decorate onto the Custodian Account.              These must take the format {domain}/{scope}/{code}, for example 'CustodianAccount/Manager/Id'. If not provided will return all the entitled properties for that Custodian Account.")] = None, **kwargs) -> CustodianAccount:  # noqa: E501
+    async def get_custodian_account(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Transaction Portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Transaction Portfolio. Together with the scope this uniquely identifies the Transaction Portfolio.")], custodian_account_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Custodian Account.")], custodian_account_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Custodian Account.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to retrieve the Custodian Account properties. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Custodian Account definition. Defaults to returning the latest version of the Custodian Account definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustodianAccount' domain to decorate onto the Custodian Account.              These must take the format {domain}/{scope}/{code}, for example 'CustodianAccount/Manager/Id'. If no properties are specified, then no properties will be returned.")] = None, **kwargs) -> CustodianAccount:  # noqa: E501
         ...
 
     @overload
-    def get_custodian_account(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Transaction Portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Transaction Portfolio. Together with the scope this uniquely identifies the Transaction Portfolio.")], custodian_account_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Custodian Account.")], custodian_account_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Custodian Account.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to retrieve the Custodian Account properties. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Custodian Account definition. Defaults to returning the latest version of the Custodian Account definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustodianAccount' domain to decorate onto the Custodian Account.              These must take the format {domain}/{scope}/{code}, for example 'CustodianAccount/Manager/Id'. If not provided will return all the entitled properties for that Custodian Account.")] = None, async_req: Optional[bool]=True, **kwargs) -> CustodianAccount:  # noqa: E501
+    def get_custodian_account(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Transaction Portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Transaction Portfolio. Together with the scope this uniquely identifies the Transaction Portfolio.")], custodian_account_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Custodian Account.")], custodian_account_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Custodian Account.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to retrieve the Custodian Account properties. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Custodian Account definition. Defaults to returning the latest version of the Custodian Account definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustodianAccount' domain to decorate onto the Custodian Account.              These must take the format {domain}/{scope}/{code}, for example 'CustodianAccount/Manager/Id'. If no properties are specified, then no properties will be returned.")] = None, async_req: Optional[bool]=True, **kwargs) -> CustodianAccount:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_custodian_account(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Transaction Portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Transaction Portfolio. Together with the scope this uniquely identifies the Transaction Portfolio.")], custodian_account_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Custodian Account.")], custodian_account_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Custodian Account.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to retrieve the Custodian Account properties. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Custodian Account definition. Defaults to returning the latest version of the Custodian Account definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustodianAccount' domain to decorate onto the Custodian Account.              These must take the format {domain}/{scope}/{code}, for example 'CustodianAccount/Manager/Id'. If not provided will return all the entitled properties for that Custodian Account.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[CustodianAccount, Awaitable[CustodianAccount]]:  # noqa: E501
+    def get_custodian_account(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Transaction Portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Transaction Portfolio. Together with the scope this uniquely identifies the Transaction Portfolio.")], custodian_account_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Custodian Account.")], custodian_account_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Custodian Account.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to retrieve the Custodian Account properties. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Custodian Account definition. Defaults to returning the latest version of the Custodian Account definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustodianAccount' domain to decorate onto the Custodian Account.              These must take the format {domain}/{scope}/{code}, for example 'CustodianAccount/Manager/Id'. If no properties are specified, then no properties will be returned.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[CustodianAccount, Awaitable[CustodianAccount]]:  # noqa: E501
         """[EXPERIMENTAL] GetCustodianAccount: Get Custodian Account  # noqa: E501
 
         Retrieve the definition of a particular Custodian Account which is part of a Transaction Portfolios.  # noqa: E501
@@ -2923,7 +2923,7 @@ class TransactionPortfoliosApi:
         :type effective_at: str
         :param as_at: The asAt datetime at which to retrieve the Custodian Account definition. Defaults to returning the latest version of the Custodian Account definition if not specified.
         :type as_at: datetime
-        :param property_keys: A list of property keys from the 'CustodianAccount' domain to decorate onto the Custodian Account.              These must take the format {domain}/{scope}/{code}, for example 'CustodianAccount/Manager/Id'. If not provided will return all the entitled properties for that Custodian Account.
+        :param property_keys: A list of property keys from the 'CustodianAccount' domain to decorate onto the Custodian Account.              These must take the format {domain}/{scope}/{code}, for example 'CustodianAccount/Manager/Id'. If no properties are specified, then no properties will be returned.
         :type property_keys: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
@@ -2944,7 +2944,7 @@ class TransactionPortfoliosApi:
         return self.get_custodian_account_with_http_info(scope, code, custodian_account_scope, custodian_account_code, effective_at, as_at, property_keys, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_custodian_account_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Transaction Portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Transaction Portfolio. Together with the scope this uniquely identifies the Transaction Portfolio.")], custodian_account_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Custodian Account.")], custodian_account_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Custodian Account.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to retrieve the Custodian Account properties. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Custodian Account definition. Defaults to returning the latest version of the Custodian Account definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustodianAccount' domain to decorate onto the Custodian Account.              These must take the format {domain}/{scope}/{code}, for example 'CustodianAccount/Manager/Id'. If not provided will return all the entitled properties for that Custodian Account.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_custodian_account_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Transaction Portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Transaction Portfolio. Together with the scope this uniquely identifies the Transaction Portfolio.")], custodian_account_scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the Custodian Account.")], custodian_account_code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the Custodian Account.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to retrieve the Custodian Account properties. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Custodian Account definition. Defaults to returning the latest version of the Custodian Account definition if not specified.")] = None, property_keys : Annotated[Optional[conlist(StrictStr)], Field(description="A list of property keys from the 'CustodianAccount' domain to decorate onto the Custodian Account.              These must take the format {domain}/{scope}/{code}, for example 'CustodianAccount/Manager/Id'. If no properties are specified, then no properties will be returned.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] GetCustodianAccount: Get Custodian Account  # noqa: E501
 
         Retrieve the definition of a particular Custodian Account which is part of a Transaction Portfolios.  # noqa: E501
@@ -2966,7 +2966,7 @@ class TransactionPortfoliosApi:
         :type effective_at: str
         :param as_at: The asAt datetime at which to retrieve the Custodian Account definition. Defaults to returning the latest version of the Custodian Account definition if not specified.
         :type as_at: datetime
-        :param property_keys: A list of property keys from the 'CustodianAccount' domain to decorate onto the Custodian Account.              These must take the format {domain}/{scope}/{code}, for example 'CustodianAccount/Manager/Id'. If not provided will return all the entitled properties for that Custodian Account.
+        :param property_keys: A list of property keys from the 'CustodianAccount' domain to decorate onto the Custodian Account.              These must take the format {domain}/{scope}/{code}, for example 'CustodianAccount/Manager/Id'. If no properties are specified, then no properties will be returned.
         :type property_keys: List[str]
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional

lusid/configuration.py

@@ -445,7 +445,7 @@ class Configuration:
         return "Python SDK Debug Report:\n"\
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
-               "Version of the API: 0.11.7074\n"\
+               "Version of the API: 0.11.7104\n"\
                "SDK Package Version: {package_version}".\
                format(env=sys.platform, pyversion=sys.version, package_version=package_version)
 

lusid/models/__init__.py

@@ -246,6 +246,7 @@ from lusid.models.create_relationship_request import CreateRelationshipRequest
 from lusid.models.create_sequence_request import CreateSequenceRequest
 from lusid.models.create_staging_rule_set_request import CreateStagingRuleSetRequest
 from lusid.models.create_tax_rule_set_request import CreateTaxRuleSetRequest
+from lusid.models.create_timeline_request import CreateTimelineRequest
 from lusid.models.create_trade_tickets_response import CreateTradeTicketsResponse
 from lusid.models.create_transaction_portfolio_request import CreateTransactionPortfolioRequest
 from lusid.models.create_unit_definition import CreateUnitDefinition
@@ -989,6 +990,7 @@ from lusid.models.tender_event import TenderEvent
 from lusid.models.term_deposit import TermDeposit
 from lusid.models.term_deposit_interest_event import TermDepositInterestEvent
 from lusid.models.term_deposit_principal_event import TermDepositPrincipalEvent
+from lusid.models.timeline import Timeline
 from lusid.models.total_return_swap import TotalReturnSwap
 from lusid.models.touch import Touch
 from lusid.models.trade_ticket import TradeTicket
@@ -1072,6 +1074,7 @@ from lusid.models.update_reference_data_request import UpdateReferenceDataReques
 from lusid.models.update_relationship_definition_request import UpdateRelationshipDefinitionRequest
 from lusid.models.update_staging_rule_set_request import UpdateStagingRuleSetRequest
 from lusid.models.update_tax_rule_set_request import UpdateTaxRuleSetRequest
+from lusid.models.update_timeline_request import UpdateTimelineRequest
 from lusid.models.update_unit_request import UpdateUnitRequest
 from lusid.models.upsert_cds_flow_conventions_request import UpsertCdsFlowConventionsRequest
 from lusid.models.upsert_complex_market_data_request import UpsertComplexMarketDataRequest
@@ -1393,6 +1396,7 @@ __all__ = [
     "CreateSequenceRequest",
     "CreateStagingRuleSetRequest",
     "CreateTaxRuleSetRequest",
+    "CreateTimelineRequest",
     "CreateTradeTicketsResponse",
     "CreateTransactionPortfolioRequest",
     "CreateUnitDefinition",
@@ -2136,6 +2140,7 @@ __all__ = [
     "TermDeposit",
     "TermDepositInterestEvent",
     "TermDepositPrincipalEvent",
+    "Timeline",
     "TotalReturnSwap",
     "Touch",
     "TradeTicket",
@@ -2219,6 +2224,7 @@ __all__ = [
     "UpdateRelationshipDefinitionRequest",
     "UpdateStagingRuleSetRequest",
     "UpdateTaxRuleSetRequest",
+    "UpdateTimelineRequest",
     "UpdateUnitRequest",
     "UpsertCdsFlowConventionsRequest",
     "UpsertComplexMarketDataRequest",

lusid/models/create_derived_property_definition_request.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, Field, StrictStr, constr, validator
+from pydantic.v1 import BaseModel, Field, StrictBool, StrictStr, constr, validator
 from lusid.models.resource_id import ResourceId
 
 class CreateDerivedPropertyDefinitionRequest(BaseModel):
@@ -33,7 +33,8 @@ class CreateDerivedPropertyDefinitionRequest(BaseModel):
     data_type_id: ResourceId = Field(..., alias="dataTypeId")
     property_description: Optional[constr(strict=True, max_length=512)] = Field(None, alias="propertyDescription", description="Describes the property")
     derivation_formula: constr(strict=True, min_length=1) = Field(..., alias="derivationFormula", description="The rule that defines how data is composed for a derived property.")
-    __properties = ["domain", "scope", "code", "displayName", "dataTypeId", "propertyDescription", "derivationFormula"]
+    is_filterable: StrictBool = Field(..., alias="isFilterable", description="Bool indicating whether the values of this property are fitlerable, this is true for all non-derived property defintions.  For a derived definition this must be set true to enable filtering.")
+    __properties = ["domain", "scope", "code", "displayName", "dataTypeId", "propertyDescription", "derivationFormula", "isFilterable"]
 
     @validator('domain')
     def domain_validate_enum(cls, value):
@@ -92,6 +93,7 @@ class CreateDerivedPropertyDefinitionRequest(BaseModel):
             "display_name": obj.get("displayName"),
             "data_type_id": ResourceId.from_dict(obj.get("dataTypeId")) if obj.get("dataTypeId") is not None else None,
             "property_description": obj.get("propertyDescription"),
-            "derivation_formula": obj.get("derivationFormula")
+            "derivation_formula": obj.get("derivationFormula"),
+            "is_filterable": obj.get("isFilterable")
         })
         return _obj

lusid/models/create_timeline_request.py

@@ -0,0 +1,102 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict, Optional
+from pydantic.v1 import BaseModel, Field, constr
+from lusid.models.model_property import ModelProperty
+from lusid.models.resource_id import ResourceId
+
+class CreateTimelineRequest(BaseModel):
+    """
+    CreateTimelineRequest
+    """
+    id: ResourceId = Field(...)
+    display_name: constr(strict=True, max_length=512, min_length=0) = Field(..., alias="displayName", description="The name of the Timeline.")
+    description: Optional[constr(strict=True, max_length=512, min_length=0)] = Field(None, description="A description for the Timeline.")
+    properties: Optional[Dict[str, ModelProperty]] = Field(None, description="The Timelines properties. These will be from the 'Timeline' domain.")
+    __properties = ["id", "displayName", "description", "properties"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> CreateTimelineRequest:
+        """Create an instance of CreateTimelineRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of id
+        if self.id:
+            _dict['id'] = self.id.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each value in properties (dict)
+        _field_dict = {}
+        if self.properties:
+            for _key in self.properties:
+                if self.properties[_key]:
+                    _field_dict[_key] = self.properties[_key].to_dict()
+            _dict['properties'] = _field_dict
+        # set to None if description (nullable) is None
+        # and __fields_set__ contains the field
+        if self.description is None and "description" in self.__fields_set__:
+            _dict['description'] = None
+
+        # set to None if properties (nullable) is None
+        # and __fields_set__ contains the field
+        if self.properties is None and "properties" in self.__fields_set__:
+            _dict['properties'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> CreateTimelineRequest:
+        """Create an instance of CreateTimelineRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return CreateTimelineRequest.parse_obj(obj)
+
+        _obj = CreateTimelineRequest.parse_obj({
+            "id": ResourceId.from_dict(obj.get("id")) if obj.get("id") is not None else None,
+            "display_name": obj.get("displayName"),
+            "description": obj.get("description"),
+            "properties": dict(
+                (_k, ModelProperty.from_dict(_v))
+                for _k, _v in obj.get("properties").items()
+            )
+            if obj.get("properties") is not None
+            else None
+        })
+        return _obj

lusid/models/equity_option.py

@@ -29,7 +29,7 @@ class EquityOption(LusidInstrument):
     """
     start_date: datetime = Field(..., alias="startDate", description="The start date of the instrument. This is normally synonymous with the trade-date.")
     option_maturity_date: datetime = Field(..., alias="optionMaturityDate", description="The maturity date of the option.")
-    option_settlement_date: datetime = Field(..., alias="optionSettlementDate", description="The settlement date of the option.")
+    option_settlement_date: Optional[datetime] = Field(None, alias="optionSettlementDate", description="The settlement date of the option.")
     delivery_type: constr(strict=True, min_length=1) = Field(..., alias="deliveryType", description="Is the option cash settled or physical delivery of option    Supported string (enumeration) values are: [Cash, Physical].")
     option_type: constr(strict=True, min_length=1) = Field(..., alias="optionType", description="Type of optionality for the option    Supported string (enumeration) values are: [Call, Put].")
     strike: Union[StrictFloat, StrictInt] = Field(..., description="The strike of the option.")
@@ -88,6 +88,11 @@ class EquityOption(LusidInstrument):
             for _key, _value in self.additional_properties.items():
                 _dict[_key] = _value
 
+        # set to None if option_settlement_date (nullable) is None
+        # and __fields_set__ contains the field
+        if self.option_settlement_date is None and "option_settlement_date" in self.__fields_set__:
+            _dict['optionSettlementDate'] = None
+
         # set to None if underlying_identifier (nullable) is None
         # and __fields_set__ contains the field
         if self.underlying_identifier is None and "underlying_identifier" in self.__fields_set__:

lusid/models/interest_rate_swaption.py

@@ -29,7 +29,7 @@ class InterestRateSwaption(LusidInstrument):
     LUSID representation of an Interest Rate Swaption.  # noqa: E501
     """
     start_date: datetime = Field(..., alias="startDate", description="The start date of the instrument. This is normally synonymous with the trade-date.")
-    pay_or_receive_fixed: constr(strict=True, min_length=1) = Field(..., alias="payOrReceiveFixed", description="True if on exercise the holder of the option enters the swap paying fixed, false if floating.    Supported string (enumeration) values are: [Pay, Receive].")
+    pay_or_receive_fixed: constr(strict=True, min_length=1) = Field(..., alias="payOrReceiveFixed", description="Pay or Receive the fixed leg of the underlying swap.    Supported string (enumeration) values are: [Pay, Receive].")
     premium: Optional[Premium] = None
     delivery_method: constr(strict=True, min_length=1) = Field(..., alias="deliveryMethod", description="How does the option settle    Supported string (enumeration) values are: [Cash, Physical].")
     swap: InterestRateSwap = Field(...)

lusid/models/output_transaction.py

@@ -21,6 +21,7 @@ from datetime import datetime
 from typing import Any, Dict, List, Optional, Union
 from pydantic.v1 import BaseModel, Field, StrictFloat, StrictInt, StrictStr, conlist, constr, validator
 from lusid.models.currency_and_amount import CurrencyAndAmount
+from lusid.models.custodian_account import CustodianAccount
 from lusid.models.perpetual_property import PerpetualProperty
 from lusid.models.realised_gain_loss import RealisedGainLoss
 from lusid.models.transaction_price import TransactionPrice
@@ -55,9 +56,10 @@ class OutputTransaction(BaseModel):
     holding_ids: Optional[conlist(StrictInt)] = Field(None, alias="holdingIds", description="The collection of single identifiers for the holding within the portfolio. The holdingId is constructed from the LusidInstrumentId, sub-holding keys and currrency and is unique within the portfolio.")
     source_type: Optional[StrictStr] = Field(None, alias="sourceType", description="The type of source that the transaction originated from, eg: InputTransaction, InstrumentEvent, HoldingAdjustment")
     source_instrument_event_id: Optional[StrictStr] = Field(None, alias="sourceInstrumentEventId", description="The unique ID of the instrument event that the transaction is related to.")
+    custodian_account: Optional[CustodianAccount] = Field(None, alias="custodianAccount")
     transaction_group_id: Optional[StrictStr] = Field(None, alias="transactionGroupId", description="The identifier for grouping economic events across multiple transactions")
     resolved_transaction_type_details: Optional[TransactionTypeDetails] = Field(None, alias="resolvedTransactionTypeDetails")
-    __properties = ["transactionId", "type", "description", "instrumentIdentifiers", "instrumentScope", "instrumentUid", "transactionDate", "settlementDate", "units", "transactionAmount", "transactionPrice", "totalConsideration", "exchangeRate", "transactionToPortfolioRate", "transactionCurrency", "properties", "counterpartyId", "source", "transactionStatus", "entryDateTime", "cancelDateTime", "realisedGainLoss", "holdingIds", "sourceType", "sourceInstrumentEventId", "transactionGroupId", "resolvedTransactionTypeDetails"]
+    __properties = ["transactionId", "type", "description", "instrumentIdentifiers", "instrumentScope", "instrumentUid", "transactionDate", "settlementDate", "units", "transactionAmount", "transactionPrice", "totalConsideration", "exchangeRate", "transactionToPortfolioRate", "transactionCurrency", "properties", "counterpartyId", "source", "transactionStatus", "entryDateTime", "cancelDateTime", "realisedGainLoss", "holdingIds", "sourceType", "sourceInstrumentEventId", "custodianAccount", "transactionGroupId", "resolvedTransactionTypeDetails"]
 
     @validator('transaction_status')
     def transaction_status_validate_enum(cls, value):
@@ -113,6 +115,9 @@ class OutputTransaction(BaseModel):
                 if _item:
                     _items.append(_item.to_dict())
             _dict['realisedGainLoss'] = _items
+        # override the default output from pydantic by calling `to_dict()` of custodian_account
+        if self.custodian_account:
+            _dict['custodianAccount'] = self.custodian_account.to_dict()
         # override the default output from pydantic by calling `to_dict()` of resolved_transaction_type_details
         if self.resolved_transaction_type_details:
             _dict['resolvedTransactionTypeDetails'] = self.resolved_transaction_type_details.to_dict()
@@ -228,6 +233,7 @@ class OutputTransaction(BaseModel):
             "holding_ids": obj.get("holdingIds"),
             "source_type": obj.get("sourceType"),
             "source_instrument_event_id": obj.get("sourceInstrumentEventId"),
+            "custodian_account": CustodianAccount.from_dict(obj.get("custodianAccount")) if obj.get("custodianAccount") is not None else None,
             "transaction_group_id": obj.get("transactionGroupId"),
             "resolved_transaction_type_details": TransactionTypeDetails.from_dict(obj.get("resolvedTransactionTypeDetails")) if obj.get("resolvedTransactionTypeDetails") is not None else None
         })

lusid/models/property_definition.py

@@ -50,8 +50,9 @@ class PropertyDefinition(BaseModel):
     properties: Optional[Dict[str, ModelProperty]] = Field(None, description="Set of unique property definition properties and associated values to store with the property definition. Each property must be from the 'PropertyDefinition' domain.")
     version: Optional[Version] = None
     staged_modifications: Optional[StagedModificationsInfo] = Field(None, alias="stagedModifications")
+    is_filterable: Optional[StrictBool] = Field(None, alias="isFilterable", description="Bool indicating whether the values of this property are fitlerable, this is true for all non-derived property defintions.  For a derived definition this must be set true to enable filtering.")
     links: Optional[conlist(Link)] = None
-    __properties = ["href", "key", "valueType", "displayName", "dataTypeId", "type", "unitSchema", "domain", "scope", "code", "valueRequired", "lifeTime", "constraintStyle", "propertyDefinitionType", "propertyDescription", "derivationFormula", "collectionType", "properties", "version", "stagedModifications", "links"]
+    __properties = ["href", "key", "valueType", "displayName", "dataTypeId", "type", "unitSchema", "domain", "scope", "code", "valueRequired", "lifeTime", "constraintStyle", "propertyDefinitionType", "propertyDescription", "derivationFormula", "collectionType", "properties", "version", "stagedModifications", "isFilterable", "links"]
 
     @validator('value_type')
     def value_type_validate_enum(cls, value):
@@ -254,6 +255,7 @@ class PropertyDefinition(BaseModel):
             else None,
             "version": Version.from_dict(obj.get("version")) if obj.get("version") is not None else None,
             "staged_modifications": StagedModificationsInfo.from_dict(obj.get("stagedModifications")) if obj.get("stagedModifications") is not None else None,
+            "is_filterable": obj.get("isFilterable"),
             "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
         })
         return _obj

lusid/models/property_definition_search_result.py

@@ -43,8 +43,9 @@ class PropertyDefinitionSearchResult(BaseModel):
     property_definition_type: Optional[StrictStr] = Field(None, alias="propertyDefinitionType", description="The definition type (DerivedDefinition or Definition). The available values are: ValueProperty, DerivedDefinition")
     property_description: Optional[StrictStr] = Field(None, alias="propertyDescription", description="A brief description of what a property of this property definition contains.")
     derivation_formula: Optional[StrictStr] = Field(None, alias="derivationFormula", description="The rule that defines how data is composed for a derived property.")
+    is_filterable: Optional[StrictBool] = Field(None, alias="isFilterable", description="Bool indicating whether the values of this property are fitlerable, this is true for all non-derived property defintions.  For a derived definition this must be set true to enable filtering.")
     links: Optional[conlist(Link)] = None
-    __properties = ["href", "key", "valueType", "displayName", "dataTypeId", "type", "unitSchema", "domain", "scope", "code", "valueRequired", "lifeTime", "constraintStyle", "propertyDefinitionType", "propertyDescription", "derivationFormula", "links"]
+    __properties = ["href", "key", "valueType", "displayName", "dataTypeId", "type", "unitSchema", "domain", "scope", "code", "valueRequired", "lifeTime", "constraintStyle", "propertyDefinitionType", "propertyDescription", "derivationFormula", "isFilterable", "links"]
 
     @validator('value_type')
     def value_type_validate_enum(cls, value):
@@ -215,6 +216,7 @@ class PropertyDefinitionSearchResult(BaseModel):
             "property_definition_type": obj.get("propertyDefinitionType"),
             "property_description": obj.get("propertyDescription"),
             "derivation_formula": obj.get("derivationFormula"),
+            "is_filterable": obj.get("isFilterable"),
             "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
         })
         return _obj

lusid/models/timeline.py

@@ -0,0 +1,135 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict, List, Optional
+from pydantic.v1 import BaseModel, Field, StrictStr, conlist
+from lusid.models.link import Link
+from lusid.models.model_property import ModelProperty
+from lusid.models.resource_id import ResourceId
+from lusid.models.version import Version
+
+class Timeline(BaseModel):
+    """
+    Timeline
+    """
+    id: Optional[ResourceId] = None
+    display_name: Optional[StrictStr] = Field(None, alias="displayName", description="The name of the Timeline.")
+    description: Optional[StrictStr] = Field(None, description="A description for the Timeline.")
+    properties: Optional[Dict[str, ModelProperty]] = Field(None, description="The Timelines properties. These will be from the 'Timeline' domain.")
+    version: Optional[Version] = None
+    href: Optional[StrictStr] = Field(None, description="The specific Uniform Resource Identifier (URI) for this resource at the requested asAt datetime.")
+    links: Optional[conlist(Link)] = None
+    __properties = ["id", "displayName", "description", "properties", "version", "href", "links"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Timeline:
+        """Create an instance of Timeline from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of id
+        if self.id:
+            _dict['id'] = self.id.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each value in properties (dict)
+        _field_dict = {}
+        if self.properties:
+            for _key in self.properties:
+                if self.properties[_key]:
+                    _field_dict[_key] = self.properties[_key].to_dict()
+            _dict['properties'] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of version
+        if self.version:
+            _dict['version'] = self.version.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in links (list)
+        _items = []
+        if self.links:
+            for _item in self.links:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['links'] = _items
+        # set to None if display_name (nullable) is None
+        # and __fields_set__ contains the field
+        if self.display_name is None and "display_name" in self.__fields_set__:
+            _dict['displayName'] = None
+
+        # set to None if description (nullable) is None
+        # and __fields_set__ contains the field
+        if self.description is None and "description" in self.__fields_set__:
+            _dict['description'] = None
+
+        # set to None if properties (nullable) is None
+        # and __fields_set__ contains the field
+        if self.properties is None and "properties" in self.__fields_set__:
+            _dict['properties'] = None
+
+        # set to None if href (nullable) is None
+        # and __fields_set__ contains the field
+        if self.href is None and "href" in self.__fields_set__:
+            _dict['href'] = None
+
+        # set to None if links (nullable) is None
+        # and __fields_set__ contains the field
+        if self.links is None and "links" in self.__fields_set__:
+            _dict['links'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> Timeline:
+        """Create an instance of Timeline from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return Timeline.parse_obj(obj)
+
+        _obj = Timeline.parse_obj({
+            "id": ResourceId.from_dict(obj.get("id")) if obj.get("id") is not None else None,
+            "display_name": obj.get("displayName"),
+            "description": obj.get("description"),
+            "properties": dict(
+                (_k, ModelProperty.from_dict(_v))
+                for _k, _v in obj.get("properties").items()
+            )
+            if obj.get("properties") is not None
+            else None,
+            "version": Version.from_dict(obj.get("version")) if obj.get("version") is not None else None,
+            "href": obj.get("href"),
+            "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
+        })
+        return _obj

lusid/models/update_derived_property_definition_request.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic.v1 import BaseModel, Field, constr
+from pydantic.v1 import BaseModel, Field, StrictBool, constr
 from lusid.models.resource_id import ResourceId
 
 class UpdateDerivedPropertyDefinitionRequest(BaseModel):
@@ -30,7 +30,8 @@ class UpdateDerivedPropertyDefinitionRequest(BaseModel):
     data_type_id: ResourceId = Field(..., alias="dataTypeId")
     property_description: Optional[constr(strict=True, max_length=512)] = Field(None, alias="propertyDescription", description="Describes the property")
     derivation_formula: constr(strict=True, min_length=1) = Field(..., alias="derivationFormula", description="The rule that defines how data is composed for a derived property.")
-    __properties = ["displayName", "dataTypeId", "propertyDescription", "derivationFormula"]
+    is_filterable: StrictBool = Field(..., alias="isFilterable", description="Bool indicating whether the values of this property are fitlerable, this is true for all non-derived property defintions.  For a derived definition this must be set true to enable filtering.")
+    __properties = ["displayName", "dataTypeId", "propertyDescription", "derivationFormula", "isFilterable"]
 
     class Config:
         """Pydantic configuration"""
@@ -79,6 +80,7 @@ class UpdateDerivedPropertyDefinitionRequest(BaseModel):
             "display_name": obj.get("displayName"),
             "data_type_id": ResourceId.from_dict(obj.get("dataTypeId")) if obj.get("dataTypeId") is not None else None,
             "property_description": obj.get("propertyDescription"),
-            "derivation_formula": obj.get("derivationFormula")
+            "derivation_formula": obj.get("derivationFormula"),
+            "is_filterable": obj.get("isFilterable")
         })
         return _obj

lusid/models/update_timeline_request.py

@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict, Optional
+from pydantic.v1 import BaseModel, Field, constr
+from lusid.models.model_property import ModelProperty
+
+class UpdateTimelineRequest(BaseModel):
+    """
+    UpdateTimelineRequest
+    """
+    display_name: constr(strict=True, max_length=512, min_length=0) = Field(..., alias="displayName", description="The name of the Timeline.")
+    description: Optional[constr(strict=True, max_length=512, min_length=0)] = Field(None, description="A description for the Timeline.")
+    properties: Optional[Dict[str, ModelProperty]] = Field(None, description="The Timelines properties. These will be from the 'Timeline' domain.")
+    __properties = ["displayName", "description", "properties"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> UpdateTimelineRequest:
+        """Create an instance of UpdateTimelineRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of each value in properties (dict)
+        _field_dict = {}
+        if self.properties:
+            for _key in self.properties:
+                if self.properties[_key]:
+                    _field_dict[_key] = self.properties[_key].to_dict()
+            _dict['properties'] = _field_dict
+        # set to None if description (nullable) is None
+        # and __fields_set__ contains the field
+        if self.description is None and "description" in self.__fields_set__:
+            _dict['description'] = None
+
+        # set to None if properties (nullable) is None
+        # and __fields_set__ contains the field
+        if self.properties is None and "properties" in self.__fields_set__:
+            _dict['properties'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> UpdateTimelineRequest:
+        """Create an instance of UpdateTimelineRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return UpdateTimelineRequest.parse_obj(obj)
+
+        _obj = UpdateTimelineRequest.parse_obj({
+            "display_name": obj.get("displayName"),
+            "description": obj.get("description"),
+            "properties": dict(
+                (_k, ModelProperty.from_dict(_v))
+                for _k, _v in obj.get("properties").items()
+            )
+            if obj.get("properties") is not None
+            else None
+        })
+        return _obj