lusid-sdk 2.1.81__py3-none-any.whl → 2.1.110__py3-none-any.whl

lusid/models/staged_modification_decision.py

@@ -0,0 +1,97 @@
+# 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, Optional
+from pydantic.v1 import BaseModel, Field, StrictStr
+
+class StagedModificationDecision(BaseModel):
+    """
+    StagedModificationDecision
+    """
+    as_at: Optional[datetime] = Field(None, alias="asAt", description="Time the decision request is made.")
+    user_id: Optional[StrictStr] = Field(None, alias="userId", description="ID of user that approved the request.")
+    request_id: Optional[StrictStr] = Field(None, alias="requestId", description="ID of user that made the request.")
+    decision: Optional[StrictStr] = Field(None, description="The decision on the requested staged modification, can be 'Approve' or 'Reject'.")
+    comment: Optional[StrictStr] = Field(None, description="Comment on decision.")
+    __properties = ["asAt", "userId", "requestId", "decision", "comment"]
+
+    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) -> StagedModificationDecision:
+        """Create an instance of StagedModificationDecision 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)
+        # set to None if user_id (nullable) is None
+        # and __fields_set__ contains the field
+        if self.user_id is None and "user_id" in self.__fields_set__:
+            _dict['userId'] = None
+
+        # set to None if request_id (nullable) is None
+        # and __fields_set__ contains the field
+        if self.request_id is None and "request_id" in self.__fields_set__:
+            _dict['requestId'] = None
+
+        # set to None if decision (nullable) is None
+        # and __fields_set__ contains the field
+        if self.decision is None and "decision" in self.__fields_set__:
+            _dict['decision'] = None
+
+        # set to None if comment (nullable) is None
+        # and __fields_set__ contains the field
+        if self.comment is None and "comment" in self.__fields_set__:
+            _dict['comment'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> StagedModificationDecision:
+        """Create an instance of StagedModificationDecision from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return StagedModificationDecision.parse_obj(obj)
+
+        _obj = StagedModificationDecision.parse_obj({
+            "as_at": obj.get("asAt"),
+            "user_id": obj.get("userId"),
+            "request_id": obj.get("requestId"),
+            "decision": obj.get("decision"),
+            "comment": obj.get("comment")
+        })
+        return _obj

lusid/models/staged_modification_decision_request.py

@@ -0,0 +1,71 @@
+# 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
+from pydantic.v1 import BaseModel, Field, constr
+
+class StagedModificationDecisionRequest(BaseModel):
+    """
+    StagedModificationDecisionRequest
+    """
+    decision: constr(strict=True, min_length=1) = Field(..., description="The decision on the requested staged modification, can be 'Approve' or 'Reject'.")
+    comment: constr(strict=True, max_length=256, min_length=1) = Field(..., description="Comment on decision.")
+    __properties = ["decision", "comment"]
+
+    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) -> StagedModificationDecisionRequest:
+        """Create an instance of StagedModificationDecisionRequest 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)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> StagedModificationDecisionRequest:
+        """Create an instance of StagedModificationDecisionRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return StagedModificationDecisionRequest.parse_obj(obj)
+
+        _obj = StagedModificationDecisionRequest.parse_obj({
+            "decision": obj.get("decision"),
+            "comment": obj.get("comment")
+        })
+        return _obj

lusid/models/staged_modification_effective_range.py

@@ -0,0 +1,71 @@
+# 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, Optional
+from pydantic.v1 import BaseModel, Field
+
+class StagedModificationEffectiveRange(BaseModel):
+    """
+    StagedModificationEffectiveRange
+    """
+    from_date: Optional[datetime] = Field(None, alias="fromDate", description="Time the decision request is made.")
+    until_date: Optional[datetime] = Field(None, alias="untilDate", description="ID of user that approved the request.")
+    __properties = ["fromDate", "untilDate"]
+
+    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) -> StagedModificationEffectiveRange:
+        """Create an instance of StagedModificationEffectiveRange 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)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> StagedModificationEffectiveRange:
+        """Create an instance of StagedModificationEffectiveRange from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return StagedModificationEffectiveRange.parse_obj(obj)
+
+        _obj = StagedModificationEffectiveRange.parse_obj({
+            "from_date": obj.get("fromDate"),
+            "until_date": obj.get("untilDate")
+        })
+        return _obj

lusid/models/staged_modification_staging_rule.py

@@ -0,0 +1,85 @@
+# 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, StrictBool, StrictInt, StrictStr
+
+class StagedModificationStagingRule(BaseModel):
+    """
+    StagedModificationStagingRule
+    """
+    staging_rule_set_id: Optional[StrictStr] = Field(None, alias="stagingRuleSetId", description="System generated unique id for the staging rule set.")
+    rule_id: Optional[StrictStr] = Field(None, alias="ruleId", description="The ID of the staging rule.")
+    required_approvals: Optional[StrictInt] = Field(None, alias="requiredApprovals", description="The number of approvals required. If left blank, one approval is needed.")
+    current_user_can_decide: Optional[StrictBool] = Field(None, alias="currentUserCanDecide", description="True or False indicating whether the current user can make a decision on the staged modification.")
+    __properties = ["stagingRuleSetId", "ruleId", "requiredApprovals", "currentUserCanDecide"]
+
+    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) -> StagedModificationStagingRule:
+        """Create an instance of StagedModificationStagingRule 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)
+        # set to None if staging_rule_set_id (nullable) is None
+        # and __fields_set__ contains the field
+        if self.staging_rule_set_id is None and "staging_rule_set_id" in self.__fields_set__:
+            _dict['stagingRuleSetId'] = None
+
+        # set to None if rule_id (nullable) is None
+        # and __fields_set__ contains the field
+        if self.rule_id is None and "rule_id" in self.__fields_set__:
+            _dict['ruleId'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> StagedModificationStagingRule:
+        """Create an instance of StagedModificationStagingRule from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return StagedModificationStagingRule.parse_obj(obj)
+
+        _obj = StagedModificationStagingRule.parse_obj({
+            "staging_rule_set_id": obj.get("stagingRuleSetId"),
+            "rule_id": obj.get("ruleId"),
+            "required_approvals": obj.get("requiredApprovals"),
+            "current_user_can_decide": obj.get("currentUserCanDecide")
+        })
+        return _obj

lusid/models/staged_modifications_entity_hrefs.py

@@ -0,0 +1,103 @@
+# 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
+
+class StagedModificationsEntityHrefs(BaseModel):
+    """
+    StagedModificationsEntityHrefs
+    """
+    when_staged: Optional[StrictStr] = Field(None, alias="whenStaged", description="The specific Uniform Resource Identifier (URI) for the staged modification change at the time when the change was requested.")
+    preview: Optional[StrictStr] = Field(None, description="The specific Uniform Resource Identifier (URI) for the preview of staged modification change once applied.")
+    latest: Optional[StrictStr] = Field(None, description="The specific Uniform Resource Identifier (URI) for the staged modification at latest time.")
+    links: Optional[conlist(Link)] = None
+    __properties = ["whenStaged", "preview", "latest", "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) -> StagedModificationsEntityHrefs:
+        """Create an instance of StagedModificationsEntityHrefs 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 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 when_staged (nullable) is None
+        # and __fields_set__ contains the field
+        if self.when_staged is None and "when_staged" in self.__fields_set__:
+            _dict['whenStaged'] = None
+
+        # set to None if preview (nullable) is None
+        # and __fields_set__ contains the field
+        if self.preview is None and "preview" in self.__fields_set__:
+            _dict['preview'] = None
+
+        # set to None if latest (nullable) is None
+        # and __fields_set__ contains the field
+        if self.latest is None and "latest" in self.__fields_set__:
+            _dict['latest'] = 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) -> StagedModificationsEntityHrefs:
+        """Create an instance of StagedModificationsEntityHrefs from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return StagedModificationsEntityHrefs.parse_obj(obj)
+
+        _obj = StagedModificationsEntityHrefs.parse_obj({
+            "when_staged": obj.get("whenStaged"),
+            "preview": obj.get("preview"),
+            "latest": obj.get("latest"),
+            "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
+        })
+        return _obj

lusid/models/staged_modifications_info.py

@@ -0,0 +1,78 @@
+# 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, StrictInt, StrictStr, conlist
+
+class StagedModificationsInfo(BaseModel):
+    """
+    The staged modifications metadata.  # noqa: E501
+    """
+    count_pending: StrictInt = Field(..., alias="countPending", description="The number of staged modifications for the entity with a status of Pending for the requested asAt.")
+    href_pending: StrictStr = Field(..., alias="hrefPending", description="Link to the list staged modifications endpoint, filtered by entityType, entityUniqueId and status (= Pending).")
+    ids_previewed: Optional[conlist(StrictStr)] = Field(None, alias="idsPreviewed", description="An array of the ids of any StagedModifications being previewed.")
+    __properties = ["countPending", "hrefPending", "idsPreviewed"]
+
+    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) -> StagedModificationsInfo:
+        """Create an instance of StagedModificationsInfo 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)
+        # set to None if ids_previewed (nullable) is None
+        # and __fields_set__ contains the field
+        if self.ids_previewed is None and "ids_previewed" in self.__fields_set__:
+            _dict['idsPreviewed'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> StagedModificationsInfo:
+        """Create an instance of StagedModificationsInfo from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return StagedModificationsInfo.parse_obj(obj)
+
+        _obj = StagedModificationsInfo.parse_obj({
+            "count_pending": obj.get("countPending"),
+            "href_pending": obj.get("hrefPending"),
+            "ids_previewed": obj.get("idsPreviewed")
+        })
+        return _obj

lusid/models/staged_modifications_requested_change_interval.py

@@ -0,0 +1,116 @@
+# 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.staged_modification_effective_range import StagedModificationEffectiveRange
+
+class StagedModificationsRequestedChangeInterval(BaseModel):
+    """
+    StagedModificationsRequestedChangeInterval
+    """
+    attribute_name: Optional[StrictStr] = Field(None, alias="attributeName", description="Name of the property the change applies to.")
+    effective_range: Optional[StagedModificationEffectiveRange] = Field(None, alias="effectiveRange")
+    previous_value: Optional[Any] = Field(None, alias="previousValue", description="The previous value of the attribute before the requested change is applied.")
+    new_value: Optional[Any] = Field(None, alias="newValue", description="The value of the attribute once the requested change is applied.")
+    as_at_basis: Optional[StrictStr] = Field(None, alias="asAtBasis", description="Whether the change represents the modification when the request was made or the modification as it would be at the latest time.")
+    links: Optional[conlist(Link)] = None
+    __properties = ["attributeName", "effectiveRange", "previousValue", "newValue", "asAtBasis", "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) -> StagedModificationsRequestedChangeInterval:
+        """Create an instance of StagedModificationsRequestedChangeInterval 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 effective_range
+        if self.effective_range:
+            _dict['effectiveRange'] = self.effective_range.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 attribute_name (nullable) is None
+        # and __fields_set__ contains the field
+        if self.attribute_name is None and "attribute_name" in self.__fields_set__:
+            _dict['attributeName'] = None
+
+        # set to None if previous_value (nullable) is None
+        # and __fields_set__ contains the field
+        if self.previous_value is None and "previous_value" in self.__fields_set__:
+            _dict['previousValue'] = None
+
+        # set to None if new_value (nullable) is None
+        # and __fields_set__ contains the field
+        if self.new_value is None and "new_value" in self.__fields_set__:
+            _dict['newValue'] = None
+
+        # set to None if as_at_basis (nullable) is None
+        # and __fields_set__ contains the field
+        if self.as_at_basis is None and "as_at_basis" in self.__fields_set__:
+            _dict['asAtBasis'] = 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) -> StagedModificationsRequestedChangeInterval:
+        """Create an instance of StagedModificationsRequestedChangeInterval from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return StagedModificationsRequestedChangeInterval.parse_obj(obj)
+
+        _obj = StagedModificationsRequestedChangeInterval.parse_obj({
+            "attribute_name": obj.get("attributeName"),
+            "effective_range": StagedModificationEffectiveRange.from_dict(obj.get("effectiveRange")) if obj.get("effectiveRange") is not None else None,
+            "previous_value": obj.get("previousValue"),
+            "new_value": obj.get("newValue"),
+            "as_at_basis": obj.get("asAtBasis"),
+            "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
+        })
+        return _obj

lusid/models/staging_rule_set.py

@@ -20,6 +20,7 @@ import json
 
 from typing import Any, Dict, List, Optional
 from pydantic.v1 import BaseModel, Field, StrictStr, conlist, constr
+from lusid.models.link import Link
 from lusid.models.staging_rule import StagingRule
 from lusid.models.version import Version
 
@@ -34,7 +35,8 @@ class StagingRuleSet(BaseModel):
     rules: conlist(StagingRule) = Field(..., description="The list of staging rules that apply to a specific entity type.")
     href: Optional[StrictStr] = Field(None, description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.")
     version: Optional[Version] = None
-    __properties = ["entityType", "stagingRuleSetId", "displayName", "description", "rules", "href", "version"]
+    links: Optional[conlist(Link)] = None
+    __properties = ["entityType", "stagingRuleSetId", "displayName", "description", "rules", "href", "version", "links"]
 
     class Config:
         """Pydantic configuration"""
@@ -70,6 +72,13 @@ class StagingRuleSet(BaseModel):
         # 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 description (nullable) is None
         # and __fields_set__ contains the field
         if self.description is None and "description" in self.__fields_set__:
@@ -80,6 +89,11 @@ class StagingRuleSet(BaseModel):
         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
@@ -98,6 +112,7 @@ class StagingRuleSet(BaseModel):
             "description": obj.get("description"),
             "rules": [StagingRule.from_dict(_item) for _item in obj.get("rules")] if obj.get("rules") is not None else None,
             "href": obj.get("href"),
-            "version": Version.from_dict(obj.get("version")) if obj.get("version") is not None else None
+            "version": Version.from_dict(obj.get("version")) if obj.get("version") is not None else None,
+            "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
         })
         return _obj