lusid-sdk 2.0.50b0__py3-none-any.whl → 2.1.683__py3-none-any.whl

lusid/models/create_relation_request.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict
-from pydantic import BaseModel, Field, StrictStr
+from pydantic.v1 import BaseModel, Field, StrictStr
 
 class CreateRelationRequest(BaseModel):
     """
@@ -34,6 +34,14 @@ class CreateRelationRequest(BaseModel):
         allow_population_by_field_name = True
         validate_assignment = True
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))

lusid/models/create_relationship_definition_request.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic import BaseModel, Field, StrictStr, constr, validator
+from pydantic.v1 import BaseModel, Field, StrictStr, constr, validator
 
 class CreateRelationshipDefinitionRequest(BaseModel):
     """
@@ -27,8 +27,8 @@ class CreateRelationshipDefinitionRequest(BaseModel):
     """
     scope: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The scope that the relationship definition exists in.")
     code: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The code of the relationship definition. Together with the scope this uniquely defines the relationship definition.")
-    source_entity_type: constr(strict=True, max_length=64, min_length=1) = Field(..., alias="sourceEntityType", description="The entity type of the source entity object. Allowed values are 'Portfolio', 'PortfolioGroup', 'Person', 'LegalEntity' or a custom entity type prefixed with '~'.")
-    target_entity_type: constr(strict=True, max_length=64, min_length=1) = Field(..., alias="targetEntityType", description="The entity type of the target entity object. Allowed values are 'Portfolio', 'PortfolioGroup', 'Person', 'LegalEntity' or a custom entity type prefixed with '~'.")
+    source_entity_type: constr(strict=True, max_length=64, min_length=1) = Field(..., alias="sourceEntityType", description="The entity type of the source entity object. Allowed values are 'Portfolio', 'PortfolioGroup', 'Person', 'LegalEntity', 'Instrument' or a custom entity type prefixed with '~'.")
+    target_entity_type: constr(strict=True, max_length=64, min_length=1) = Field(..., alias="targetEntityType", description="The entity type of the target entity object. Allowed values are 'Portfolio', 'PortfolioGroup', 'Person', 'LegalEntity', 'Instrument' or a custom entity type prefixed with '~'.")
     display_name: constr(strict=True, max_length=512, min_length=1) = Field(..., alias="displayName", description="The display name of the relationship definition.")
     outward_description: constr(strict=True, max_length=512, min_length=1) = Field(..., alias="outwardDescription", description="The description to relate source entity object and target entity object.")
     inward_description: constr(strict=True, max_length=512, min_length=1) = Field(..., alias="inwardDescription", description="The description to relate target entity object and source entity object.")
@@ -76,6 +76,14 @@ class CreateRelationshipDefinitionRequest(BaseModel):
         allow_population_by_field_name = True
         validate_assignment = True
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))

lusid/models/create_relationship_request.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic import BaseModel, Field, StrictStr, constr, validator
+from pydantic.v1 import BaseModel, Field, StrictStr, constr, validator
 
 class CreateRelationshipRequest(BaseModel):
     """
@@ -56,6 +56,14 @@ class CreateRelationshipRequest(BaseModel):
         allow_population_by_field_name = True
         validate_assignment = True
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))

lusid/models/create_sequence_request.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, Optional
-from pydantic import BaseModel, Field, StrictBool, StrictInt, constr, validator
+from pydantic.v1 import BaseModel, Field, StrictBool, StrictInt, constr, validator
 
 class CreateSequenceRequest(BaseModel):
     """
@@ -56,6 +56,14 @@ class CreateSequenceRequest(BaseModel):
         allow_population_by_field_name = True
         validate_assignment = True
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))

lusid/models/create_simple_position_portfolio_request.py

@@ -0,0 +1,196 @@
+# 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 datetime import datetime
+from typing import Any, Dict, List, Optional
+from pydantic.v1 import BaseModel, Field, StrictStr, conlist, constr, validator
+from lusid.models.instrument_event_configuration import InstrumentEventConfiguration
+from lusid.models.model_property import ModelProperty
+from lusid.models.resource_id import ResourceId
+
+class CreateSimplePositionPortfolioRequest(BaseModel):
+    """
+    CreateSimplePositionPortfolioRequest
+    """
+    display_name: constr(strict=True, max_length=1024, min_length=0) = Field(..., alias="displayName", description="The name of the simple position portfolio.")
+    description: Optional[constr(strict=True, max_length=1024, min_length=0)] = Field(None, description="A description for the simple position portfolio.")
+    code: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The code of the simple position portfolio. Together with the scope this uniquely identifies the simple position portfolio.")
+    created: Optional[datetime] = Field(None, description="The effective datetime at which to create the simple position portfolio. No holdings can be set on the simple position portfolio before this date. Defaults to the current LUSID system datetime if not specified.")
+    base_currency: StrictStr = Field(..., alias="baseCurrency", description="The base currency of the simple position portfolio in ISO 4217 currency code format.")
+    corporate_action_source_id: Optional[ResourceId] = Field(None, alias="corporateActionSourceId")
+    accounting_method: Optional[StrictStr] = Field(None, alias="accountingMethod", description=". The available values are: Default, AverageCost, FirstInFirstOut, LastInFirstOut, HighestCostFirst, LowestCostFirst, ProRateByUnits, ProRateByCost, ProRateByCostPortfolioCurrency, IntraDayThenFirstInFirstOut, LongTermHighestCostFirst, LongTermHighestCostFirstPortfolioCurrency, HighestCostFirstPortfolioCurrency, LowestCostFirstPortfolioCurrency, MaximumLossMinimumGain, MaximumLossMinimumGainPortfolioCurrency")
+    sub_holding_keys: Optional[conlist(StrictStr, max_items=100)] = Field(None, alias="subHoldingKeys", description="A set of unique transaction properties to group the simple position portfolio's holdings by, perhaps for strategy tagging. Each property must be from the 'Transaction' domain and identified by a key in the format {domain}/{scope}/{code}, for example 'Transaction/strategies/quantsignal'. See https://support.lusid.com/knowledgebase/article/KA-01879/en-us for more information.")
+    properties: Optional[Dict[str, ModelProperty]] = Field(None, description="A set of unique portfolio properties to add custom data to the simple position portfolio. Each property must be from the 'Portfolio' domain and identified by a key in the format {domain}/{scope}/{code}, for example 'Portfolio/Manager/Id'. Note these properties must be pre-defined.")
+    instrument_scopes: Optional[conlist(StrictStr, max_items=1)] = Field(None, alias="instrumentScopes", description="The resolution strategy used to resolve instruments of holdings upserted to this portfolio.")
+    amortisation_method: Optional[StrictStr] = Field(None, alias="amortisationMethod", description="The amortisation method used by the portfolio for the calculation. The available values are: NoAmortisation, StraightLine, EffectiveYield, StraightLineSettlementDate, EffectiveYieldSettlementDate")
+    transaction_type_scope: Optional[constr(strict=True, max_length=64, min_length=1)] = Field(None, alias="transactionTypeScope", description="The scope of the transaction types.")
+    cash_gain_loss_calculation_date: Optional[StrictStr] = Field(None, alias="cashGainLossCalculationDate", description="The option when the Cash Gain Loss to be calulated, TransactionDate/SettlementDate. Defaults to SettlementDate.")
+    instrument_event_configuration: Optional[InstrumentEventConfiguration] = Field(None, alias="instrumentEventConfiguration")
+    amortisation_rule_set_id: Optional[ResourceId] = Field(None, alias="amortisationRuleSetId")
+    __properties = ["displayName", "description", "code", "created", "baseCurrency", "corporateActionSourceId", "accountingMethod", "subHoldingKeys", "properties", "instrumentScopes", "amortisationMethod", "transactionTypeScope", "cashGainLossCalculationDate", "instrumentEventConfiguration", "amortisationRuleSetId"]
+
+    @validator('code')
+    def code_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[a-zA-Z0-9\-_]+$", value):
+            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9\-_]+$/")
+        return value
+
+    @validator('accounting_method')
+    def accounting_method_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in ('Default', 'AverageCost', 'FirstInFirstOut', 'LastInFirstOut', 'HighestCostFirst', 'LowestCostFirst', 'ProRateByUnits', 'ProRateByCost', 'ProRateByCostPortfolioCurrency', 'IntraDayThenFirstInFirstOut', 'LongTermHighestCostFirst', 'LongTermHighestCostFirstPortfolioCurrency', 'HighestCostFirstPortfolioCurrency', 'LowestCostFirstPortfolioCurrency', 'MaximumLossMinimumGain', 'MaximumLossMinimumGainPortfolioCurrency'):
+            raise ValueError("must be one of enum values ('Default', 'AverageCost', 'FirstInFirstOut', 'LastInFirstOut', 'HighestCostFirst', 'LowestCostFirst', 'ProRateByUnits', 'ProRateByCost', 'ProRateByCostPortfolioCurrency', 'IntraDayThenFirstInFirstOut', 'LongTermHighestCostFirst', 'LongTermHighestCostFirstPortfolioCurrency', 'HighestCostFirstPortfolioCurrency', 'LowestCostFirstPortfolioCurrency', 'MaximumLossMinimumGain', 'MaximumLossMinimumGainPortfolioCurrency')")
+        return value
+
+    @validator('transaction_type_scope')
+    def transaction_type_scope_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[a-zA-Z0-9\-_]+$", value):
+            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9\-_]+$/")
+        return value
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
+    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) -> CreateSimplePositionPortfolioRequest:
+        """Create an instance of CreateSimplePositionPortfolioRequest 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 corporate_action_source_id
+        if self.corporate_action_source_id:
+            _dict['corporateActionSourceId'] = self.corporate_action_source_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 instrument_event_configuration
+        if self.instrument_event_configuration:
+            _dict['instrumentEventConfiguration'] = self.instrument_event_configuration.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of amortisation_rule_set_id
+        if self.amortisation_rule_set_id:
+            _dict['amortisationRuleSetId'] = self.amortisation_rule_set_id.to_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 created (nullable) is None
+        # and __fields_set__ contains the field
+        if self.created is None and "created" in self.__fields_set__:
+            _dict['created'] = None
+
+        # set to None if sub_holding_keys (nullable) is None
+        # and __fields_set__ contains the field
+        if self.sub_holding_keys is None and "sub_holding_keys" in self.__fields_set__:
+            _dict['subHoldingKeys'] = 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 instrument_scopes (nullable) is None
+        # and __fields_set__ contains the field
+        if self.instrument_scopes is None and "instrument_scopes" in self.__fields_set__:
+            _dict['instrumentScopes'] = None
+
+        # set to None if amortisation_method (nullable) is None
+        # and __fields_set__ contains the field
+        if self.amortisation_method is None and "amortisation_method" in self.__fields_set__:
+            _dict['amortisationMethod'] = None
+
+        # set to None if transaction_type_scope (nullable) is None
+        # and __fields_set__ contains the field
+        if self.transaction_type_scope is None and "transaction_type_scope" in self.__fields_set__:
+            _dict['transactionTypeScope'] = None
+
+        # set to None if cash_gain_loss_calculation_date (nullable) is None
+        # and __fields_set__ contains the field
+        if self.cash_gain_loss_calculation_date is None and "cash_gain_loss_calculation_date" in self.__fields_set__:
+            _dict['cashGainLossCalculationDate'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> CreateSimplePositionPortfolioRequest:
+        """Create an instance of CreateSimplePositionPortfolioRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return CreateSimplePositionPortfolioRequest.parse_obj(obj)
+
+        _obj = CreateSimplePositionPortfolioRequest.parse_obj({
+            "display_name": obj.get("displayName"),
+            "description": obj.get("description"),
+            "code": obj.get("code"),
+            "created": obj.get("created"),
+            "base_currency": obj.get("baseCurrency"),
+            "corporate_action_source_id": ResourceId.from_dict(obj.get("corporateActionSourceId")) if obj.get("corporateActionSourceId") is not None else None,
+            "accounting_method": obj.get("accountingMethod"),
+            "sub_holding_keys": obj.get("subHoldingKeys"),
+            "properties": dict(
+                (_k, ModelProperty.from_dict(_v))
+                for _k, _v in obj.get("properties").items()
+            )
+            if obj.get("properties") is not None
+            else None,
+            "instrument_scopes": obj.get("instrumentScopes"),
+            "amortisation_method": obj.get("amortisationMethod"),
+            "transaction_type_scope": obj.get("transactionTypeScope"),
+            "cash_gain_loss_calculation_date": obj.get("cashGainLossCalculationDate"),
+            "instrument_event_configuration": InstrumentEventConfiguration.from_dict(obj.get("instrumentEventConfiguration")) if obj.get("instrumentEventConfiguration") is not None else None,
+            "amortisation_rule_set_id": ResourceId.from_dict(obj.get("amortisationRuleSetId")) if obj.get("amortisationRuleSetId") is not None else None
+        })
+        return _obj

lusid/models/create_staging_rule_set_request.py

@@ -0,0 +1,94 @@
+# 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, conlist, constr
+from lusid.models.staging_rule import StagingRule
+
+class CreateStagingRuleSetRequest(BaseModel):
+    """
+    CreateStagingRuleSetRequest
+    """
+    display_name: constr(strict=True, max_length=256, min_length=1) = Field(..., alias="displayName", description="The name of the staging rule set.")
+    description: Optional[constr(strict=True, max_length=1024, min_length=0)] = Field(None, description="A description for the staging rule set.")
+    rules: conlist(StagingRule) = Field(..., description="The list of staging rules that apply to a specific entity type.")
+    __properties = ["displayName", "description", "rules"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
+    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) -> CreateStagingRuleSetRequest:
+        """Create an instance of CreateStagingRuleSetRequest 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 item in rules (list)
+        _items = []
+        if self.rules:
+            for _item in self.rules:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['rules'] = _items
+        # 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
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> CreateStagingRuleSetRequest:
+        """Create an instance of CreateStagingRuleSetRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return CreateStagingRuleSetRequest.parse_obj(obj)
+
+        _obj = CreateStagingRuleSetRequest.parse_obj({
+            "display_name": obj.get("displayName"),
+            "description": obj.get("description"),
+            "rules": [StagingRule.from_dict(_item) for _item in obj.get("rules")] if obj.get("rules") is not None else None
+        })
+        return _obj

lusid/models/create_tax_rule_set_request.py

@@ -19,7 +19,7 @@ import json
 
 
 from typing import Any, Dict, List
-from pydantic import BaseModel, Field, StrictStr, conlist, constr, validator
+from pydantic.v1 import BaseModel, Field, StrictStr, conlist, constr, validator
 from lusid.models.resource_id import ResourceId
 from lusid.models.tax_rule import TaxRule
 
@@ -53,6 +53,14 @@ class CreateTaxRuleSetRequest(BaseModel):
         allow_population_by_field_name = True
         validate_assignment = True
 
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.dict(by_alias=True))

lusid/models/create_timeline_request.py

@@ -0,0 +1,110 @@
+# 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 __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
+    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/create_trade_tickets_response.py

@@ -0,0 +1,95 @@
+# 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
+from pydantic.v1 import BaseModel, Field, conlist
+from lusid.models.error_detail import ErrorDetail
+from lusid.models.lusid_trade_ticket import LusidTradeTicket
+
+class CreateTradeTicketsResponse(BaseModel):
+    """
+    Batch trade ticket creation response  # noqa: E501
+    """
+    values: conlist(LusidTradeTicket) = Field(...)
+    failures: conlist(ErrorDetail) = Field(...)
+    __properties = ["values", "failures"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
+    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) -> CreateTradeTicketsResponse:
+        """Create an instance of CreateTradeTicketsResponse 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 item in values (list)
+        _items = []
+        if self.values:
+            for _item in self.values:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['values'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in failures (list)
+        _items = []
+        if self.failures:
+            for _item in self.failures:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['failures'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> CreateTradeTicketsResponse:
+        """Create an instance of CreateTradeTicketsResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return CreateTradeTicketsResponse.parse_obj(obj)
+
+        _obj = CreateTradeTicketsResponse.parse_obj({
+            "values": [LusidTradeTicket.from_dict(_item) for _item in obj.get("values")] if obj.get("values") is not None else None,
+            "failures": [ErrorDetail.from_dict(_item) for _item in obj.get("failures")] if obj.get("failures") is not None else None
+        })
+        return _obj