lusid-sdk 2.1.405__py3-none-any.whl → 2.1.537__py3-none-any.whl

lusid/models/group_reconciliation_definition_currencies.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 GroupReconciliationDefinitionCurrencies(BaseModel):
+    """
+    GroupReconciliationDefinitionCurrencies
+    """
+    left: constr(strict=True, max_length=3, min_length=0) = Field(..., description="Currency for the left side of a reconciliation")
+    right: constr(strict=True, max_length=3, min_length=0) = Field(..., description="Currency for the right side of a reconciliation")
+    __properties = ["left", "right"]
+
+    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) -> GroupReconciliationDefinitionCurrencies:
+        """Create an instance of GroupReconciliationDefinitionCurrencies 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) -> GroupReconciliationDefinitionCurrencies:
+        """Create an instance of GroupReconciliationDefinitionCurrencies from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationDefinitionCurrencies.parse_obj(obj)
+
+        _obj = GroupReconciliationDefinitionCurrencies.parse_obj({
+            "left": obj.get("left"),
+            "right": obj.get("right")
+        })
+        return _obj

lusid/models/group_reconciliation_definition_portfolio_entity_ids.py

@@ -0,0 +1,86 @@
+# 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.portfolio_entity_id import PortfolioEntityId
+
+class GroupReconciliationDefinitionPortfolioEntityIds(BaseModel):
+    """
+    GroupReconciliationDefinitionPortfolioEntityIds
+    """
+    left: conlist(PortfolioEntityId, min_items=1) = Field(..., description="Portfolio Entity Id of the left side of a reconciliation")
+    right: conlist(PortfolioEntityId, min_items=1) = Field(..., description="Portfolio Entity Id of the right side of a reconciliation")
+    __properties = ["left", "right"]
+
+    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) -> GroupReconciliationDefinitionPortfolioEntityIds:
+        """Create an instance of GroupReconciliationDefinitionPortfolioEntityIds 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 left (list)
+        _items = []
+        if self.left:
+            for _item in self.left:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['left'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in right (list)
+        _items = []
+        if self.right:
+            for _item in self.right:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['right'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationDefinitionPortfolioEntityIds:
+        """Create an instance of GroupReconciliationDefinitionPortfolioEntityIds from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationDefinitionPortfolioEntityIds.parse_obj(obj)
+
+        _obj = GroupReconciliationDefinitionPortfolioEntityIds.parse_obj({
+            "left": [PortfolioEntityId.from_dict(_item) for _item in obj.get("left")] if obj.get("left") is not None else None,
+            "right": [PortfolioEntityId.from_dict(_item) for _item in obj.get("right")] if obj.get("right") is not None else None
+        })
+        return _obj

lusid/models/group_reconciliation_definition_recipe_ids.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
+from pydantic.v1 import BaseModel, Field
+from lusid.models.resource_id import ResourceId
+
+class GroupReconciliationDefinitionRecipeIds(BaseModel):
+    """
+    GroupReconciliationDefinitionRecipeIds
+    """
+    left: ResourceId = Field(...)
+    right: ResourceId = Field(...)
+    __properties = ["left", "right"]
+
+    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) -> GroupReconciliationDefinitionRecipeIds:
+        """Create an instance of GroupReconciliationDefinitionRecipeIds 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 left
+        if self.left:
+            _dict['left'] = self.left.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of right
+        if self.right:
+            _dict['right'] = self.right.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationDefinitionRecipeIds:
+        """Create an instance of GroupReconciliationDefinitionRecipeIds from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationDefinitionRecipeIds.parse_obj(obj)
+
+        _obj = GroupReconciliationDefinitionRecipeIds.parse_obj({
+            "left": ResourceId.from_dict(obj.get("left")) if obj.get("left") is not None else None,
+            "right": ResourceId.from_dict(obj.get("right")) if obj.get("right") is not None else None
+        })
+        return _obj

lusid/models/group_reconciliation_instance_id.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 GroupReconciliationInstanceId(BaseModel):
+    """
+    GroupReconciliationInstanceId
+    """
+    run_id_type: constr(strict=True, min_length=1) = Field(..., alias="runIdType", description="Type of the reconciliation run, manual or automatic (via the workflow). \"Manual\" | \"WorkflowServiceTaskId\"")
+    run_id_value: constr(strict=True, min_length=1) = Field(..., alias="runIdValue", description="Reconciliation run identifier: a manually-provided key or taskId.")
+    __properties = ["runIdType", "runIdValue"]
+
+    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) -> GroupReconciliationInstanceId:
+        """Create an instance of GroupReconciliationInstanceId 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) -> GroupReconciliationInstanceId:
+        """Create an instance of GroupReconciliationInstanceId from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationInstanceId.parse_obj(obj)
+
+        _obj = GroupReconciliationInstanceId.parse_obj({
+            "run_id_type": obj.get("runIdType"),
+            "run_id_value": obj.get("runIdValue")
+        })
+        return _obj

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