lusid-sdk 2.1.401__py3-none-any.whl → 2.1.423__py3-none-any.whl

lusid/models/batch_upsert_portfolio_access_metadata_request.py

@@ -18,16 +18,18 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict
-from pydantic.v1 import BaseModel, Field
-from lusid.models.metadata_key_value import MetadataKeyValue
+from typing import Any, Dict, List
+from pydantic.v1 import BaseModel, Field, conlist
+from lusid.models.access_metadata_value import AccessMetadataValue
+from lusid.models.resource_id import ResourceId
 
 class BatchUpsertPortfolioAccessMetadataRequest(BaseModel):
     """
     BatchUpsertPortfolioAccessMetadataRequest
     """
-    portfolios_with_metadata: Dict[str, MetadataKeyValue] = Field(..., alias="portfoliosWithMetadata", description="The set of portfolios with the access control metadata")
-    __properties = ["portfoliosWithMetadata"]
+    portfolio_id: ResourceId = Field(..., alias="portfolioId")
+    metadata: Dict[str, conlist(AccessMetadataValue)] = Field(...)
+    __properties = ["portfolioId", "metadata"]
 
     class Config:
         """Pydantic configuration"""
@@ -53,13 +55,18 @@ class BatchUpsertPortfolioAccessMetadataRequest(BaseModel):
                           exclude={
                           },
                           exclude_none=True)
-        # override the default output from pydantic by calling `to_dict()` of each value in portfolios_with_metadata (dict)
-        _field_dict = {}
-        if self.portfolios_with_metadata:
-            for _key in self.portfolios_with_metadata:
-                if self.portfolios_with_metadata[_key]:
-                    _field_dict[_key] = self.portfolios_with_metadata[_key].to_dict()
-            _dict['portfoliosWithMetadata'] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of portfolio_id
+        if self.portfolio_id:
+            _dict['portfolioId'] = self.portfolio_id.to_dict()
+        # 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
         return _dict
 
     @classmethod
@@ -72,11 +79,14 @@ class BatchUpsertPortfolioAccessMetadataRequest(BaseModel):
             return BatchUpsertPortfolioAccessMetadataRequest.parse_obj(obj)
 
         _obj = BatchUpsertPortfolioAccessMetadataRequest.parse_obj({
-            "portfolios_with_metadata": dict(
-                (_k, MetadataKeyValue.from_dict(_v))
-                for _k, _v in obj.get("portfoliosWithMetadata").items()
+            "portfolio_id": ResourceId.from_dict(obj.get("portfolioId")) if obj.get("portfolioId") is not None else None,
+            "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()
             )
-            if obj.get("portfoliosWithMetadata") is not None
-            else None
         })
         return _obj

lusid/models/batch_upsert_portfolio_access_metadata_response.py

@@ -18,16 +18,20 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict
-from pydantic.v1 import BaseModel, Field
-from lusid.models.metadata_key_value_response import MetadataKeyValueResponse
+from typing import Any, Dict, List, Optional
+from pydantic.v1 import BaseModel, Field, conlist
+from lusid.models.batch_upsert_portfolio_access_metadata_response_item import BatchUpsertPortfolioAccessMetadataResponseItem
+from lusid.models.error_detail import ErrorDetail
+from lusid.models.link import Link
 
 class BatchUpsertPortfolioAccessMetadataResponse(BaseModel):
     """
     BatchUpsertPortfolioAccessMetadataResponse
     """
-    portfolios_with_metadata: Dict[str, MetadataKeyValueResponse] = Field(..., alias="portfoliosWithMetadata", description="The set of portfolios with the access control metadata")
-    __properties = ["portfoliosWithMetadata"]
+    values: Optional[Dict[str, BatchUpsertPortfolioAccessMetadataResponseItem]] = Field(None, description="The items have been successfully updated or created.")
+    failed: Optional[Dict[str, ErrorDetail]] = Field(None, description="The items that could not be updated or created along with a reason for their failure.")
+    links: Optional[conlist(Link)] = None
+    __properties = ["values", "failed", "links"]
 
     class Config:
         """Pydantic configuration"""
@@ -53,13 +57,42 @@ class BatchUpsertPortfolioAccessMetadataResponse(BaseModel):
                           exclude={
                           },
                           exclude_none=True)
-        # override the default output from pydantic by calling `to_dict()` of each value in portfolios_with_metadata (dict)
+        # override the default output from pydantic by calling `to_dict()` of each value in values (dict)
         _field_dict = {}
-        if self.portfolios_with_metadata:
-            for _key in self.portfolios_with_metadata:
-                if self.portfolios_with_metadata[_key]:
-                    _field_dict[_key] = self.portfolios_with_metadata[_key].to_dict()
-            _dict['portfoliosWithMetadata'] = _field_dict
+        if self.values:
+            for _key in self.values:
+                if self.values[_key]:
+                    _field_dict[_key] = self.values[_key].to_dict()
+            _dict['values'] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of each value in failed (dict)
+        _field_dict = {}
+        if self.failed:
+            for _key in self.failed:
+                if self.failed[_key]:
+                    _field_dict[_key] = self.failed[_key].to_dict()
+            _dict['failed'] = _field_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 values (nullable) is None
+        # and __fields_set__ contains the field
+        if self.values is None and "values" in self.__fields_set__:
+            _dict['values'] = None
+
+        # set to None if failed (nullable) is None
+        # and __fields_set__ contains the field
+        if self.failed is None and "failed" in self.__fields_set__:
+            _dict['failed'] = 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
@@ -72,11 +105,18 @@ class BatchUpsertPortfolioAccessMetadataResponse(BaseModel):
             return BatchUpsertPortfolioAccessMetadataResponse.parse_obj(obj)
 
         _obj = BatchUpsertPortfolioAccessMetadataResponse.parse_obj({
-            "portfolios_with_metadata": dict(
-                (_k, MetadataKeyValueResponse.from_dict(_v))
-                for _k, _v in obj.get("portfoliosWithMetadata").items()
+            "values": dict(
+                (_k, BatchUpsertPortfolioAccessMetadataResponseItem.from_dict(_v))
+                for _k, _v in obj.get("values").items()
+            )
+            if obj.get("values") is not None
+            else None,
+            "failed": dict(
+                (_k, ErrorDetail.from_dict(_v))
+                for _k, _v in obj.get("failed").items()
             )
-            if obj.get("portfoliosWithMetadata") is not None
-            else None
+            if obj.get("failed") 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

lusid/models/{metadata_key_value.py → batch_upsert_portfolio_access_metadata_response_item.py}

@@ -21,13 +21,15 @@ 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.resource_id import ResourceId
 
-class MetadataKeyValue(BaseModel):
+class BatchUpsertPortfolioAccessMetadataResponseItem(BaseModel):
     """
-    MetadataKeyValue
+    BatchUpsertPortfolioAccessMetadataResponseItem
     """
+    portfolio_id: ResourceId = Field(..., alias="portfolioId")
     metadata: Dict[str, conlist(AccessMetadataValue)] = Field(...)
-    __properties = ["metadata"]
+    __properties = ["portfolioId", "metadata"]
 
     class Config:
         """Pydantic configuration"""
@@ -43,8 +45,8 @@ class MetadataKeyValue(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> MetadataKeyValue:
-        """Create an instance of MetadataKeyValue from a JSON string"""
+    def from_json(cls, json_str: str) -> BatchUpsertPortfolioAccessMetadataResponseItem:
+        """Create an instance of BatchUpsertPortfolioAccessMetadataResponseItem from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self):
@@ -53,6 +55,9 @@ class MetadataKeyValue(BaseModel):
                           exclude={
                           },
                           exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of portfolio_id
+        if self.portfolio_id:
+            _dict['portfolioId'] = self.portfolio_id.to_dict()
         # 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:
@@ -65,15 +70,16 @@ class MetadataKeyValue(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> MetadataKeyValue:
-        """Create an instance of MetadataKeyValue from a dict"""
+    def from_dict(cls, obj: dict) -> BatchUpsertPortfolioAccessMetadataResponseItem:
+        """Create an instance of BatchUpsertPortfolioAccessMetadataResponseItem from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return MetadataKeyValue.parse_obj(obj)
+            return BatchUpsertPortfolioAccessMetadataResponseItem.parse_obj(obj)
 
-        _obj = MetadataKeyValue.parse_obj({
+        _obj = BatchUpsertPortfolioAccessMetadataResponseItem.parse_obj({
+            "portfolio_id": ResourceId.from_dict(obj.get("portfolioId")) if obj.get("portfolioId") is not None else None,
             "metadata": dict(
                 (_k,
                         [AccessMetadataValue.from_dict(_item) for _item in _v]

lusid/models/{component_rule.py → break_code_source.py}

@@ -18,16 +18,16 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, List, Optional
-from pydantic.v1 import BaseModel, conlist
-from lusid.models.component_filter import ComponentFilter
+from typing import Any, Dict
+from pydantic.v1 import BaseModel, Field
+from lusid.models.resource_id import ResourceId
 
-class ComponentRule(BaseModel):
+class BreakCodeSource(BaseModel):
     """
-    ComponentRule
+    BreakCodeSource
     """
-    components: Optional[conlist(ComponentFilter)] = None
-    __properties = ["components"]
+    data_type_id: ResourceId = Field(..., alias="dataTypeId")
+    __properties = ["dataTypeId"]
 
     class Config:
         """Pydantic configuration"""
@@ -43,8 +43,8 @@ class ComponentRule(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> ComponentRule:
-        """Create an instance of ComponentRule from a JSON string"""
+    def from_json(cls, json_str: str) -> BreakCodeSource:
+        """Create an instance of BreakCodeSource from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self):
@@ -53,25 +53,21 @@ class ComponentRule(BaseModel):
                           exclude={
                           },
                           exclude_none=True)
-        # override the default output from pydantic by calling `to_dict()` of each item in components (list)
-        _items = []
-        if self.components:
-            for _item in self.components:
-                if _item:
-                    _items.append(_item.to_dict())
-            _dict['components'] = _items
+        # override the default output from pydantic by calling `to_dict()` of data_type_id
+        if self.data_type_id:
+            _dict['dataTypeId'] = self.data_type_id.to_dict()
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> ComponentRule:
-        """Create an instance of ComponentRule from a dict"""
+    def from_dict(cls, obj: dict) -> BreakCodeSource:
+        """Create an instance of BreakCodeSource from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return ComponentRule.parse_obj(obj)
+            return BreakCodeSource.parse_obj(obj)
 
-        _obj = ComponentRule.parse_obj({
-            "components": [ComponentFilter.from_dict(_item) for _item in obj.get("components")] if obj.get("components") is not None else None
+        _obj = BreakCodeSource.parse_obj({
+            "data_type_id": ResourceId.from_dict(obj.get("dataTypeId")) if obj.get("dataTypeId") is not None else None
         })
         return _obj

lusid/models/change_interval_with_order_management_detail.py

@@ -0,0 +1,137 @@
+# 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, StrictInt, StrictStr
+from lusid.models.property_value import PropertyValue
+from lusid.models.staged_modification_effective_range import StagedModificationEffectiveRange
+
+class ChangeIntervalWithOrderManagementDetail(BaseModel):
+    """
+    Defines a change that occured for an entity, with extra detail about the change  # noqa: E501
+    """
+    detail: Optional[Dict[str, StrictStr]] = Field(None, description="Information about the particular instance of the ChangeInterval (supplied information depends on the type of Action). Contains extra detail for order management actions such as related entity ids and compliance run details.")
+    action_description: Optional[StrictStr] = Field(None, alias="actionDescription", description="Description of the action performed on the entity.")
+    as_at_modified: Optional[datetime] = Field(None, alias="asAtModified", description="The date/time of the change.")
+    user_id_modified: Optional[StrictStr] = Field(None, alias="userIdModified", description="The unique identifier of the user that made the change.")
+    request_id_modified: Optional[StrictStr] = Field(None, alias="requestIdModified", description="The unique identifier of the request that the changes were part of.")
+    as_at_version_number: Optional[StrictInt] = Field(None, alias="asAtVersionNumber", description="The version number for the entity (the entity was created at version 1). This may refer to the version number of a changed related entity, not a change for the entity itself.")
+    staged_modification_id_modified: Optional[StrictStr] = Field(None, alias="stagedModificationIdModified", description="The id of the staged modification that was approved. Will be null if the change didn't come from a staged modification.")
+    action: Optional[StrictStr] = Field(None, description="The action performed on the entity.")
+    attribute_name: Optional[StrictStr] = Field(None, alias="attributeName", description="The name of the field or property that has been changed.")
+    previous_value: Optional[PropertyValue] = Field(None, alias="previousValue")
+    new_value: Optional[PropertyValue] = Field(None, alias="newValue")
+    effective_range: Optional[StagedModificationEffectiveRange] = Field(None, alias="effectiveRange")
+    __properties = ["detail", "actionDescription", "asAtModified", "userIdModified", "requestIdModified", "asAtVersionNumber", "stagedModificationIdModified", "action", "attributeName", "previousValue", "newValue", "effectiveRange"]
+
+    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) -> ChangeIntervalWithOrderManagementDetail:
+        """Create an instance of ChangeIntervalWithOrderManagementDetail 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 previous_value
+        if self.previous_value:
+            _dict['previousValue'] = self.previous_value.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of new_value
+        if self.new_value:
+            _dict['newValue'] = self.new_value.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of effective_range
+        if self.effective_range:
+            _dict['effectiveRange'] = self.effective_range.to_dict()
+        # set to None if detail (nullable) is None
+        # and __fields_set__ contains the field
+        if self.detail is None and "detail" in self.__fields_set__:
+            _dict['detail'] = None
+
+        # set to None if action_description (nullable) is None
+        # and __fields_set__ contains the field
+        if self.action_description is None and "action_description" in self.__fields_set__:
+            _dict['actionDescription'] = None
+
+        # set to None if user_id_modified (nullable) is None
+        # and __fields_set__ contains the field
+        if self.user_id_modified is None and "user_id_modified" in self.__fields_set__:
+            _dict['userIdModified'] = None
+
+        # set to None if request_id_modified (nullable) is None
+        # and __fields_set__ contains the field
+        if self.request_id_modified is None and "request_id_modified" in self.__fields_set__:
+            _dict['requestIdModified'] = None
+
+        # set to None if staged_modification_id_modified (nullable) is None
+        # and __fields_set__ contains the field
+        if self.staged_modification_id_modified is None and "staged_modification_id_modified" in self.__fields_set__:
+            _dict['stagedModificationIdModified'] = None
+
+        # set to None if action (nullable) is None
+        # and __fields_set__ contains the field
+        if self.action is None and "action" in self.__fields_set__:
+            _dict['action'] = None
+
+        # 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
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> ChangeIntervalWithOrderManagementDetail:
+        """Create an instance of ChangeIntervalWithOrderManagementDetail from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ChangeIntervalWithOrderManagementDetail.parse_obj(obj)
+
+        _obj = ChangeIntervalWithOrderManagementDetail.parse_obj({
+            "detail": obj.get("detail"),
+            "action_description": obj.get("actionDescription"),
+            "as_at_modified": obj.get("asAtModified"),
+            "user_id_modified": obj.get("userIdModified"),
+            "request_id_modified": obj.get("requestIdModified"),
+            "as_at_version_number": obj.get("asAtVersionNumber"),
+            "staged_modification_id_modified": obj.get("stagedModificationIdModified"),
+            "action": obj.get("action"),
+            "attribute_name": obj.get("attributeName"),
+            "previous_value": PropertyValue.from_dict(obj.get("previousValue")) if obj.get("previousValue") is not None else None,
+            "new_value": PropertyValue.from_dict(obj.get("newValue")) if obj.get("newValue") is not None else None,
+            "effective_range": StagedModificationEffectiveRange.from_dict(obj.get("effectiveRange")) if obj.get("effectiveRange") is not None else None
+        })
+        return _obj

lusid/models/create_group_reconciliation_definition_request.py

@@ -0,0 +1,113 @@
+# 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.break_code_source import BreakCodeSource
+from lusid.models.group_reconciliation_definition_comparison_ruleset_ids import GroupReconciliationDefinitionComparisonRulesetIds
+from lusid.models.group_reconciliation_definition_currencies import GroupReconciliationDefinitionCurrencies
+from lusid.models.group_reconciliation_definition_portfolio_entity_ids import GroupReconciliationDefinitionPortfolioEntityIds
+from lusid.models.group_reconciliation_definition_recipe_ids import GroupReconciliationDefinitionRecipeIds
+from lusid.models.resource_id import ResourceId
+from lusid.models.transaction_date_windows import TransactionDateWindows
+
+class CreateGroupReconciliationDefinitionRequest(BaseModel):
+    """
+    CreateGroupReconciliationDefinitionRequest
+    """
+    id: Optional[ResourceId] = None
+    display_name: constr(strict=True, min_length=1) = Field(..., alias="displayName", description="The name of the Group Reconciliation Definition")
+    description: constr(strict=True, min_length=1) = Field(..., description="The description of the Group Reconciliation Definition")
+    portfolio_entity_ids: GroupReconciliationDefinitionPortfolioEntityIds = Field(..., alias="portfolioEntityIds")
+    recipe_ids: Optional[GroupReconciliationDefinitionRecipeIds] = Field(None, alias="recipeIds")
+    currencies: Optional[GroupReconciliationDefinitionCurrencies] = None
+    transaction_date_windows: Optional[TransactionDateWindows] = Field(None, alias="transactionDateWindows")
+    comparison_ruleset_ids: Optional[GroupReconciliationDefinitionComparisonRulesetIds] = Field(None, alias="comparisonRulesetIds")
+    break_code_source: BreakCodeSource = Field(..., alias="breakCodeSource")
+    __properties = ["id", "displayName", "description", "portfolioEntityIds", "recipeIds", "currencies", "transactionDateWindows", "comparisonRulesetIds", "breakCodeSource"]
+
+    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) -> CreateGroupReconciliationDefinitionRequest:
+        """Create an instance of CreateGroupReconciliationDefinitionRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of id
+        if self.id:
+            _dict['id'] = self.id.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of portfolio_entity_ids
+        if self.portfolio_entity_ids:
+            _dict['portfolioEntityIds'] = self.portfolio_entity_ids.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of recipe_ids
+        if self.recipe_ids:
+            _dict['recipeIds'] = self.recipe_ids.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of currencies
+        if self.currencies:
+            _dict['currencies'] = self.currencies.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of transaction_date_windows
+        if self.transaction_date_windows:
+            _dict['transactionDateWindows'] = self.transaction_date_windows.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of comparison_ruleset_ids
+        if self.comparison_ruleset_ids:
+            _dict['comparisonRulesetIds'] = self.comparison_ruleset_ids.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of break_code_source
+        if self.break_code_source:
+            _dict['breakCodeSource'] = self.break_code_source.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> CreateGroupReconciliationDefinitionRequest:
+        """Create an instance of CreateGroupReconciliationDefinitionRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return CreateGroupReconciliationDefinitionRequest.parse_obj(obj)
+
+        _obj = CreateGroupReconciliationDefinitionRequest.parse_obj({
+            "id": ResourceId.from_dict(obj.get("id")) if obj.get("id") is not None else None,
+            "display_name": obj.get("displayName"),
+            "description": obj.get("description"),
+            "portfolio_entity_ids": GroupReconciliationDefinitionPortfolioEntityIds.from_dict(obj.get("portfolioEntityIds")) if obj.get("portfolioEntityIds") is not None else None,
+            "recipe_ids": GroupReconciliationDefinitionRecipeIds.from_dict(obj.get("recipeIds")) if obj.get("recipeIds") is not None else None,
+            "currencies": GroupReconciliationDefinitionCurrencies.from_dict(obj.get("currencies")) if obj.get("currencies") is not None else None,
+            "transaction_date_windows": TransactionDateWindows.from_dict(obj.get("transactionDateWindows")) if obj.get("transactionDateWindows") is not None else None,
+            "comparison_ruleset_ids": GroupReconciliationDefinitionComparisonRulesetIds.from_dict(obj.get("comparisonRulesetIds")) if obj.get("comparisonRulesetIds") is not None else None,
+            "break_code_source": BreakCodeSource.from_dict(obj.get("breakCodeSource")) if obj.get("breakCodeSource") is not None else None
+        })
+        return _obj