pingram-python 0.1.0__py3-none-any.whl

pingram/models/post_user_request.py

@@ -0,0 +1,121 @@
+# coding: utf-8
+
+"""
+    NotificationAPI
+
+    Internal API for notification delivery and management
+
+    The version of the OpenAPI document: 1.0.0
+    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
+from typing import Any, ClassVar, Dict, List, Optional
+from pingram.models.get_users_response_users_inner_push_tokens_inner import GetUsersResponseUsersInnerPushTokensInner
+from pingram.models.get_users_response_users_inner_slack_token import GetUsersResponseUsersInnerSlackToken
+from pingram.models.get_users_response_users_inner_web_push_tokens_inner import GetUsersResponseUsersInnerWebPushTokensInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class PostUserRequest(BaseModel):
+    """
+    PostUserRequest
+    """ # noqa: E501
+    id: Optional[StrictStr] = None
+    email: Optional[StrictStr] = None
+    number: Optional[StrictStr] = None
+    push_tokens: Optional[List[GetUsersResponseUsersInnerPushTokensInner]] = Field(default=None, alias="pushTokens")
+    web_push_tokens: Optional[List[GetUsersResponseUsersInnerWebPushTokensInner]] = Field(default=None, alias="webPushTokens")
+    timezone: Optional[StrictStr] = None
+    slack_channel: Optional[StrictStr] = Field(default=None, description="The destination channel of slack notifications sent to this user. Can be either of the following: - Channel name, e.g. \"test\" - Channel name with # prefix, e.g. \"#test\" - Channel ID, e.g. \"C1234567890\" - User ID for DM, e.g. \"U1234567890\" - Username with @ prefix, e.g. \"@test\"", alias="slackChannel")
+    slack_token: Optional[GetUsersResponseUsersInnerSlackToken] = Field(default=None, alias="slackToken")
+    __properties: ClassVar[List[str]] = ["id", "email", "number", "pushTokens", "webPushTokens", "timezone", "slackChannel", "slackToken"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of PostUserRequest 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 push_tokens (list)
+        _items = []
+        if self.push_tokens:
+            for _item_push_tokens in self.push_tokens:
+                if _item_push_tokens:
+                    _items.append(_item_push_tokens.to_dict())
+            _dict['pushTokens'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in web_push_tokens (list)
+        _items = []
+        if self.web_push_tokens:
+            for _item_web_push_tokens in self.web_push_tokens:
+                if _item_web_push_tokens:
+                    _items.append(_item_web_push_tokens.to_dict())
+            _dict['webPushTokens'] = _items
+        # override the default output from pydantic by calling `to_dict()` of slack_token
+        if self.slack_token:
+            _dict['slackToken'] = self.slack_token.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PostUserRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "email": obj.get("email"),
+            "number": obj.get("number"),
+            "pushTokens": [GetUsersResponseUsersInnerPushTokensInner.from_dict(_item) for _item in obj["pushTokens"]] if obj.get("pushTokens") is not None else None,
+            "webPushTokens": [GetUsersResponseUsersInnerWebPushTokensInner.from_dict(_item) for _item in obj["webPushTokens"]] if obj.get("webPushTokens") is not None else None,
+            "timezone": obj.get("timezone"),
+            "slackChannel": obj.get("slackChannel"),
+            "slackToken": GetUsersResponseUsersInnerSlackToken.from_dict(obj["slackToken"]) if obj.get("slackToken") is not None else None
+        })
+        return _obj
+
+

pingram/models/sender_post_body.py

@@ -0,0 +1,166 @@
+# coding: utf-8
+
+"""
+    NotificationAPI
+
+    Internal API for notification delivery and management
+
+    The version of the OpenAPI document: 1.0.0
+    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
+from typing import Any, ClassVar, Dict, List, Optional
+from pingram.models.channels_enum import ChannelsEnum
+from pingram.models.sender_post_body_email import SenderPostBodyEmail
+from pingram.models.sender_post_body_inapp import SenderPostBodyInapp
+from pingram.models.sender_post_body_mobile_push import SenderPostBodyMobilePush
+from pingram.models.sender_post_body_options import SenderPostBodyOptions
+from pingram.models.sender_post_body_slack import SenderPostBodySlack
+from pingram.models.sender_post_body_sms import SenderPostBodySms
+from pingram.models.sender_post_body_sms_auto_reply import SenderPostBodySmsAutoReply
+from pingram.models.sender_post_body_to import SenderPostBodyTo
+from pingram.models.sender_post_body_user import SenderPostBodyUser
+from pingram.models.sender_post_body_web_push import SenderPostBodyWebPush
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SenderPostBody(BaseModel):
+    """
+    SenderPostBody
+    """ # noqa: E501
+    notification_id: Optional[StrictStr] = Field(default=None, alias="notificationId")
+    user: Optional[SenderPostBodyUser] = None
+    merge_tags: Optional[Dict[str, Any]] = Field(default=None, alias="mergeTags")
+    replace: Optional[Dict[str, StrictStr]] = None
+    type: Optional[StrictStr] = None
+    to: Optional[SenderPostBodyTo] = None
+    force_channels: Optional[List[ChannelsEnum]] = Field(default=None, alias="forceChannels")
+    parameters: Optional[Dict[str, Any]] = None
+    secondary_id: Optional[StrictStr] = Field(default=None, alias="secondaryId")
+    template_id: Optional[StrictStr] = Field(default=None, alias="templateId")
+    sub_notification_id: Optional[StrictStr] = Field(default=None, alias="subNotificationId")
+    options: Optional[SenderPostBodyOptions] = None
+    schedule: Optional[StrictStr] = None
+    email: Optional[SenderPostBodyEmail] = None
+    inapp: Optional[SenderPostBodyInapp] = None
+    sms: Optional[SenderPostBodySms] = None
+    call: Optional[SenderPostBodySmsAutoReply] = None
+    web_push: Optional[SenderPostBodyWebPush] = None
+    mobile_push: Optional[SenderPostBodyMobilePush] = None
+    slack: Optional[SenderPostBodySlack] = None
+    __properties: ClassVar[List[str]] = ["notificationId", "user", "mergeTags", "replace", "type", "to", "forceChannels", "parameters", "secondaryId", "templateId", "subNotificationId", "options", "schedule", "email", "inapp", "sms", "call", "web_push", "mobile_push", "slack"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SenderPostBody 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 user
+        if self.user:
+            _dict['user'] = self.user.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of to
+        if self.to:
+            _dict['to'] = self.to.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of options
+        if self.options:
+            _dict['options'] = self.options.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of email
+        if self.email:
+            _dict['email'] = self.email.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of inapp
+        if self.inapp:
+            _dict['inapp'] = self.inapp.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of sms
+        if self.sms:
+            _dict['sms'] = self.sms.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of call
+        if self.call:
+            _dict['call'] = self.call.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of web_push
+        if self.web_push:
+            _dict['web_push'] = self.web_push.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of mobile_push
+        if self.mobile_push:
+            _dict['mobile_push'] = self.mobile_push.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of slack
+        if self.slack:
+            _dict['slack'] = self.slack.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SenderPostBody from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "notificationId": obj.get("notificationId"),
+            "user": SenderPostBodyUser.from_dict(obj["user"]) if obj.get("user") is not None else None,
+            "mergeTags": obj.get("mergeTags"),
+            "replace": obj.get("replace"),
+            "type": obj.get("type"),
+            "to": SenderPostBodyTo.from_dict(obj["to"]) if obj.get("to") is not None else None,
+            "forceChannels": obj.get("forceChannels"),
+            "parameters": obj.get("parameters"),
+            "secondaryId": obj.get("secondaryId"),
+            "templateId": obj.get("templateId"),
+            "subNotificationId": obj.get("subNotificationId"),
+            "options": SenderPostBodyOptions.from_dict(obj["options"]) if obj.get("options") is not None else None,
+            "schedule": obj.get("schedule"),
+            "email": SenderPostBodyEmail.from_dict(obj["email"]) if obj.get("email") is not None else None,
+            "inapp": SenderPostBodyInapp.from_dict(obj["inapp"]) if obj.get("inapp") is not None else None,
+            "sms": SenderPostBodySms.from_dict(obj["sms"]) if obj.get("sms") is not None else None,
+            "call": SenderPostBodySmsAutoReply.from_dict(obj["call"]) if obj.get("call") is not None else None,
+            "web_push": SenderPostBodyWebPush.from_dict(obj["web_push"]) if obj.get("web_push") is not None else None,
+            "mobile_push": SenderPostBodyMobilePush.from_dict(obj["mobile_push"]) if obj.get("mobile_push") is not None else None,
+            "slack": SenderPostBodySlack.from_dict(obj["slack"]) if obj.get("slack") is not None else None
+        })
+        return _obj
+
+

pingram/models/sender_post_body_email.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    NotificationAPI
+
+    Internal API for notification delivery and management
+
+    The version of the OpenAPI document: 1.0.0
+    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
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SenderPostBodyEmail(BaseModel):
+    """
+    SenderPostBodyEmail
+    """ # noqa: E501
+    subject: StrictStr
+    html: StrictStr
+    preview_text: Optional[StrictStr] = Field(default=None, alias="previewText")
+    sender_name: Optional[StrictStr] = Field(default=None, alias="senderName")
+    sender_email: Optional[StrictStr] = Field(default=None, alias="senderEmail")
+    __properties: ClassVar[List[str]] = ["subject", "html", "previewText", "senderName", "senderEmail"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SenderPostBodyEmail 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SenderPostBodyEmail from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "subject": obj.get("subject"),
+            "html": obj.get("html"),
+            "previewText": obj.get("previewText"),
+            "senderName": obj.get("senderName"),
+            "senderEmail": obj.get("senderEmail")
+        })
+        return _obj
+
+

pingram/models/sender_post_body_inapp.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    NotificationAPI
+
+    Internal API for notification delivery and management
+
+    The version of the OpenAPI document: 1.0.0
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SenderPostBodyInapp(BaseModel):
+    """
+    SenderPostBodyInapp
+    """ # noqa: E501
+    title: StrictStr
+    url: Optional[StrictStr] = None
+    image: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["title", "url", "image"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SenderPostBodyInapp 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SenderPostBodyInapp from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "title": obj.get("title"),
+            "url": obj.get("url"),
+            "image": obj.get("image")
+        })
+        return _obj
+
+

pingram/models/sender_post_body_mobile_push.py

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+    NotificationAPI
+
+    Internal API for notification delivery and management
+
+    The version of the OpenAPI document: 1.0.0
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SenderPostBodyMobilePush(BaseModel):
+    """
+    SenderPostBodyMobilePush
+    """ # noqa: E501
+    title: StrictStr
+    message: StrictStr
+    __properties: ClassVar[List[str]] = ["title", "message"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SenderPostBodyMobilePush 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SenderPostBodyMobilePush from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "title": obj.get("title"),
+            "message": obj.get("message")
+        })
+        return _obj
+
+

pingram/models/sender_post_body_options.py

@@ -0,0 +1,103 @@
+# coding: utf-8
+
+"""
+    NotificationAPI
+
+    Internal API for notification delivery and management
+
+    The version of the OpenAPI document: 1.0.0
+    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
+from typing import Any, ClassVar, Dict, List, Optional
+from pingram.models.sender_post_body_options_apn import SenderPostBodyOptionsApn
+from pingram.models.sender_post_body_options_email import SenderPostBodyOptionsEmail
+from pingram.models.sender_post_body_options_fcm import SenderPostBodyOptionsFcm
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SenderPostBodyOptions(BaseModel):
+    """
+    SenderPostBodyOptions
+    """ # noqa: E501
+    email: Optional[SenderPostBodyOptionsEmail] = None
+    apn: Optional[SenderPostBodyOptionsApn] = None
+    fcm: Optional[SenderPostBodyOptionsFcm] = None
+    __properties: ClassVar[List[str]] = ["email", "apn", "fcm"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SenderPostBodyOptions 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 email
+        if self.email:
+            _dict['email'] = self.email.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of apn
+        if self.apn:
+            _dict['apn'] = self.apn.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of fcm
+        if self.fcm:
+            _dict['fcm'] = self.fcm.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SenderPostBodyOptions from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "email": SenderPostBodyOptionsEmail.from_dict(obj["email"]) if obj.get("email") is not None else None,
+            "apn": SenderPostBodyOptionsApn.from_dict(obj["apn"]) if obj.get("apn") is not None else None,
+            "fcm": SenderPostBodyOptionsFcm.from_dict(obj["fcm"]) if obj.get("fcm") is not None else None
+        })
+        return _obj
+
+