solvimon-python-sdk 0.0.4b0__py3-none-any.whl

solvimon_python_sdk/models/approval_policy_rule.py

@@ -0,0 +1,159 @@
+# coding: utf-8
+
+"""
+    Solvimon API
+
+    Unified Solvimon API covering Configuration, Event, Identity, and Transaction domains.
+
+    The version of the OpenAPI document: 0.0.4-beta
+    Contact: contact@solvimon.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from solvimon_python_sdk.models.approval_policy_billing_entity import ApprovalPolicyBillingEntity
+from solvimon_python_sdk.models.approval_policy_billing_period import ApprovalPolicyBillingPeriod
+from solvimon_python_sdk.models.approval_policy_commitment import ApprovalPolicyCommitment
+from solvimon_python_sdk.models.approval_policy_custom_field import ApprovalPolicyCustomField
+from solvimon_python_sdk.models.approval_policy_discount import ApprovalPolicyDiscount
+from solvimon_python_sdk.models.approval_policy_due_date import ApprovalPolicyDueDate
+from solvimon_python_sdk.models.approval_policy_payment_acceptor import ApprovalPolicyPaymentAcceptor
+from solvimon_python_sdk.models.approval_policy_pricing import ApprovalPolicyPricing
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ApprovalPolicyRule(BaseModel):
+    """
+    ApprovalPolicyRule
+    """ # noqa: E501
+    type: Optional[StrictStr] = Field(default=None, description="The type of rule that will be applied.")
+    comparator: Optional[StrictStr] = Field(default=None, description="Indicates how the value(s) will be compared.")
+    discount: Optional[ApprovalPolicyDiscount] = Field(default=None, description="The values for a discount rule.")
+    commitment: Optional[ApprovalPolicyCommitment] = Field(default=None, description="The values for a commitment rule.")
+    pricing: Optional[ApprovalPolicyPricing] = Field(default=None, description="The values for a pricing rule.")
+    custom_field: Optional[ApprovalPolicyCustomField] = Field(default=None, description="The values for a custom field rule.")
+    billing_entity: Optional[ApprovalPolicyBillingEntity] = Field(default=None, description="The values for a billing entity rule.")
+    billing_period: Optional[ApprovalPolicyBillingPeriod] = Field(default=None, description="The values for a billing period rule.")
+    due_date: Optional[ApprovalPolicyDueDate] = Field(default=None, description="The values for a due date rule.")
+    payment_acceptor: Optional[ApprovalPolicyPaymentAcceptor] = Field(default=None, description="The values for a payment term rule.")
+    __properties: ClassVar[List[str]] = ["type", "comparator", "discount", "commitment", "pricing", "custom_field", "billing_entity", "billing_period", "due_date", "payment_acceptor"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['ALWAYS_APPROVE', 'DISCOUNT', 'COMMITMENT', 'PRICING', 'CUSTOM_FIELD', 'BILLING_ENTITY', 'BILLING_PERIOD', 'DUE_DATE', 'PAYMENT_ACCEPTOR']):
+            raise ValueError("must be one of enum values ('ALWAYS_APPROVE', 'DISCOUNT', 'COMMITMENT', 'PRICING', 'CUSTOM_FIELD', 'BILLING_ENTITY', 'BILLING_PERIOD', 'DUE_DATE', 'PAYMENT_ACCEPTOR')")
+        return value
+
+    @field_validator('comparator')
+    def comparator_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['LESS_THAN', 'LESS_THAN_OR_EQUALS', 'EQUALS', 'GREATER_THAN_OR_EQUALS', 'GREATER_THAN']):
+            raise ValueError("must be one of enum values ('LESS_THAN', 'LESS_THAN_OR_EQUALS', 'EQUALS', 'GREATER_THAN_OR_EQUALS', 'GREATER_THAN')")
+        return value
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ApprovalPolicyRule from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of discount
+        if self.discount:
+            _dict['discount'] = self.discount.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of commitment
+        if self.commitment:
+            _dict['commitment'] = self.commitment.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of pricing
+        if self.pricing:
+            _dict['pricing'] = self.pricing.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of custom_field
+        if self.custom_field:
+            _dict['custom_field'] = self.custom_field.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of billing_entity
+        if self.billing_entity:
+            _dict['billing_entity'] = self.billing_entity.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of billing_period
+        if self.billing_period:
+            _dict['billing_period'] = self.billing_period.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of due_date
+        if self.due_date:
+            _dict['due_date'] = self.due_date.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of payment_acceptor
+        if self.payment_acceptor:
+            _dict['payment_acceptor'] = self.payment_acceptor.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ApprovalPolicyRule from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "type": obj.get("type"),
+            "comparator": obj.get("comparator"),
+            "discount": ApprovalPolicyDiscount.from_dict(obj["discount"]) if obj.get("discount") is not None else None,
+            "commitment": ApprovalPolicyCommitment.from_dict(obj["commitment"]) if obj.get("commitment") is not None else None,
+            "pricing": ApprovalPolicyPricing.from_dict(obj["pricing"]) if obj.get("pricing") is not None else None,
+            "custom_field": ApprovalPolicyCustomField.from_dict(obj["custom_field"]) if obj.get("custom_field") is not None else None,
+            "billing_entity": ApprovalPolicyBillingEntity.from_dict(obj["billing_entity"]) if obj.get("billing_entity") is not None else None,
+            "billing_period": ApprovalPolicyBillingPeriod.from_dict(obj["billing_period"]) if obj.get("billing_period") is not None else None,
+            "due_date": ApprovalPolicyDueDate.from_dict(obj["due_date"]) if obj.get("due_date") is not None else None,
+            "payment_acceptor": ApprovalPolicyPaymentAcceptor.from_dict(obj["payment_acceptor"]) if obj.get("payment_acceptor") is not None else None
+        })
+        return _obj
+
+

solvimon_python_sdk/models/approval_policy_rule_group.py

@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+    Solvimon API
+
+    Unified Solvimon API covering Configuration, Event, Identity, and Transaction domains.
+
+    The version of the OpenAPI document: 0.0.4-beta
+    Contact: contact@solvimon.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from solvimon_python_sdk.models.approval_policy_rule import ApprovalPolicyRule
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ApprovalPolicyRuleGroup(BaseModel):
+    """
+    ApprovalPolicyRuleGroup
+    """ # noqa: E501
+    rules: Optional[List[ApprovalPolicyRule]] = Field(default=None, description="The rules that are applicable for the approval policy. These will be chained using AND.")
+    __properties: ClassVar[List[str]] = ["rules"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ApprovalPolicyRuleGroup from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in rules (list)
+        _items = []
+        if self.rules:
+            for _item_rules in self.rules:
+                _items.append(_item_rules.to_dict() if _item_rules is not None else None)
+            _dict['rules'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ApprovalPolicyRuleGroup from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "rules": [ApprovalPolicyRule.from_dict(_item) for _item in obj["rules"]] if obj.get("rules") is not None else None
+        })
+        return _obj
+
+

solvimon_python_sdk/models/approval_policy_rule_group_create_request.py

@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+    Solvimon API
+
+    Unified Solvimon API covering Configuration, Event, Identity, and Transaction domains.
+
+    The version of the OpenAPI document: 0.0.4-beta
+    Contact: contact@solvimon.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from solvimon_python_sdk.models.approval_policy_rule import ApprovalPolicyRule
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ApprovalPolicyRuleGroupCreateRequest(BaseModel):
+    """
+    ApprovalPolicyRuleGroupCreateRequest
+    """ # noqa: E501
+    rules: Optional[List[ApprovalPolicyRule]] = Field(default=None, description="The rules that are applicable for the approval policy. These will be chained using AND.")
+    __properties: ClassVar[List[str]] = ["rules"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ApprovalPolicyRuleGroupCreateRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in rules (list)
+        _items = []
+        if self.rules:
+            for _item_rules in self.rules:
+                _items.append(_item_rules.to_dict() if _item_rules is not None else None)
+            _dict['rules'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ApprovalPolicyRuleGroupCreateRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "rules": [ApprovalPolicyRule.from_dict(_item) for _item in obj["rules"]] if obj.get("rules") is not None else None
+        })
+        return _obj
+
+

solvimon_python_sdk/models/approval_policy_rule_group_update_request.py

@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+    Solvimon API
+
+    Unified Solvimon API covering Configuration, Event, Identity, and Transaction domains.
+
+    The version of the OpenAPI document: 0.0.4-beta
+    Contact: contact@solvimon.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from solvimon_python_sdk.models.approval_policy_rule import ApprovalPolicyRule
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ApprovalPolicyRuleGroupUpdateRequest(BaseModel):
+    """
+    ApprovalPolicyRuleGroupUpdateRequest
+    """ # noqa: E501
+    rules: Optional[List[ApprovalPolicyRule]] = Field(default=None, description="The rules that are applicable for the approval policy. These will be chained using AND.")
+    __properties: ClassVar[List[str]] = ["rules"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ApprovalPolicyRuleGroupUpdateRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in rules (list)
+        _items = []
+        if self.rules:
+            for _item_rules in self.rules:
+                _items.append(_item_rules.to_dict() if _item_rules is not None else None)
+            _dict['rules'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ApprovalPolicyRuleGroupUpdateRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "rules": [ApprovalPolicyRule.from_dict(_item) for _item in obj["rules"]] if obj.get("rules") is not None else None
+        })
+        return _obj
+
+

solvimon_python_sdk/models/approval_policy_update_request.py

@@ -0,0 +1,169 @@
+# coding: utf-8
+
+"""
+    Solvimon API
+
+    Unified Solvimon API covering Configuration, Event, Identity, and Transaction domains.
+
+    The version of the OpenAPI document: 0.0.4-beta
+    Contact: contact@solvimon.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from solvimon_python_sdk.models.approval_policy_rule_group_update_request import ApprovalPolicyRuleGroupUpdateRequest
+from solvimon_python_sdk.models.approvers_update_request import ApproversUpdateRequest
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ApprovalPolicyUpdateRequest(BaseModel):
+    """
+    ApprovalPolicyUpdateRequest
+    """ # noqa: E501
+    object_type: Optional[StrictStr] = None
+    id: Optional[StrictStr] = None
+    source_type: Optional[StrictStr] = Field(default=None, description="The object type of this approval policy.")
+    reference: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=256)]] = Field(default=None, description="The human-readable reference to this approval policy.")
+    name: Optional[StrictStr] = Field(default=None, description="The name of this approval policy.")
+    status: Optional[StrictStr] = Field(default=None, description="The current status of the approval policy.")
+    approval_type: Optional[StrictStr] = Field(default=None, description="The type of approval process which needs to be followed if this approval policy is invoked.")
+    created_at: Optional[StrictStr] = Field(default=None, description="When the approval policy was created.")
+    update_at: Optional[StrictStr] = Field(default=None, description="When the approval policy was updated last.")
+    approvers: Optional[ApproversUpdateRequest] = Field(default=None, description="The type of approve level and users who are allowed to approve/decline the approval review.")
+    rule_groups: Optional[Annotated[List[ApprovalPolicyRuleGroupUpdateRequest], Field(min_length=1, max_length=300)]] = Field(default=None, description="The groups of rules that are applicable for this approval policy. These will be chained using OR.")
+    __properties: ClassVar[List[str]] = ["object_type", "id", "source_type", "reference", "name", "status", "approval_type", "created_at", "update_at", "approvers", "rule_groups"]
+
+    @field_validator('source_type')
+    def source_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['QUOTE_VERSION', 'INVOICE', 'PRICING_PLAN_SCHEDULE']):
+            raise ValueError("must be one of enum values ('QUOTE_VERSION', 'INVOICE', 'PRICING_PLAN_SCHEDULE')")
+        return value
+
+    @field_validator('reference', mode="before")
+    def reference_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if isinstance(value, str) and not re.match(r"^\S+$", value):
+            raise ValueError(r"must validate the regular expression /^\S+$/")
+        return value
+
+    @field_validator('status')
+    def status_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['DRAFT', 'ACTIVE', 'DEPRECATED', 'ARCHIVED']):
+            raise ValueError("must be one of enum values ('DRAFT', 'ACTIVE', 'DEPRECATED', 'ARCHIVED')")
+        return value
+
+    @field_validator('approval_type')
+    def approval_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['GROUP', 'LEVEL']):
+            raise ValueError("must be one of enum values ('GROUP', 'LEVEL')")
+        return value
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ApprovalPolicyUpdateRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        """
+        excluded_fields: Set[str] = set([
+            "object_type",
+            "id",
+            "created_at",
+            "update_at",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of approvers
+        if self.approvers:
+            _dict['approvers'] = self.approvers.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in rule_groups (list)
+        _items = []
+        if self.rule_groups:
+            for _item_rule_groups in self.rule_groups:
+                _items.append(_item_rule_groups.to_dict() if _item_rule_groups is not None else None)
+            _dict['rule_groups'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ApprovalPolicyUpdateRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "object_type": obj.get("object_type"),
+            "id": obj.get("id"),
+            "source_type": obj.get("source_type"),
+            "reference": obj.get("reference"),
+            "name": obj.get("name"),
+            "status": obj.get("status"),
+            "approval_type": obj.get("approval_type"),
+            "created_at": obj.get("created_at"),
+            "update_at": obj.get("update_at"),
+            "approvers": ApproversUpdateRequest.from_dict(obj["approvers"]) if obj.get("approvers") is not None else None,
+            "rule_groups": [ApprovalPolicyRuleGroupUpdateRequest.from_dict(_item) for _item in obj["rule_groups"]] if obj.get("rule_groups") is not None else None
+        })
+        return _obj
+
+