leadping 1.0.0__py3-none-any.whl

leadping/models/user_dunning_info.py

@@ -0,0 +1,91 @@
+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
+
+@dataclass
+class UserDunningInfo(AdditionalDataHolder, Parsable):
+    """
+    Dunning state recorded after a failed recurring payment.
+    """
+    # 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 finalCancellationAt property
+    final_cancellation_at: Optional[datetime.datetime] = None
+    # The gracePeriodEndsAt property
+    grace_period_ends_at: Optional[datetime.datetime] = None
+    # The lastFailedInvoiceId property
+    last_failed_invoice_id: Optional[str] = None
+    # The lastFailedInvoiceStatus property
+    last_failed_invoice_status: Optional[str] = None
+    # The lastUpdatedAt property
+    last_updated_at: Optional[datetime.datetime] = None
+    # The nextRetryAt property
+    next_retry_at: Optional[datetime.datetime] = None
+    # The outboundRestrictedAt property
+    outbound_restricted_at: Optional[datetime.datetime] = None
+    # The outboundSuspendedAt property
+    outbound_suspended_at: Optional[datetime.datetime] = None
+    # The paymentFailedAt property
+    payment_failed_at: Optional[datetime.datetime] = None
+    # The retryAttemptCount property
+    retry_attempt_count: Optional[int] = None
+    # The stage property
+    stage: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserDunningInfo:
+        """
+        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: UserDunningInfo
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserDunningInfo()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        fields: dict[str, Callable[[Any], None]] = {
+            "finalCancellationAt": lambda n : setattr(self, 'final_cancellation_at', n.get_datetime_value()),
+            "gracePeriodEndsAt": lambda n : setattr(self, 'grace_period_ends_at', n.get_datetime_value()),
+            "lastFailedInvoiceId": lambda n : setattr(self, 'last_failed_invoice_id', n.get_str_value()),
+            "lastFailedInvoiceStatus": lambda n : setattr(self, 'last_failed_invoice_status', n.get_str_value()),
+            "lastUpdatedAt": lambda n : setattr(self, 'last_updated_at', n.get_datetime_value()),
+            "nextRetryAt": lambda n : setattr(self, 'next_retry_at', n.get_datetime_value()),
+            "outboundRestrictedAt": lambda n : setattr(self, 'outbound_restricted_at', n.get_datetime_value()),
+            "outboundSuspendedAt": lambda n : setattr(self, 'outbound_suspended_at', n.get_datetime_value()),
+            "paymentFailedAt": lambda n : setattr(self, 'payment_failed_at', n.get_datetime_value()),
+            "retryAttemptCount": lambda n : setattr(self, 'retry_attempt_count', n.get_int_value()),
+            "stage": lambda n : setattr(self, 'stage', n.get_str_value()),
+        }
+        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_datetime_value("finalCancellationAt", self.final_cancellation_at)
+        writer.write_datetime_value("gracePeriodEndsAt", self.grace_period_ends_at)
+        writer.write_str_value("lastFailedInvoiceId", self.last_failed_invoice_id)
+        writer.write_str_value("lastFailedInvoiceStatus", self.last_failed_invoice_status)
+        writer.write_datetime_value("lastUpdatedAt", self.last_updated_at)
+        writer.write_datetime_value("nextRetryAt", self.next_retry_at)
+        writer.write_datetime_value("outboundRestrictedAt", self.outbound_restricted_at)
+        writer.write_datetime_value("outboundSuspendedAt", self.outbound_suspended_at)
+        writer.write_datetime_value("paymentFailedAt", self.payment_failed_at)
+        writer.write_int_value("retryAttemptCount", self.retry_attempt_count)
+        writer.write_str_value("stage", self.stage)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/user_identity.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+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
+
+@dataclass
+class UserIdentity(AdditionalDataHolder, Parsable):
+    """
+    Represents a user's sign-in identity, including information about the identity provider and method of authentication.
+    """
+    # 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)
+
+    # Gets or sets the identity provider that issued the sign-in identity (e.g., "contoso.com" or "facebook.com").
+    issuer: Optional[str] = None
+    # Gets or sets the unique identifier assigned to the user by the identity provider.
+    issuer_assigned_id: Optional[str] = None
+    # Gets or sets the method of sign-in used by the identity (e.g., "emailAddress", "userName", or "federated").
+    sign_in_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserIdentity:
+        """
+        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: UserIdentity
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserIdentity()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        fields: dict[str, Callable[[Any], None]] = {
+            "issuer": lambda n : setattr(self, 'issuer', n.get_str_value()),
+            "issuerAssignedId": lambda n : setattr(self, 'issuer_assigned_id', n.get_str_value()),
+            "signInType": lambda n : setattr(self, 'sign_in_type', n.get_str_value()),
+        }
+        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("issuer", self.issuer)
+        writer.write_str_value("issuerAssignedId", self.issuer_assigned_id)
+        writer.write_str_value("signInType", self.sign_in_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/user_notification_preferences.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+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
+
+@dataclass
+class UserNotificationPreferences(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing user notification preferences 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)
+
+    # Whether automation failed notifications are enabled for this user notification preferences.
+    automation_failed_enabled: Optional[bool] = None
+    # Whether billing email is enabled for this user notification preferences.
+    billing_email_enabled: Optional[bool] = None
+    # Whether billing SMS is enabled for this user notification preferences.
+    billing_sms_enabled: Optional[bool] = None
+    # Whether low wallet balance notifications are enabled for this user notification preferences.
+    low_wallet_balance_enabled: Optional[bool] = None
+    # Whether missed call notifications are enabled for this user notification preferences.
+    missed_call_enabled: Optional[bool] = None
+    # Whether new lead email is enabled for this user notification preferences.
+    new_lead_email_enabled: Optional[bool] = None
+    # Whether new lead notifications are enabled for this user notification preferences.
+    new_lead_enabled: Optional[bool] = None
+    # Whether new lead SMS is enabled for this user notification preferences.
+    new_lead_sms_enabled: Optional[bool] = None
+    # Whether payment failed notifications are enabled for this user notification preferences.
+    payment_failed_enabled: Optional[bool] = None
+    # Whether subscription renewing notifications are enabled for this user notification preferences.
+    subscription_renewing_enabled: Optional[bool] = None
+    # Whether 10DLC status notifications are enabled for this user notification preferences.
+    ten_dlc_status_enabled: Optional[bool] = None
+    # Whether unread SMS notifications are enabled for this user notification preferences.
+    unread_sms_enabled: Optional[bool] = None
+    # Whether usage limit hit notifications are enabled for this user notification preferences.
+    usage_limit_hit_enabled: Optional[bool] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserNotificationPreferences:
+        """
+        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: UserNotificationPreferences
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserNotificationPreferences()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        fields: dict[str, Callable[[Any], None]] = {
+            "automationFailedEnabled": lambda n : setattr(self, 'automation_failed_enabled', n.get_bool_value()),
+            "billingEmailEnabled": lambda n : setattr(self, 'billing_email_enabled', n.get_bool_value()),
+            "billingSmsEnabled": lambda n : setattr(self, 'billing_sms_enabled', n.get_bool_value()),
+            "lowWalletBalanceEnabled": lambda n : setattr(self, 'low_wallet_balance_enabled', n.get_bool_value()),
+            "missedCallEnabled": lambda n : setattr(self, 'missed_call_enabled', n.get_bool_value()),
+            "newLeadEmailEnabled": lambda n : setattr(self, 'new_lead_email_enabled', n.get_bool_value()),
+            "newLeadEnabled": lambda n : setattr(self, 'new_lead_enabled', n.get_bool_value()),
+            "newLeadSmsEnabled": lambda n : setattr(self, 'new_lead_sms_enabled', n.get_bool_value()),
+            "paymentFailedEnabled": lambda n : setattr(self, 'payment_failed_enabled', n.get_bool_value()),
+            "subscriptionRenewingEnabled": lambda n : setattr(self, 'subscription_renewing_enabled', n.get_bool_value()),
+            "tenDlcStatusEnabled": lambda n : setattr(self, 'ten_dlc_status_enabled', n.get_bool_value()),
+            "unreadSmsEnabled": lambda n : setattr(self, 'unread_sms_enabled', n.get_bool_value()),
+            "usageLimitHitEnabled": lambda n : setattr(self, 'usage_limit_hit_enabled', n.get_bool_value()),
+        }
+        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_bool_value("automationFailedEnabled", self.automation_failed_enabled)
+        writer.write_bool_value("billingEmailEnabled", self.billing_email_enabled)
+        writer.write_bool_value("billingSmsEnabled", self.billing_sms_enabled)
+        writer.write_bool_value("lowWalletBalanceEnabled", self.low_wallet_balance_enabled)
+        writer.write_bool_value("missedCallEnabled", self.missed_call_enabled)
+        writer.write_bool_value("newLeadEmailEnabled", self.new_lead_email_enabled)
+        writer.write_bool_value("newLeadEnabled", self.new_lead_enabled)
+        writer.write_bool_value("newLeadSmsEnabled", self.new_lead_sms_enabled)
+        writer.write_bool_value("paymentFailedEnabled", self.payment_failed_enabled)
+        writer.write_bool_value("subscriptionRenewingEnabled", self.subscription_renewing_enabled)
+        writer.write_bool_value("tenDlcStatusEnabled", self.ten_dlc_status_enabled)
+        writer.write_bool_value("unreadSmsEnabled", self.unread_sms_enabled)
+        writer.write_bool_value("usageLimitHitEnabled", self.usage_limit_hit_enabled)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/user_request.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+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_request_billing_plan import UserRequest_billingPlan
+    from .user_request_business import UserRequest_business
+    from .user_request_compliance import UserRequest_compliance
+    from .user_request_current_business import UserRequest_currentBusiness
+    from .user_request_notification_preferences import UserRequest_notificationPreferences
+    from .user_request_subscription_status import UserRequest_subscriptionStatus
+
+@dataclass
+class UserRequest(AdditionalDataHolder, Parsable):
+    """
+    Request payload for user.
+    """
+    # 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[UserRequest_billingPlan] = None
+    # The business value for this user.
+    business: Optional[UserRequest_business] = None
+    # The compliance value for this user.
+    compliance: Optional[UserRequest_compliance] = None
+    # The current business value for this user.
+    current_business: Optional[UserRequest_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, when updating an existing entity.
+    id: Optional[str] = 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 display name for the entity.
+    name: Optional[str] = None
+    # The notification preferences value for this user.
+    notification_preferences: Optional[UserRequest_notificationPreferences] = None
+    # The phone number associated with this user.
+    phone: Optional[str] = None
+    # Defines the supported Subscription Status values.
+    subscription_status: Optional[UserRequest_subscriptionStatus] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserRequest:
+        """
+        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: UserRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserRequest()
+    
+    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_request_billing_plan import UserRequest_billingPlan
+        from .user_request_business import UserRequest_business
+        from .user_request_compliance import UserRequest_compliance
+        from .user_request_current_business import UserRequest_currentBusiness
+        from .user_request_notification_preferences import UserRequest_notificationPreferences
+        from .user_request_subscription_status import UserRequest_subscriptionStatus
+
+        from .mobile_device_preferences import MobileDevicePreferences
+        from .user_request_billing_plan import UserRequest_billingPlan
+        from .user_request_business import UserRequest_business
+        from .user_request_compliance import UserRequest_compliance
+        from .user_request_current_business import UserRequest_currentBusiness
+        from .user_request_notification_preferences import UserRequest_notificationPreferences
+        from .user_request_subscription_status import UserRequest_subscriptionStatus
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "billingPlan": lambda n : setattr(self, 'billing_plan', n.get_enum_value(UserRequest_billingPlan)),
+            "business": lambda n : setattr(self, 'business', n.get_object_value(UserRequest_business)),
+            "compliance": lambda n : setattr(self, 'compliance', n.get_object_value(UserRequest_compliance)),
+            "currentBusiness": lambda n : setattr(self, 'current_business', n.get_object_value(UserRequest_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()),
+            "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)),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "notificationPreferences": lambda n : setattr(self, 'notification_preferences', n.get_object_value(UserRequest_notificationPreferences)),
+            "phone": lambda n : setattr(self, 'phone', n.get_str_value()),
+            "subscriptionStatus": lambda n : setattr(self, 'subscription_status', n.get_enum_value(UserRequest_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_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_str_value("lastName", self.last_name)
+        writer.write_collection_of_object_values("mobileDevicePreferences", self.mobile_device_preferences)
+        writer.write_str_value("name", self.name)
+        writer.write_object_value("notificationPreferences", self.notification_preferences)
+        writer.write_str_value("phone", self.phone)
+        writer.write_enum_value("subscriptionStatus", self.subscription_status)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/user_request_billing_plan.py

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

leadping/models/user_request_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 UserRequest_business(IdNamePair, Parsable):
+    """
+    The business value for this user.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserRequest_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: UserRequest_business
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserRequest_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_request_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 UserRequest_compliance(UserCompliance, Parsable):
+    """
+    The compliance value for this user.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserRequest_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: UserRequest_compliance
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserRequest_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_request_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 UserRequest_currentBusiness(IdNamePair, Parsable):
+    """
+    The current business value for this user.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserRequest_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: UserRequest_currentBusiness
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserRequest_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_request_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 UserRequest_notificationPreferences(UserNotificationPreferences, Parsable):
+    """
+    The notification preferences value for this user.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserRequest_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: UserRequest_notificationPreferences
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserRequest_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_request_subscription_status.py

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