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

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/{metadata_key_value_response.py → group_reconciliation_run_response.py}

@@ -20,14 +20,14 @@ import json
 
 from typing import Any, Dict, List
 from pydantic.v1 import BaseModel, Field, conlist
-from lusid.models.access_metadata_value import AccessMetadataValue
+from lusid.models.group_reconciliation_summary import GroupReconciliationSummary
 
-class MetadataKeyValueResponse(BaseModel):
+class GroupReconciliationRunResponse(BaseModel):
     """
-    MetadataKeyValueResponse
+    GroupReconciliationRunResponse
     """
-    metadata: Dict[str, conlist(AccessMetadataValue)] = Field(...)
-    __properties = ["metadata"]
+    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"""
@@ -43,8 +43,8 @@ class MetadataKeyValueResponse(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> MetadataKeyValueResponse:
-        """Create an instance of MetadataKeyValueResponse from a JSON string"""
+    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):
@@ -53,34 +53,25 @@ class MetadataKeyValueResponse(BaseModel):
                           exclude={
                           },
                           exclude_none=True)
-        # override the default output from pydantic by calling `to_dict()` of each value in metadata (dict of array)
-        _field_dict_of_array = {}
-        if self.metadata:
-            for _key in self.metadata:
-                if self.metadata[_key]:
-                    _field_dict_of_array[_key] = [
-                        _item.to_dict() for _item in self.metadata[_key]
-                    ]
-            _dict['metadata'] = _field_dict_of_array
+        # 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) -> MetadataKeyValueResponse:
-        """Create an instance of MetadataKeyValueResponse from a dict"""
+    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 MetadataKeyValueResponse.parse_obj(obj)
-
-        _obj = MetadataKeyValueResponse.parse_obj({
-            "metadata": dict(
-                (_k,
-                        [AccessMetadataValue.from_dict(_item) for _item in _v]
-                        if _v is not None
-                        else None
-                )
-                for _k, _v in obj.get("metadata").items()
-            )
+            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

lusid/models/group_reconciliation_user_review.py

@@ -0,0 +1,112 @@
+# 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
+from lusid.models.group_reconciliation_user_review_break_code import GroupReconciliationUserReviewBreakCode
+from lusid.models.group_reconciliation_user_review_comment import GroupReconciliationUserReviewComment
+from lusid.models.group_reconciliation_user_review_match_key import GroupReconciliationUserReviewMatchKey
+
+class GroupReconciliationUserReview(BaseModel):
+    """
+    GroupReconciliationUserReview
+    """
+    break_codes: Optional[conlist(GroupReconciliationUserReviewBreakCode)] = Field(None, alias="breakCodes", description="A list of break codes shared between the reconciliation runs of the same run instance and result hash.")
+    match_keys: Optional[conlist(GroupReconciliationUserReviewMatchKey)] = Field(None, alias="matchKeys", description="A list of match keys shared between the reconciliation runs of the same run instance and result hash.")
+    comments: Optional[conlist(GroupReconciliationUserReviewComment)] = Field(None, description="A list of comments shared between the reconciliation runs of the same run instance and result hash.")
+    __properties = ["breakCodes", "matchKeys", "comments"]
+
+    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) -> GroupReconciliationUserReview:
+        """Create an instance of GroupReconciliationUserReview 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 break_codes (list)
+        _items = []
+        if self.break_codes:
+            for _item in self.break_codes:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['breakCodes'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in match_keys (list)
+        _items = []
+        if self.match_keys:
+            for _item in self.match_keys:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['matchKeys'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in comments (list)
+        _items = []
+        if self.comments:
+            for _item in self.comments:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['comments'] = _items
+        # set to None if break_codes (nullable) is None
+        # and __fields_set__ contains the field
+        if self.break_codes is None and "break_codes" in self.__fields_set__:
+            _dict['breakCodes'] = None
+
+        # set to None if match_keys (nullable) is None
+        # and __fields_set__ contains the field
+        if self.match_keys is None and "match_keys" in self.__fields_set__:
+            _dict['matchKeys'] = None
+
+        # set to None if comments (nullable) is None
+        # and __fields_set__ contains the field
+        if self.comments is None and "comments" in self.__fields_set__:
+            _dict['comments'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationUserReview:
+        """Create an instance of GroupReconciliationUserReview from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationUserReview.parse_obj(obj)
+
+        _obj = GroupReconciliationUserReview.parse_obj({
+            "break_codes": [GroupReconciliationUserReviewBreakCode.from_dict(_item) for _item in obj.get("breakCodes")] if obj.get("breakCodes") is not None else None,
+            "match_keys": [GroupReconciliationUserReviewMatchKey.from_dict(_item) for _item in obj.get("matchKeys")] if obj.get("matchKeys") is not None else None,
+            "comments": [GroupReconciliationUserReviewComment.from_dict(_item) for _item in obj.get("comments")] if obj.get("comments") is not None else None
+        })
+        return _obj

lusid/models/group_reconciliation_user_review_add.py

@@ -0,0 +1,88 @@
+# 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
+
+class GroupReconciliationUserReviewAdd(BaseModel):
+    """
+    GroupReconciliationUserReviewAdd
+    """
+    break_code: Optional[StrictStr] = Field(None, alias="breakCode", description="The break code of the reconciliation result.")
+    match_key: Optional[StrictStr] = Field(None, alias="matchKey", description="The match key of the reconciliation result.")
+    comment_text: Optional[StrictStr] = Field(None, alias="commentText", description="User's comment regarding the reconciliation result.")
+    __properties = ["breakCode", "matchKey", "commentText"]
+
+    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) -> GroupReconciliationUserReviewAdd:
+        """Create an instance of GroupReconciliationUserReviewAdd 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 break_code (nullable) is None
+        # and __fields_set__ contains the field
+        if self.break_code is None and "break_code" in self.__fields_set__:
+            _dict['breakCode'] = None
+
+        # set to None if match_key (nullable) is None
+        # and __fields_set__ contains the field
+        if self.match_key is None and "match_key" in self.__fields_set__:
+            _dict['matchKey'] = None
+
+        # set to None if comment_text (nullable) is None
+        # and __fields_set__ contains the field
+        if self.comment_text is None and "comment_text" in self.__fields_set__:
+            _dict['commentText'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationUserReviewAdd:
+        """Create an instance of GroupReconciliationUserReviewAdd from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationUserReviewAdd.parse_obj(obj)
+
+        _obj = GroupReconciliationUserReviewAdd.parse_obj({
+            "break_code": obj.get("breakCode"),
+            "match_key": obj.get("matchKey"),
+            "comment_text": obj.get("commentText")
+        })
+        return _obj

lusid/models/group_reconciliation_user_review_break_code.py

@@ -0,0 +1,80 @@
+# 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, constr
+
+class GroupReconciliationUserReviewBreakCode(BaseModel):
+    """
+    GroupReconciliationUserReviewBreakCode
+    """
+    break_code: constr(strict=True, min_length=1) = Field(..., alias="breakCode", description="The break code of the reconciliation result.")
+    user_id: Optional[constr(strict=True, max_length=16384, min_length=0)] = Field(None, alias="userId", description="Id of the user who made a User Review input.")
+    as_at_added: Optional[datetime] = Field(None, alias="asAtAdded", description="The timestamp of the added User Review input.")
+    as_at_invalid: Optional[datetime] = Field(None, alias="asAtInvalid", description="The timestamp when User Review input became invalid e.g. because of the different attribute values within the new run.")
+    __properties = ["breakCode", "userId", "asAtAdded", "asAtInvalid"]
+
+    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) -> GroupReconciliationUserReviewBreakCode:
+        """Create an instance of GroupReconciliationUserReviewBreakCode 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
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationUserReviewBreakCode:
+        """Create an instance of GroupReconciliationUserReviewBreakCode from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationUserReviewBreakCode.parse_obj(obj)
+
+        _obj = GroupReconciliationUserReviewBreakCode.parse_obj({
+            "break_code": obj.get("breakCode"),
+            "user_id": obj.get("userId"),
+            "as_at_added": obj.get("asAtAdded"),
+            "as_at_invalid": obj.get("asAtInvalid")
+        })
+        return _obj

lusid/models/group_reconciliation_user_review_comment.py

@@ -0,0 +1,80 @@
+# 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, constr
+
+class GroupReconciliationUserReviewComment(BaseModel):
+    """
+    GroupReconciliationUserReviewComment
+    """
+    comment_text: constr(strict=True, min_length=1) = Field(..., alias="commentText", description="User's comment regarding the reconciliation result.")
+    user_id: Optional[constr(strict=True, max_length=16384, min_length=0)] = Field(None, alias="userId", description="Id of the user who made a User Review input.")
+    as_at_added: Optional[datetime] = Field(None, alias="asAtAdded", description="The timestamp of the added User Review input.")
+    as_at_invalid: Optional[datetime] = Field(None, alias="asAtInvalid", description="The timestamp when User Review input became invalid e.g. because of the different attribute values within the new run.")
+    __properties = ["commentText", "userId", "asAtAdded", "asAtInvalid"]
+
+    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) -> GroupReconciliationUserReviewComment:
+        """Create an instance of GroupReconciliationUserReviewComment 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
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationUserReviewComment:
+        """Create an instance of GroupReconciliationUserReviewComment from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationUserReviewComment.parse_obj(obj)
+
+        _obj = GroupReconciliationUserReviewComment.parse_obj({
+            "comment_text": obj.get("commentText"),
+            "user_id": obj.get("userId"),
+            "as_at_added": obj.get("asAtAdded"),
+            "as_at_invalid": obj.get("asAtInvalid")
+        })
+        return _obj