leadping 1.0.0__py3-none-any.whl

leadping/models/user_response.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+import datetime
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .mobile_device_preferences import MobileDevicePreferences
+    from .user_identity import UserIdentity
+    from .user_response_billing_plan import UserResponse_billingPlan
+    from .user_response_business import UserResponse_business
+    from .user_response_compliance import UserResponse_compliance
+    from .user_response_current_business import UserResponse_currentBusiness
+    from .user_response_notification_preferences import UserResponse_notificationPreferences
+    from .user_response_stripe_info import UserResponse_stripeInfo
+    from .user_response_subscription_status import UserResponse_subscriptionStatus
+
+@dataclass
+class UserResponse(AdditionalDataHolder, Parsable):
+    """
+    API response containing user data returned to callers.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # Defines the supported Billing Plan values.
+    billing_plan: Optional[UserResponse_billingPlan] = None
+    # The business value for this user.
+    business: Optional[UserResponse_business] = None
+    # The compliance value for this user.
+    compliance: Optional[UserResponse_compliance] = None
+    # The date and time when the entity was created.
+    created_at: Optional[datetime.datetime] = None
+    # The current business value for this user.
+    current_business: Optional[UserResponse_currentBusiness] = None
+    # The email address associated with this user.
+    email: Optional[str] = None
+    # The first name value for this user.
+    first_name: Optional[str] = None
+    # The unique identifier for the entity.
+    id: Optional[str] = None
+    # The identities included with this user.
+    identities: Optional[list[UserIdentity]] = None
+    # The date and time when this user last completed the Leadping sign-in flow.
+    last_logged_in_at: Optional[datetime.datetime] = None
+    # The date and time for the last name value on this user.
+    last_name: Optional[str] = None
+    # The Leadping mobile device preferences for this user.
+    mobile_device_preferences: Optional[list[MobileDevicePreferences]] = None
+    # The date and time when the entity was last modified, if applicable.
+    modified_at: Optional[datetime.datetime] = None
+    # The display name for the entity.
+    name: Optional[str] = None
+    # The notification preferences value for this user.
+    notification_preferences: Optional[UserResponse_notificationPreferences] = None
+    # The date and time for the personal data deleted at value on this user.
+    personal_data_deleted_at: Optional[datetime.datetime] = None
+    # The human-readable personal data deletion reason explaining this user.
+    personal_data_deletion_reason: Optional[str] = None
+    # The date and time for the personal data deletion requested at value on this user.
+    personal_data_deletion_requested_at: Optional[datetime.datetime] = None
+    # The current personal data deletion status for this user.
+    personal_data_deletion_status: Optional[str] = None
+    # The phone number associated with this user.
+    phone: Optional[str] = None
+    # The Stripe info value for this user.
+    stripe_info: Optional[UserResponse_stripeInfo] = None
+    # Defines the supported Subscription Status values.
+    subscription_status: Optional[UserResponse_subscriptionStatus] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserResponse:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: UserResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .mobile_device_preferences import MobileDevicePreferences
+        from .user_identity import UserIdentity
+        from .user_response_billing_plan import UserResponse_billingPlan
+        from .user_response_business import UserResponse_business
+        from .user_response_compliance import UserResponse_compliance
+        from .user_response_current_business import UserResponse_currentBusiness
+        from .user_response_notification_preferences import UserResponse_notificationPreferences
+        from .user_response_stripe_info import UserResponse_stripeInfo
+        from .user_response_subscription_status import UserResponse_subscriptionStatus
+
+        from .mobile_device_preferences import MobileDevicePreferences
+        from .user_identity import UserIdentity
+        from .user_response_billing_plan import UserResponse_billingPlan
+        from .user_response_business import UserResponse_business
+        from .user_response_compliance import UserResponse_compliance
+        from .user_response_current_business import UserResponse_currentBusiness
+        from .user_response_notification_preferences import UserResponse_notificationPreferences
+        from .user_response_stripe_info import UserResponse_stripeInfo
+        from .user_response_subscription_status import UserResponse_subscriptionStatus
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "billingPlan": lambda n : setattr(self, 'billing_plan', n.get_enum_value(UserResponse_billingPlan)),
+            "business": lambda n : setattr(self, 'business', n.get_object_value(UserResponse_business)),
+            "compliance": lambda n : setattr(self, 'compliance', n.get_object_value(UserResponse_compliance)),
+            "createdAt": lambda n : setattr(self, 'created_at', n.get_datetime_value()),
+            "currentBusiness": lambda n : setattr(self, 'current_business', n.get_object_value(UserResponse_currentBusiness)),
+            "email": lambda n : setattr(self, 'email', n.get_str_value()),
+            "firstName": lambda n : setattr(self, 'first_name', n.get_str_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "identities": lambda n : setattr(self, 'identities', n.get_collection_of_object_values(UserIdentity)),
+            "lastLoggedInAt": lambda n : setattr(self, 'last_logged_in_at', n.get_datetime_value()),
+            "lastName": lambda n : setattr(self, 'last_name', n.get_str_value()),
+            "mobileDevicePreferences": lambda n : setattr(self, 'mobile_device_preferences', n.get_collection_of_object_values(MobileDevicePreferences)),
+            "modifiedAt": lambda n : setattr(self, 'modified_at', n.get_datetime_value()),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "notificationPreferences": lambda n : setattr(self, 'notification_preferences', n.get_object_value(UserResponse_notificationPreferences)),
+            "personalDataDeletedAt": lambda n : setattr(self, 'personal_data_deleted_at', n.get_datetime_value()),
+            "personalDataDeletionReason": lambda n : setattr(self, 'personal_data_deletion_reason', n.get_str_value()),
+            "personalDataDeletionRequestedAt": lambda n : setattr(self, 'personal_data_deletion_requested_at', n.get_datetime_value()),
+            "personalDataDeletionStatus": lambda n : setattr(self, 'personal_data_deletion_status', n.get_str_value()),
+            "phone": lambda n : setattr(self, 'phone', n.get_str_value()),
+            "stripeInfo": lambda n : setattr(self, 'stripe_info', n.get_object_value(UserResponse_stripeInfo)),
+            "subscriptionStatus": lambda n : setattr(self, 'subscription_status', n.get_enum_value(UserResponse_subscriptionStatus)),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_enum_value("billingPlan", self.billing_plan)
+        writer.write_object_value("business", self.business)
+        writer.write_object_value("compliance", self.compliance)
+        writer.write_datetime_value("createdAt", self.created_at)
+        writer.write_object_value("currentBusiness", self.current_business)
+        writer.write_str_value("email", self.email)
+        writer.write_str_value("firstName", self.first_name)
+        writer.write_str_value("id", self.id)
+        writer.write_collection_of_object_values("identities", self.identities)
+        writer.write_datetime_value("lastLoggedInAt", self.last_logged_in_at)
+        writer.write_str_value("lastName", self.last_name)
+        writer.write_collection_of_object_values("mobileDevicePreferences", self.mobile_device_preferences)
+        writer.write_datetime_value("modifiedAt", self.modified_at)
+        writer.write_str_value("name", self.name)
+        writer.write_object_value("notificationPreferences", self.notification_preferences)
+        writer.write_datetime_value("personalDataDeletedAt", self.personal_data_deleted_at)
+        writer.write_str_value("personalDataDeletionReason", self.personal_data_deletion_reason)
+        writer.write_datetime_value("personalDataDeletionRequestedAt", self.personal_data_deletion_requested_at)
+        writer.write_str_value("personalDataDeletionStatus", self.personal_data_deletion_status)
+        writer.write_str_value("phone", self.phone)
+        writer.write_object_value("stripeInfo", self.stripe_info)
+        writer.write_enum_value("subscriptionStatus", self.subscription_status)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/user_response_billing_plan.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+class UserResponse_billingPlan(str, Enum):
+    Annual = "Annual",
+    Monthly = "Monthly",
+

leadping/models/user_response_business.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .id_name_pair import IdNamePair
+
+from .id_name_pair import IdNamePair
+
+@dataclass
+class UserResponse_business(IdNamePair, Parsable):
+    """
+    The business value for this user.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserResponse_business:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: UserResponse_business
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserResponse_business()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .id_name_pair import IdNamePair
+
+        from .id_name_pair import IdNamePair
+
+        fields: dict[str, Callable[[Any], None]] = {
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+    
+

leadping/models/user_response_compliance.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .user_compliance import UserCompliance
+
+from .user_compliance import UserCompliance
+
+@dataclass
+class UserResponse_compliance(UserCompliance, Parsable):
+    """
+    The compliance value for this user.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserResponse_compliance:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: UserResponse_compliance
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserResponse_compliance()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .user_compliance import UserCompliance
+
+        from .user_compliance import UserCompliance
+
+        fields: dict[str, Callable[[Any], None]] = {
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+    
+

leadping/models/user_response_current_business.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .id_name_pair import IdNamePair
+
+from .id_name_pair import IdNamePair
+
+@dataclass
+class UserResponse_currentBusiness(IdNamePair, Parsable):
+    """
+    The current business value for this user.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserResponse_currentBusiness:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: UserResponse_currentBusiness
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserResponse_currentBusiness()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .id_name_pair import IdNamePair
+
+        from .id_name_pair import IdNamePair
+
+        fields: dict[str, Callable[[Any], None]] = {
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+    
+

leadping/models/user_response_notification_preferences.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .user_notification_preferences import UserNotificationPreferences
+
+from .user_notification_preferences import UserNotificationPreferences
+
+@dataclass
+class UserResponse_notificationPreferences(UserNotificationPreferences, Parsable):
+    """
+    The notification preferences value for this user.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserResponse_notificationPreferences:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: UserResponse_notificationPreferences
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserResponse_notificationPreferences()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .user_notification_preferences import UserNotificationPreferences
+
+        from .user_notification_preferences import UserNotificationPreferences
+
+        fields: dict[str, Callable[[Any], None]] = {
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+    
+

leadping/models/user_response_stripe_info.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .user_stripe_info import UserStripeInfo
+
+from .user_stripe_info import UserStripeInfo
+
+@dataclass
+class UserResponse_stripeInfo(UserStripeInfo, Parsable):
+    """
+    The Stripe info value for this user.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserResponse_stripeInfo:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: UserResponse_stripeInfo
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserResponse_stripeInfo()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .user_stripe_info import UserStripeInfo
+
+        from .user_stripe_info import UserStripeInfo
+
+        fields: dict[str, Callable[[Any], None]] = {
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+    
+

leadping/models/user_response_subscription_status.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class UserResponse_subscriptionStatus(str, Enum):
+    Pending = "Pending",
+    Active = "Active",
+    Overdue = "Overdue",
+    Canceled = "Canceled",
+

leadping/models/user_stripe_info.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+import datetime
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .user_stripe_info_cancellation import UserStripeInfo_cancellation
+    from .user_stripe_info_dunning import UserStripeInfo_dunning
+
+@dataclass
+class UserStripeInfo(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing user stripe info data used by Leadping API contracts.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # The business user subscription item ID associated with this user Stripe info.
+    business_user_subscription_item_id: Optional[str] = None
+    # The date and time for the cancel at value on this user Stripe info.
+    cancel_at: Optional[datetime.datetime] = None
+    # The captured subscription cancellation feedback for retention and churn analysis.
+    cancellation: Optional[UserStripeInfo_cancellation] = None
+    # The customer ID associated with this user Stripe info.
+    customer_id: Optional[str] = None
+    # The default payment method ID associated with this user Stripe info.
+    default_payment_method_id: Optional[str] = None
+    # The active dunning state after a failed recurring payment.
+    dunning: Optional[UserStripeInfo_dunning] = None
+    # The date and time for the last payment method event at value on this user Stripe info.
+    last_payment_method_event_at: Optional[datetime.datetime] = None
+    # The date and time for the last subscription event at value on this user Stripe info.
+    last_subscription_event_at: Optional[datetime.datetime] = None
+    # The phone subscription ID associated with this user Stripe info.
+    phone_subscription_id: Optional[str] = None
+    # The phone subscription item ID associated with this user Stripe info.
+    phone_subscription_item_id: Optional[str] = None
+    # The plan subscription ID associated with this user Stripe info.
+    plan_subscription_id: Optional[str] = None
+    # The plan subscription item ID associated with this user Stripe info.
+    plan_subscription_item_id: Optional[str] = None
+    # The subscription ids included with this user Stripe info.
+    subscription_ids: Optional[list[str]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserStripeInfo:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: UserStripeInfo
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserStripeInfo()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .user_stripe_info_cancellation import UserStripeInfo_cancellation
+        from .user_stripe_info_dunning import UserStripeInfo_dunning
+
+        from .user_stripe_info_cancellation import UserStripeInfo_cancellation
+        from .user_stripe_info_dunning import UserStripeInfo_dunning
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "businessUserSubscriptionItemId": lambda n : setattr(self, 'business_user_subscription_item_id', n.get_str_value()),
+            "cancelAt": lambda n : setattr(self, 'cancel_at', n.get_datetime_value()),
+            "cancellation": lambda n : setattr(self, 'cancellation', n.get_object_value(UserStripeInfo_cancellation)),
+            "customerId": lambda n : setattr(self, 'customer_id', n.get_str_value()),
+            "defaultPaymentMethodId": lambda n : setattr(self, 'default_payment_method_id', n.get_str_value()),
+            "dunning": lambda n : setattr(self, 'dunning', n.get_object_value(UserStripeInfo_dunning)),
+            "lastPaymentMethodEventAt": lambda n : setattr(self, 'last_payment_method_event_at', n.get_datetime_value()),
+            "lastSubscriptionEventAt": lambda n : setattr(self, 'last_subscription_event_at', n.get_datetime_value()),
+            "phoneSubscriptionId": lambda n : setattr(self, 'phone_subscription_id', n.get_str_value()),
+            "phoneSubscriptionItemId": lambda n : setattr(self, 'phone_subscription_item_id', n.get_str_value()),
+            "planSubscriptionId": lambda n : setattr(self, 'plan_subscription_id', n.get_str_value()),
+            "planSubscriptionItemId": lambda n : setattr(self, 'plan_subscription_item_id', n.get_str_value()),
+            "subscriptionIds": lambda n : setattr(self, 'subscription_ids', n.get_collection_of_primitive_values(str)),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("businessUserSubscriptionItemId", self.business_user_subscription_item_id)
+        writer.write_datetime_value("cancelAt", self.cancel_at)
+        writer.write_object_value("cancellation", self.cancellation)
+        writer.write_str_value("customerId", self.customer_id)
+        writer.write_str_value("defaultPaymentMethodId", self.default_payment_method_id)
+        writer.write_object_value("dunning", self.dunning)
+        writer.write_datetime_value("lastPaymentMethodEventAt", self.last_payment_method_event_at)
+        writer.write_datetime_value("lastSubscriptionEventAt", self.last_subscription_event_at)
+        writer.write_str_value("phoneSubscriptionId", self.phone_subscription_id)
+        writer.write_str_value("phoneSubscriptionItemId", self.phone_subscription_item_id)
+        writer.write_str_value("planSubscriptionId", self.plan_subscription_id)
+        writer.write_str_value("planSubscriptionItemId", self.plan_subscription_item_id)
+        writer.write_collection_of_primitive_values("subscriptionIds", self.subscription_ids)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/user_stripe_info_cancellation.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .user_subscription_cancellation_info import UserSubscriptionCancellationInfo
+
+from .user_subscription_cancellation_info import UserSubscriptionCancellationInfo
+
+@dataclass
+class UserStripeInfo_cancellation(UserSubscriptionCancellationInfo, Parsable):
+    """
+    The captured subscription cancellation feedback for retention and churn analysis.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserStripeInfo_cancellation:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: UserStripeInfo_cancellation
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserStripeInfo_cancellation()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .user_subscription_cancellation_info import UserSubscriptionCancellationInfo
+
+        from .user_subscription_cancellation_info import UserSubscriptionCancellationInfo
+
+        fields: dict[str, Callable[[Any], None]] = {
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+    
+