lusid-sdk 2.1.462__py3-none-any.whl → 2.1.542__py3-none-any.whl

lusid/models/group_reconciliation_result_statuses.py

@@ -0,0 +1,89 @@
+# 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, StrictInt
+from lusid.models.link import Link
+
+class GroupReconciliationResultStatuses(BaseModel):
+    """
+    GroupReconciliationResultStatuses
+    """
+    count_new: StrictInt = Field(..., alias="countNew", description="The number of comparison results of resultStatus \"New\" with this instanceId and reconciliationType")
+    link_new: Link = Field(..., alias="linkNew")
+    count_confirmed: StrictInt = Field(..., alias="countConfirmed", description="The number of comparison results of resultStatus \"Confirmed\" with this instanceId and reconciliationType")
+    link_confirmed: Link = Field(..., alias="linkConfirmed")
+    count_changed: StrictInt = Field(..., alias="countChanged", description="The number of comparison results of resultStatus \"Changed\" with this instanceId and reconciliationType")
+    link_changed: Link = Field(..., alias="linkChanged")
+    __properties = ["countNew", "linkNew", "countConfirmed", "linkConfirmed", "countChanged", "linkChanged"]
+
+    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) -> GroupReconciliationResultStatuses:
+        """Create an instance of GroupReconciliationResultStatuses 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 link_new
+        if self.link_new:
+            _dict['linkNew'] = self.link_new.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of link_confirmed
+        if self.link_confirmed:
+            _dict['linkConfirmed'] = self.link_confirmed.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of link_changed
+        if self.link_changed:
+            _dict['linkChanged'] = self.link_changed.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationResultStatuses:
+        """Create an instance of GroupReconciliationResultStatuses from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationResultStatuses.parse_obj(obj)
+
+        _obj = GroupReconciliationResultStatuses.parse_obj({
+            "count_new": obj.get("countNew"),
+            "link_new": Link.from_dict(obj.get("linkNew")) if obj.get("linkNew") is not None else None,
+            "count_confirmed": obj.get("countConfirmed"),
+            "link_confirmed": Link.from_dict(obj.get("linkConfirmed")) if obj.get("linkConfirmed") is not None else None,
+            "count_changed": obj.get("countChanged"),
+            "link_changed": Link.from_dict(obj.get("linkChanged")) if obj.get("linkChanged") is not None else None
+        })
+        return _obj

lusid/models/group_reconciliation_result_types.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
+from pydantic.v1 import BaseModel, Field, StrictInt
+from lusid.models.link import Link
+
+class GroupReconciliationResultTypes(BaseModel):
+    """
+    GroupReconciliationResultTypes
+    """
+    count_match: StrictInt = Field(..., alias="countMatch", description="The number of comparison results of resultType \"Match\" with this instanceId and reconciliationType")
+    link_matches: Link = Field(..., alias="linkMatches")
+    count_partial_match: StrictInt = Field(..., alias="countPartialMatch", description="The number of comparison results of resultType \"PartialMatch\" with this instanceId and reconciliationType")
+    link_partial_matches: Link = Field(..., alias="linkPartialMatches")
+    count_break: StrictInt = Field(..., alias="countBreak", description="The number of comparison results of resultType \"Break\" with this instanceId and reconciliationType")
+    link_breaks: Link = Field(..., alias="linkBreaks")
+    count_not_found: StrictInt = Field(..., alias="countNotFound", description="The number of comparison results of resultType \"NotFound\" with this instanceId and reconciliationType")
+    link_not_found: Link = Field(..., alias="linkNotFound")
+    __properties = ["countMatch", "linkMatches", "countPartialMatch", "linkPartialMatches", "countBreak", "linkBreaks", "countNotFound", "linkNotFound"]
+
+    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) -> GroupReconciliationResultTypes:
+        """Create an instance of GroupReconciliationResultTypes 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 link_matches
+        if self.link_matches:
+            _dict['linkMatches'] = self.link_matches.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of link_partial_matches
+        if self.link_partial_matches:
+            _dict['linkPartialMatches'] = self.link_partial_matches.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of link_breaks
+        if self.link_breaks:
+            _dict['linkBreaks'] = self.link_breaks.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of link_not_found
+        if self.link_not_found:
+            _dict['linkNotFound'] = self.link_not_found.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationResultTypes:
+        """Create an instance of GroupReconciliationResultTypes from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationResultTypes.parse_obj(obj)
+
+        _obj = GroupReconciliationResultTypes.parse_obj({
+            "count_match": obj.get("countMatch"),
+            "link_matches": Link.from_dict(obj.get("linkMatches")) if obj.get("linkMatches") is not None else None,
+            "count_partial_match": obj.get("countPartialMatch"),
+            "link_partial_matches": Link.from_dict(obj.get("linkPartialMatches")) if obj.get("linkPartialMatches") is not None else None,
+            "count_break": obj.get("countBreak"),
+            "link_breaks": Link.from_dict(obj.get("linkBreaks")) if obj.get("linkBreaks") is not None else None,
+            "count_not_found": obj.get("countNotFound"),
+            "link_not_found": Link.from_dict(obj.get("linkNotFound")) if obj.get("linkNotFound") is not None else None
+        })
+        return _obj

lusid/models/group_reconciliation_review_statuses.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
+from pydantic.v1 import BaseModel, Field, StrictInt
+from lusid.models.link import Link
+
+class GroupReconciliationReviewStatuses(BaseModel):
+    """
+    GroupReconciliationReviewStatuses
+    """
+    count_pending: StrictInt = Field(..., alias="countPending", description="The number of comparison results of reviewStatus \"Pending\" with this instanceId and reconciliationType")
+    link_pending: Link = Field(..., alias="linkPending")
+    count_reviewed: StrictInt = Field(..., alias="countReviewed", description="The number of comparison results of reviewStatus \"Reviewed\" with this instanceId and reconciliationType")
+    link_reviewed: Link = Field(..., alias="linkReviewed")
+    count_matched: StrictInt = Field(..., alias="countMatched", description="The number of comparison results of reviewStatus \"Matched\" with this instanceId and reconciliationType")
+    link_matched: Link = Field(..., alias="linkMatched")
+    count_invalid: StrictInt = Field(..., alias="countInvalid", description="The number of comparison results of reviewStatus \"Invalid\" with this instanceId and reconciliationType")
+    link_invalid: Link = Field(..., alias="linkInvalid")
+    __properties = ["countPending", "linkPending", "countReviewed", "linkReviewed", "countMatched", "linkMatched", "countInvalid", "linkInvalid"]
+
+    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) -> GroupReconciliationReviewStatuses:
+        """Create an instance of GroupReconciliationReviewStatuses 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 link_pending
+        if self.link_pending:
+            _dict['linkPending'] = self.link_pending.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of link_reviewed
+        if self.link_reviewed:
+            _dict['linkReviewed'] = self.link_reviewed.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of link_matched
+        if self.link_matched:
+            _dict['linkMatched'] = self.link_matched.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of link_invalid
+        if self.link_invalid:
+            _dict['linkInvalid'] = self.link_invalid.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationReviewStatuses:
+        """Create an instance of GroupReconciliationReviewStatuses from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationReviewStatuses.parse_obj(obj)
+
+        _obj = GroupReconciliationReviewStatuses.parse_obj({
+            "count_pending": obj.get("countPending"),
+            "link_pending": Link.from_dict(obj.get("linkPending")) if obj.get("linkPending") is not None else None,
+            "count_reviewed": obj.get("countReviewed"),
+            "link_reviewed": Link.from_dict(obj.get("linkReviewed")) if obj.get("linkReviewed") is not None else None,
+            "count_matched": obj.get("countMatched"),
+            "link_matched": Link.from_dict(obj.get("linkMatched")) if obj.get("linkMatched") is not None else None,
+            "count_invalid": obj.get("countInvalid"),
+            "link_invalid": Link.from_dict(obj.get("linkInvalid")) if obj.get("linkInvalid") is not None else None
+        })
+        return _obj

lusid/models/group_reconciliation_run_details.py

@@ -0,0 +1,76 @@
+# 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, StrictStr, constr
+
+class GroupReconciliationRunDetails(BaseModel):
+    """
+    GroupReconciliationRunDetails
+    """
+    completion_status: constr(strict=True, min_length=1) = Field(..., alias="completionStatus", description="Provides the reconciliation completion status \"Completed\" | \"FailedToComplete\"")
+    error_detail: Optional[StrictStr] = Field(None, alias="errorDetail", description="Error information if the reconciliation failed to complete")
+    __properties = ["completionStatus", "errorDetail"]
+
+    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) -> GroupReconciliationRunDetails:
+        """Create an instance of GroupReconciliationRunDetails 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 error_detail (nullable) is None
+        # and __fields_set__ contains the field
+        if self.error_detail is None and "error_detail" in self.__fields_set__:
+            _dict['errorDetail'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationRunDetails:
+        """Create an instance of GroupReconciliationRunDetails from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationRunDetails.parse_obj(obj)
+
+        _obj = GroupReconciliationRunDetails.parse_obj({
+            "completion_status": obj.get("completionStatus"),
+            "error_detail": obj.get("errorDetail")
+        })
+        return _obj

lusid/models/group_reconciliation_run_request.py

@@ -0,0 +1,75 @@
+# 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.group_reconciliation_dates import GroupReconciliationDates
+
+class GroupReconciliationRunRequest(BaseModel):
+    """
+    GroupReconciliationRunRequest
+    """
+    instance_id: constr(strict=True, max_length=64, min_length=1) = Field(..., alias="instanceId", description="Reconciliation run Id. Consists of run type (manual or workflow) and identifier.")
+    dates_to_reconcile: Optional[GroupReconciliationDates] = Field(None, alias="datesToReconcile")
+    __properties = ["instanceId", "datesToReconcile"]
+
+    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) -> GroupReconciliationRunRequest:
+        """Create an instance of GroupReconciliationRunRequest 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 dates_to_reconcile
+        if self.dates_to_reconcile:
+            _dict['datesToReconcile'] = self.dates_to_reconcile.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationRunRequest:
+        """Create an instance of GroupReconciliationRunRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationRunRequest.parse_obj(obj)
+
+        _obj = GroupReconciliationRunRequest.parse_obj({
+            "instance_id": obj.get("instanceId"),
+            "dates_to_reconcile": GroupReconciliationDates.from_dict(obj.get("datesToReconcile")) if obj.get("datesToReconcile") is not None else None
+        })
+        return _obj

lusid/models/group_reconciliation_run_response.py

@@ -0,0 +1,77 @@
+# 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.group_reconciliation_summary import GroupReconciliationSummary
+
+class GroupReconciliationRunResponse(BaseModel):
+    """
+    GroupReconciliationRunResponse
+    """
+    reconciliation_summaries: conlist(GroupReconciliationSummary) = Field(..., alias="reconciliationSummaries", description="One summary record for each of the \"Holding\" | \"Transaction\" | \"Valuation\" reconciliations performed")
+    __properties = ["reconciliationSummaries"]
+
+    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) -> GroupReconciliationRunResponse:
+        """Create an instance of GroupReconciliationRunResponse 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 reconciliation_summaries (list)
+        _items = []
+        if self.reconciliation_summaries:
+            for _item in self.reconciliation_summaries:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['reconciliationSummaries'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationRunResponse:
+        """Create an instance of GroupReconciliationRunResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationRunResponse.parse_obj(obj)
+
+        _obj = GroupReconciliationRunResponse.parse_obj({
+            "reconciliation_summaries": [GroupReconciliationSummary.from_dict(_item) for _item in obj.get("reconciliationSummaries")] if obj.get("reconciliationSummaries") is not None else None
+        })
+        return _obj

lusid/models/group_reconciliation_summary.py

@@ -0,0 +1,121 @@
+# 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, StrictInt, constr
+from lusid.models.group_reconciliation_dates import GroupReconciliationDates
+from lusid.models.group_reconciliation_instance_id import GroupReconciliationInstanceId
+from lusid.models.group_reconciliation_result_statuses import GroupReconciliationResultStatuses
+from lusid.models.group_reconciliation_result_types import GroupReconciliationResultTypes
+from lusid.models.group_reconciliation_review_statuses import GroupReconciliationReviewStatuses
+from lusid.models.group_reconciliation_run_details import GroupReconciliationRunDetails
+from lusid.models.link import Link
+from lusid.models.resource_id import ResourceId
+
+class GroupReconciliationSummary(BaseModel):
+    """
+    GroupReconciliationSummary
+    """
+    run_details: Optional[GroupReconciliationRunDetails] = Field(None, alias="runDetails")
+    group_reconciliation_definition_id: Optional[ResourceId] = Field(None, alias="groupReconciliationDefinitionId")
+    reconciliation_type: constr(strict=True, min_length=1) = Field(..., alias="reconciliationType", description="The type of reconciliation to perform. \"Holding\" | \"Transaction\" | \"Valuation\"")
+    instance_id: GroupReconciliationInstanceId = Field(..., alias="instanceId")
+    dates_reconciled: GroupReconciliationDates = Field(..., alias="datesReconciled")
+    reconciliation_run_as_at: constr(strict=True, min_length=1) = Field(..., alias="reconciliationRunAsAt", description="The date and time the reconciliation was run")
+    count_comparison_results: StrictInt = Field(..., alias="countComparisonResults", description="The total number of comparison results with this InstanceId and ReconciliationType")
+    link_comparison_results: Optional[Link] = Field(None, alias="linkComparisonResults")
+    result_types: Optional[GroupReconciliationResultTypes] = Field(None, alias="resultTypes")
+    result_statuses: Optional[GroupReconciliationResultStatuses] = Field(None, alias="resultStatuses")
+    review_statuses: Optional[GroupReconciliationReviewStatuses] = Field(None, alias="reviewStatuses")
+    __properties = ["runDetails", "groupReconciliationDefinitionId", "reconciliationType", "instanceId", "datesReconciled", "reconciliationRunAsAt", "countComparisonResults", "linkComparisonResults", "resultTypes", "resultStatuses", "reviewStatuses"]
+
+    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) -> GroupReconciliationSummary:
+        """Create an instance of GroupReconciliationSummary 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 run_details
+        if self.run_details:
+            _dict['runDetails'] = self.run_details.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of group_reconciliation_definition_id
+        if self.group_reconciliation_definition_id:
+            _dict['groupReconciliationDefinitionId'] = self.group_reconciliation_definition_id.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of instance_id
+        if self.instance_id:
+            _dict['instanceId'] = self.instance_id.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of dates_reconciled
+        if self.dates_reconciled:
+            _dict['datesReconciled'] = self.dates_reconciled.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of link_comparison_results
+        if self.link_comparison_results:
+            _dict['linkComparisonResults'] = self.link_comparison_results.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of result_types
+        if self.result_types:
+            _dict['resultTypes'] = self.result_types.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of result_statuses
+        if self.result_statuses:
+            _dict['resultStatuses'] = self.result_statuses.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of review_statuses
+        if self.review_statuses:
+            _dict['reviewStatuses'] = self.review_statuses.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationSummary:
+        """Create an instance of GroupReconciliationSummary from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationSummary.parse_obj(obj)
+
+        _obj = GroupReconciliationSummary.parse_obj({
+            "run_details": GroupReconciliationRunDetails.from_dict(obj.get("runDetails")) if obj.get("runDetails") is not None else None,
+            "group_reconciliation_definition_id": ResourceId.from_dict(obj.get("groupReconciliationDefinitionId")) if obj.get("groupReconciliationDefinitionId") is not None else None,
+            "reconciliation_type": obj.get("reconciliationType"),
+            "instance_id": GroupReconciliationInstanceId.from_dict(obj.get("instanceId")) if obj.get("instanceId") is not None else None,
+            "dates_reconciled": GroupReconciliationDates.from_dict(obj.get("datesReconciled")) if obj.get("datesReconciled") is not None else None,
+            "reconciliation_run_as_at": obj.get("reconciliationRunAsAt"),
+            "count_comparison_results": obj.get("countComparisonResults"),
+            "link_comparison_results": Link.from_dict(obj.get("linkComparisonResults")) if obj.get("linkComparisonResults") is not None else None,
+            "result_types": GroupReconciliationResultTypes.from_dict(obj.get("resultTypes")) if obj.get("resultTypes") is not None else None,
+            "result_statuses": GroupReconciliationResultStatuses.from_dict(obj.get("resultStatuses")) if obj.get("resultStatuses") is not None else None,
+            "review_statuses": GroupReconciliationReviewStatuses.from_dict(obj.get("reviewStatuses")) if obj.get("reviewStatuses") is not None else None
+        })
+        return _obj