spatialflow 0.1.0__py3-none-any.whl

spatialflow/_generated/spatialflow_generated/models/user_profile_response.py

@@ -0,0 +1,158 @@
+# coding: utf-8
+
+"""
+    SpatialFlow API
+
+    Real-time geospatial automation platform API.  ## Authentication  **API Key:** Include `X-API-Key` header **JWT Token:** Include `Authorization: Bearer <token>` header  ## Rate Limits  - Per API Key: 200 rps sustained, 1,000 rps burst - Per Organization: 1,000 rps aggregate  ## Webhook Verification  Outbound webhooks include HMAC-SHA256 signatures in `X-SF-Signature` header.  ## Support  - Documentation: https://docs.spatialflow.io - GitHub: https://github.com/spatialflow/spatialflow - Email: support@spatialflow.io     
+
+    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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UserProfileResponse(BaseModel):
+    """
+    User profile response schema.
+    """ # noqa: E501
+    id: StrictStr
+    email: StrictStr
+    name: StrictStr
+    role: StrictStr
+    is_staff: Optional[StrictBool] = False
+    is_superuser: Optional[StrictBool] = False
+    email_verified: StrictBool
+    created_at: datetime
+    updated_at: datetime
+    bio: Optional[StrictStr] = None
+    avatar_url: Optional[StrictStr] = None
+    phone_number: Optional[StrictStr] = None
+    timezone: Optional[StrictStr] = 'UTC'
+    date_format: Optional[StrictStr] = 'YYYY-MM-DD'
+    time_format: Optional[StrictStr] = '24h'
+    email_notifications: Optional[StrictBool] = True
+    webhook_failure_notifications: Optional[StrictBool] = True
+    workflow_failure_notifications: Optional[StrictBool] = True
+    usage_alert_notifications: Optional[StrictBool] = True
+    marketing_emails: Optional[StrictBool] = False
+    default_map_style: Optional[StrictStr] = 'streets'
+    default_geofence_color: Optional[StrictStr] = '#3B82F6'
+    show_tutorial_tooltips: Optional[StrictBool] = True
+    default_api_version: Optional[StrictStr] = 'v1'
+    selected_plan: Optional[StrictStr] = 'free'
+    company: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["id", "email", "name", "role", "is_staff", "is_superuser", "email_verified", "created_at", "updated_at", "bio", "avatar_url", "phone_number", "timezone", "date_format", "time_format", "email_notifications", "webhook_failure_notifications", "workflow_failure_notifications", "usage_alert_notifications", "marketing_emails", "default_map_style", "default_geofence_color", "show_tutorial_tooltips", "default_api_version", "selected_plan", "company"]
+
+    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 UserProfileResponse 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,
+        )
+        # set to None if bio (nullable) is None
+        # and model_fields_set contains the field
+        if self.bio is None and "bio" in self.model_fields_set:
+            _dict['bio'] = None
+
+        # set to None if avatar_url (nullable) is None
+        # and model_fields_set contains the field
+        if self.avatar_url is None and "avatar_url" in self.model_fields_set:
+            _dict['avatar_url'] = None
+
+        # set to None if phone_number (nullable) is None
+        # and model_fields_set contains the field
+        if self.phone_number is None and "phone_number" in self.model_fields_set:
+            _dict['phone_number'] = None
+
+        # set to None if company (nullable) is None
+        # and model_fields_set contains the field
+        if self.company is None and "company" in self.model_fields_set:
+            _dict['company'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UserProfileResponse 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"),
+            "name": obj.get("name"),
+            "role": obj.get("role"),
+            "is_staff": obj.get("is_staff") if obj.get("is_staff") is not None else False,
+            "is_superuser": obj.get("is_superuser") if obj.get("is_superuser") is not None else False,
+            "email_verified": obj.get("email_verified"),
+            "created_at": obj.get("created_at"),
+            "updated_at": obj.get("updated_at"),
+            "bio": obj.get("bio"),
+            "avatar_url": obj.get("avatar_url"),
+            "phone_number": obj.get("phone_number"),
+            "timezone": obj.get("timezone") if obj.get("timezone") is not None else 'UTC',
+            "date_format": obj.get("date_format") if obj.get("date_format") is not None else 'YYYY-MM-DD',
+            "time_format": obj.get("time_format") if obj.get("time_format") is not None else '24h',
+            "email_notifications": obj.get("email_notifications") if obj.get("email_notifications") is not None else True,
+            "webhook_failure_notifications": obj.get("webhook_failure_notifications") if obj.get("webhook_failure_notifications") is not None else True,
+            "workflow_failure_notifications": obj.get("workflow_failure_notifications") if obj.get("workflow_failure_notifications") is not None else True,
+            "usage_alert_notifications": obj.get("usage_alert_notifications") if obj.get("usage_alert_notifications") is not None else True,
+            "marketing_emails": obj.get("marketing_emails") if obj.get("marketing_emails") is not None else False,
+            "default_map_style": obj.get("default_map_style") if obj.get("default_map_style") is not None else 'streets',
+            "default_geofence_color": obj.get("default_geofence_color") if obj.get("default_geofence_color") is not None else '#3B82F6',
+            "show_tutorial_tooltips": obj.get("show_tutorial_tooltips") if obj.get("show_tutorial_tooltips") is not None else True,
+            "default_api_version": obj.get("default_api_version") if obj.get("default_api_version") is not None else 'v1',
+            "selected_plan": obj.get("selected_plan") if obj.get("selected_plan") is not None else 'free',
+            "company": obj.get("company")
+        })
+        return _obj
+
+

spatialflow/_generated/spatialflow_generated/models/user_rejection_request.py

@@ -0,0 +1,87 @@
+# coding: utf-8
+
+"""
+    SpatialFlow API
+
+    Real-time geospatial automation platform API.  ## Authentication  **API Key:** Include `X-API-Key` header **JWT Token:** Include `Authorization: Bearer <token>` header  ## Rate Limits  - Per API Key: 200 rps sustained, 1,000 rps burst - Per Organization: 1,000 rps aggregate  ## Webhook Verification  Outbound webhooks include HMAC-SHA256 signatures in `X-SF-Signature` header.  ## Support  - Documentation: https://docs.spatialflow.io - GitHub: https://github.com/spatialflow/spatialflow - Email: support@spatialflow.io     
+
+    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 UserRejectionRequest(BaseModel):
+    """
+    Request schema for rejecting a pending user.
+    """ # noqa: E501
+    reason: StrictStr
+    __properties: ClassVar[List[str]] = ["reason"]
+
+    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 UserRejectionRequest 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 UserRejectionRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "reason": obj.get("reason")
+        })
+        return _obj
+
+

spatialflow/_generated/spatialflow_generated/models/user_response.py

@@ -0,0 +1,142 @@
+# coding: utf-8
+
+"""
+    SpatialFlow API
+
+    Real-time geospatial automation platform API.  ## Authentication  **API Key:** Include `X-API-Key` header **JWT Token:** Include `Authorization: Bearer <token>` header  ## Rate Limits  - Per API Key: 200 rps sustained, 1,000 rps burst - Per Organization: 1,000 rps aggregate  ## Webhook Verification  Outbound webhooks include HMAC-SHA256 signatures in `X-SF-Signature` header.  ## Support  - Documentation: https://docs.spatialflow.io - GitHub: https://github.com/spatialflow/spatialflow - Email: support@spatialflow.io     
+
+    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, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UserResponse(BaseModel):
+    """
+    UserResponse
+    """ # noqa: E501
+    id: StrictStr
+    email: StrictStr
+    name: StrictStr
+    role: StrictStr
+    email_verified: StrictBool = Field(alias="emailVerified")
+    selected_plan: StrictStr
+    company: Optional[StrictStr]
+    language_preference: StrictStr = Field(alias="languagePreference")
+    created_at: StrictStr = Field(alias="createdAt")
+    updated_at: StrictStr = Field(alias="updatedAt")
+    is_superuser: StrictBool
+    is_staff: StrictBool
+    roles: Optional[List[StrictStr]]
+    is_beta_user: Optional[StrictBool] = None
+    admin_approved: Optional[StrictBool] = None
+    admin_approved_at: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["id", "email", "name", "role", "emailVerified", "selected_plan", "company", "languagePreference", "createdAt", "updatedAt", "is_superuser", "is_staff", "roles", "is_beta_user", "admin_approved", "admin_approved_at"]
+
+    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 UserResponse 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,
+        )
+        # set to None if company (nullable) is None
+        # and model_fields_set contains the field
+        if self.company is None and "company" in self.model_fields_set:
+            _dict['company'] = None
+
+        # set to None if roles (nullable) is None
+        # and model_fields_set contains the field
+        if self.roles is None and "roles" in self.model_fields_set:
+            _dict['roles'] = None
+
+        # set to None if is_beta_user (nullable) is None
+        # and model_fields_set contains the field
+        if self.is_beta_user is None and "is_beta_user" in self.model_fields_set:
+            _dict['is_beta_user'] = None
+
+        # set to None if admin_approved (nullable) is None
+        # and model_fields_set contains the field
+        if self.admin_approved is None and "admin_approved" in self.model_fields_set:
+            _dict['admin_approved'] = None
+
+        # set to None if admin_approved_at (nullable) is None
+        # and model_fields_set contains the field
+        if self.admin_approved_at is None and "admin_approved_at" in self.model_fields_set:
+            _dict['admin_approved_at'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UserResponse 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"),
+            "name": obj.get("name"),
+            "role": obj.get("role"),
+            "emailVerified": obj.get("emailVerified"),
+            "selected_plan": obj.get("selected_plan"),
+            "company": obj.get("company"),
+            "languagePreference": obj.get("languagePreference"),
+            "createdAt": obj.get("createdAt"),
+            "updatedAt": obj.get("updatedAt"),
+            "is_superuser": obj.get("is_superuser"),
+            "is_staff": obj.get("is_staff"),
+            "roles": obj.get("roles"),
+            "is_beta_user": obj.get("is_beta_user"),
+            "admin_approved": obj.get("admin_approved"),
+            "admin_approved_at": obj.get("admin_approved_at")
+        })
+        return _obj
+
+

spatialflow/_generated/spatialflow_generated/models/user_summary.py

@@ -0,0 +1,140 @@
+# coding: utf-8
+
+"""
+    SpatialFlow API
+
+    Real-time geospatial automation platform API.  ## Authentication  **API Key:** Include `X-API-Key` header **JWT Token:** Include `Authorization: Bearer <token>` header  ## Rate Limits  - Per API Key: 200 rps sustained, 1,000 rps burst - Per Organization: 1,000 rps aggregate  ## Webhook Verification  Outbound webhooks include HMAC-SHA256 signatures in `X-SF-Signature` header.  ## Support  - Documentation: https://docs.spatialflow.io - GitHub: https://github.com/spatialflow/spatialflow - Email: support@spatialflow.io     
+
+    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, StrictBool, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from .workspace_summary import WorkspaceSummary
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UserSummary(BaseModel):
+    """
+    UserSummary
+    """ # noqa: E501
+    id: StrictStr
+    email: StrictStr
+    name: Optional[StrictStr]
+    role: StrictStr
+    email_verified: StrictBool
+    is_beta_user: Optional[StrictBool] = False
+    admin_approved: Optional[StrictBool] = False
+    admin_approved_at: Optional[StrictStr] = None
+    created_at: Optional[StrictStr]
+    last_login: Optional[StrictStr]
+    subscription_tier: Optional[StrictStr] = 'free'
+    api_keys_count: StrictInt
+    workspace: Optional[WorkspaceSummary] = None
+    __properties: ClassVar[List[str]] = ["id", "email", "name", "role", "email_verified", "is_beta_user", "admin_approved", "admin_approved_at", "created_at", "last_login", "subscription_tier", "api_keys_count", "workspace"]
+
+    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 UserSummary 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 workspace
+        if self.workspace:
+            _dict['workspace'] = self.workspace.to_dict()
+        # set to None if name (nullable) is None
+        # and model_fields_set contains the field
+        if self.name is None and "name" in self.model_fields_set:
+            _dict['name'] = None
+
+        # set to None if admin_approved_at (nullable) is None
+        # and model_fields_set contains the field
+        if self.admin_approved_at is None and "admin_approved_at" in self.model_fields_set:
+            _dict['admin_approved_at'] = None
+
+        # set to None if created_at (nullable) is None
+        # and model_fields_set contains the field
+        if self.created_at is None and "created_at" in self.model_fields_set:
+            _dict['created_at'] = None
+
+        # set to None if last_login (nullable) is None
+        # and model_fields_set contains the field
+        if self.last_login is None and "last_login" in self.model_fields_set:
+            _dict['last_login'] = None
+
+        # set to None if workspace (nullable) is None
+        # and model_fields_set contains the field
+        if self.workspace is None and "workspace" in self.model_fields_set:
+            _dict['workspace'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UserSummary 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"),
+            "name": obj.get("name"),
+            "role": obj.get("role"),
+            "email_verified": obj.get("email_verified"),
+            "is_beta_user": obj.get("is_beta_user") if obj.get("is_beta_user") is not None else False,
+            "admin_approved": obj.get("admin_approved") if obj.get("admin_approved") is not None else False,
+            "admin_approved_at": obj.get("admin_approved_at"),
+            "created_at": obj.get("created_at"),
+            "last_login": obj.get("last_login"),
+            "subscription_tier": obj.get("subscription_tier") if obj.get("subscription_tier") is not None else 'free',
+            "api_keys_count": obj.get("api_keys_count"),
+            "workspace": WorkspaceSummary.from_dict(obj["workspace"]) if obj.get("workspace") is not None else None
+        })
+        return _obj
+
+

spatialflow/_generated/spatialflow_generated/models/user_usage_response.py

@@ -0,0 +1,152 @@
+# coding: utf-8
+
+"""
+    SpatialFlow API
+
+    Real-time geospatial automation platform API.  ## Authentication  **API Key:** Include `X-API-Key` header **JWT Token:** Include `Authorization: Bearer <token>` header  ## Rate Limits  - Per API Key: 200 rps sustained, 1,000 rps burst - Per Organization: 1,000 rps aggregate  ## Webhook Verification  Outbound webhooks include HMAC-SHA256 signatures in `X-SF-Signature` header.  ## Support  - Documentation: https://docs.spatialflow.io - GitHub: https://github.com/spatialflow/spatialflow - Email: support@spatialflow.io     
+
+    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 .activity_summary import ActivitySummary
+from .api_usage_stats import APIUsageStats
+from .email_stats import EmailStats
+from .geofence_stats import GeofenceStats
+from .recent_activity import RecentActivity
+from .workspace_detail import WorkspaceDetail
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UserUsageResponse(BaseModel):
+    """
+    UserUsageResponse
+    """ # noqa: E501
+    user_id: StrictStr
+    email: StrictStr
+    workspace: Optional[WorkspaceDetail] = None
+    api_usage: APIUsageStats
+    email_stats: EmailStats
+    geofence_stats: GeofenceStats
+    activity_summary: List[ActivitySummary]
+    recent_activities: List[RecentActivity]
+    account_created: Optional[StrictStr]
+    last_login: Optional[StrictStr]
+    __properties: ClassVar[List[str]] = ["user_id", "email", "workspace", "api_usage", "email_stats", "geofence_stats", "activity_summary", "recent_activities", "account_created", "last_login"]
+
+    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 UserUsageResponse 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 workspace
+        if self.workspace:
+            _dict['workspace'] = self.workspace.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of api_usage
+        if self.api_usage:
+            _dict['api_usage'] = self.api_usage.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of email_stats
+        if self.email_stats:
+            _dict['email_stats'] = self.email_stats.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of geofence_stats
+        if self.geofence_stats:
+            _dict['geofence_stats'] = self.geofence_stats.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in activity_summary (list)
+        _items = []
+        if self.activity_summary:
+            for _item_activity_summary in self.activity_summary:
+                if _item_activity_summary:
+                    _items.append(_item_activity_summary.to_dict())
+            _dict['activity_summary'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in recent_activities (list)
+        _items = []
+        if self.recent_activities:
+            for _item_recent_activities in self.recent_activities:
+                if _item_recent_activities:
+                    _items.append(_item_recent_activities.to_dict())
+            _dict['recent_activities'] = _items
+        # set to None if workspace (nullable) is None
+        # and model_fields_set contains the field
+        if self.workspace is None and "workspace" in self.model_fields_set:
+            _dict['workspace'] = None
+
+        # set to None if account_created (nullable) is None
+        # and model_fields_set contains the field
+        if self.account_created is None and "account_created" in self.model_fields_set:
+            _dict['account_created'] = None
+
+        # set to None if last_login (nullable) is None
+        # and model_fields_set contains the field
+        if self.last_login is None and "last_login" in self.model_fields_set:
+            _dict['last_login'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UserUsageResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "user_id": obj.get("user_id"),
+            "email": obj.get("email"),
+            "workspace": WorkspaceDetail.from_dict(obj["workspace"]) if obj.get("workspace") is not None else None,
+            "api_usage": APIUsageStats.from_dict(obj["api_usage"]) if obj.get("api_usage") is not None else None,
+            "email_stats": EmailStats.from_dict(obj["email_stats"]) if obj.get("email_stats") is not None else None,
+            "geofence_stats": GeofenceStats.from_dict(obj["geofence_stats"]) if obj.get("geofence_stats") is not None else None,
+            "activity_summary": [ActivitySummary.from_dict(_item) for _item in obj["activity_summary"]] if obj.get("activity_summary") is not None else None,
+            "recent_activities": [RecentActivity.from_dict(_item) for _item in obj["recent_activities"]] if obj.get("recent_activities") is not None else None,
+            "account_created": obj.get("account_created"),
+            "last_login": obj.get("last_login")
+        })
+        return _obj
+
+