leadping 1.0.0__py3-none-any.whl

leadping/models/business_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 .business_stripe_info_cancellation import BusinessStripeInfo_cancellation
+    from .business_stripe_info_dunning import BusinessStripeInfo_dunning
+
+@dataclass
+class BusinessStripeInfo(AdditionalDataHolder, Parsable):
+    """
+    Stripe billing state owned by a business account.
+    """
+    # 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 businessUserSubscriptionItemId property
+    business_user_subscription_item_id: Optional[str] = None
+    # The cancelAt property
+    cancel_at: Optional[datetime.datetime] = None
+    # Captured subscription cancellation feedback for retention and churn analysis.
+    cancellation: Optional[BusinessStripeInfo_cancellation] = None
+    # The customerId property
+    customer_id: Optional[str] = None
+    # The defaultPaymentMethodId property
+    default_payment_method_id: Optional[str] = None
+    # Dunning state recorded after a failed recurring payment.
+    dunning: Optional[BusinessStripeInfo_dunning] = None
+    # The lastPaymentMethodEventAt property
+    last_payment_method_event_at: Optional[datetime.datetime] = None
+    # The lastSubscriptionEventAt property
+    last_subscription_event_at: Optional[datetime.datetime] = None
+    # The phoneSubscriptionId property
+    phone_subscription_id: Optional[str] = None
+    # The phoneSubscriptionItemId property
+    phone_subscription_item_id: Optional[str] = None
+    # The planSubscriptionId property
+    plan_subscription_id: Optional[str] = None
+    # The planSubscriptionItemId property
+    plan_subscription_item_id: Optional[str] = None
+    # The subscriptionIds property
+    subscription_ids: Optional[list[str]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> BusinessStripeInfo:
+        """
+        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: BusinessStripeInfo
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return BusinessStripeInfo()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .business_stripe_info_cancellation import BusinessStripeInfo_cancellation
+        from .business_stripe_info_dunning import BusinessStripeInfo_dunning
+
+        from .business_stripe_info_cancellation import BusinessStripeInfo_cancellation
+        from .business_stripe_info_dunning import BusinessStripeInfo_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(BusinessStripeInfo_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(BusinessStripeInfo_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/business_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 BusinessStripeInfo_cancellation(UserSubscriptionCancellationInfo, Parsable):
+    """
+    Captured subscription cancellation feedback for retention and churn analysis.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> BusinessStripeInfo_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: BusinessStripeInfo_cancellation
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return BusinessStripeInfo_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)
+    
+

leadping/models/business_stripe_info_dunning.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_dunning_info import UserDunningInfo
+
+from .user_dunning_info import UserDunningInfo
+
+@dataclass
+class BusinessStripeInfo_dunning(UserDunningInfo, Parsable):
+    """
+    Dunning state recorded after a failed recurring payment.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> BusinessStripeInfo_dunning:
+        """
+        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: BusinessStripeInfo_dunning
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return BusinessStripeInfo_dunning()
+    
+    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_dunning_info import UserDunningInfo
+
+        from .user_dunning_info import UserDunningInfo
+
+        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/business_switch_option.py

@@ -0,0 +1,100 @@
+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 .business_switch_option_activation_status import BusinessSwitchOption_activationStatus
+    from .business_switch_option_business_status import BusinessSwitchOption_businessStatus
+    from .business_user_role import BusinessUserRole
+
+@dataclass
+class BusinessSwitchOption(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing business switch option 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)
+
+    # Defines the supported Customer Activation Status values.
+    activation_status: Optional[BusinessSwitchOption_activationStatus] = None
+    # The activation summary value for this business switch option.
+    activation_summary: Optional[str] = None
+    # Defines the supported Business Status values.
+    business_status: Optional[BusinessSwitchOption_businessStatus] = None
+    # The unique ID for this business switch option.
+    id: Optional[str] = None
+    # Whether this business switch option is current.
+    is_current: Optional[bool] = None
+    # The date and time for the last used at value on this business switch option.
+    last_used_at: Optional[datetime.datetime] = None
+    # The human-readable name shown for this business switch option.
+    name: Optional[str] = None
+    # Whether needs admin review applies to this business switch option.
+    needs_admin_review: Optional[bool] = None
+    # Whether ready for customer traffic applies to this business switch option.
+    ready_for_customer_traffic: Optional[bool] = None
+    # The role value for this business switch option.
+    role: Optional[BusinessUserRole] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> BusinessSwitchOption:
+        """
+        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: BusinessSwitchOption
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return BusinessSwitchOption()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .business_switch_option_activation_status import BusinessSwitchOption_activationStatus
+        from .business_switch_option_business_status import BusinessSwitchOption_businessStatus
+        from .business_user_role import BusinessUserRole
+
+        from .business_switch_option_activation_status import BusinessSwitchOption_activationStatus
+        from .business_switch_option_business_status import BusinessSwitchOption_businessStatus
+        from .business_user_role import BusinessUserRole
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "activationStatus": lambda n : setattr(self, 'activation_status', n.get_enum_value(BusinessSwitchOption_activationStatus)),
+            "activationSummary": lambda n : setattr(self, 'activation_summary', n.get_str_value()),
+            "businessStatus": lambda n : setattr(self, 'business_status', n.get_enum_value(BusinessSwitchOption_businessStatus)),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "isCurrent": lambda n : setattr(self, 'is_current', n.get_bool_value()),
+            "lastUsedAt": lambda n : setattr(self, 'last_used_at', n.get_datetime_value()),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "needsAdminReview": lambda n : setattr(self, 'needs_admin_review', n.get_bool_value()),
+            "readyForCustomerTraffic": lambda n : setattr(self, 'ready_for_customer_traffic', n.get_bool_value()),
+            "role": lambda n : setattr(self, 'role', n.get_enum_value(BusinessUserRole)),
+        }
+        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("activationStatus", self.activation_status)
+        writer.write_str_value("activationSummary", self.activation_summary)
+        writer.write_enum_value("businessStatus", self.business_status)
+        writer.write_str_value("id", self.id)
+        writer.write_bool_value("isCurrent", self.is_current)
+        writer.write_datetime_value("lastUsedAt", self.last_used_at)
+        writer.write_str_value("name", self.name)
+        writer.write_bool_value("needsAdminReview", self.needs_admin_review)
+        writer.write_bool_value("readyForCustomerTraffic", self.ready_for_customer_traffic)
+        writer.write_enum_value("role", self.role)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/business_switch_option_activation_status.py

@@ -0,0 +1,24 @@
+from enum import Enum
+
+class BusinessSwitchOption_activationStatus(str, Enum):
+    DraftOnboarding = "DraftOnboarding",
+    PaymentMethodPending = "PaymentMethodPending",
+    PaymentMethodConfirmed = "PaymentMethodConfirmed",
+    SubscriptionPending = "SubscriptionPending",
+    SubscriptionReceived = "SubscriptionReceived",
+    SubscriptionActive = "SubscriptionActive",
+    LaunchReviewPending = "LaunchReviewPending",
+    TelephonyProvisioningPending = "TelephonyProvisioningPending",
+    TelephonyPartiallyProvisioned = "TelephonyPartiallyProvisioned",
+    TelephonyReady = "TelephonyReady",
+    AwaitingReview = "AwaitingReview",
+    DomainSelection = "DomainSelection",
+    WebsiteSetup = "WebsiteSetup",
+    ComplianceRegistration = "ComplianceRegistration",
+    ReadyForApproval = "ReadyForApproval",
+    Active = "Active",
+    Failed = "Failed",
+    Blocked = "Blocked",
+    BlockedRequiresOperatorAction = "BlockedRequiresOperatorAction",
+    ManuallyBypassed = "ManuallyBypassed",
+

leadping/models/business_switch_option_business_status.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class BusinessSwitchOption_businessStatus(str, Enum):
+    SettingUp = "SettingUp",
+    SetupCompleted = "SetupCompleted",
+    Active = "Active",
+

leadping/models/business_switch_request.py

@@ -0,0 +1,50 @@
+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 BusinessSwitchRequest(AdditionalDataHolder, Parsable):
+    """
+    Request payload for business switch.
+    """
+    # 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 ID associated with this business switch.
+    business_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> BusinessSwitchRequest:
+        """
+        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: BusinessSwitchRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return BusinessSwitchRequest()
+    
+    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]] = {
+            "businessId": lambda n : setattr(self, 'business_id', 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("businessId", self.business_id)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/business_user_request.py

@@ -0,0 +1,65 @@
+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 .business_user_role import BusinessUserRole
+
+@dataclass
+class BusinessUserRequest(AdditionalDataHolder, Parsable):
+    """
+    Request payload for business 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)
+
+    # The email address associated with this business user.
+    email: Optional[str] = None
+    # The role value for this business user.
+    role: Optional[BusinessUserRole] = None
+    # The user ID associated with this business user.
+    user_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> BusinessUserRequest:
+        """
+        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: BusinessUserRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return BusinessUserRequest()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .business_user_role import BusinessUserRole
+
+        from .business_user_role import BusinessUserRole
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "email": lambda n : setattr(self, 'email', n.get_str_value()),
+            "role": lambda n : setattr(self, 'role', n.get_enum_value(BusinessUserRole)),
+            "userId": lambda n : setattr(self, 'user_id', 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("email", self.email)
+        writer.write_enum_value("role", self.role)
+        writer.write_str_value("userId", self.user_id)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/business_user_response.py

@@ -0,0 +1,121 @@
+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 .business_user_role import BusinessUserRole
+    from .id_name_pair import IdNamePair
+
+@dataclass
+class BusinessUserResponse(AdditionalDataHolder, Parsable):
+    """
+    API response containing business 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)
+
+    # The business value for this business user.
+    business: Optional[IdNamePair] = None
+    # The date and time when the entity was created.
+    created_at: Optional[datetime.datetime] = None
+    # The created by user ID associated with this business user.
+    created_by_user_id: Optional[str] = None
+    # The unique identifier for the entity.
+    id: Optional[str] = None
+    # The date and time for the last used at value on this business user.
+    last_used_at: Optional[datetime.datetime] = None
+    # The billing status for this user's business license.
+    license_billing_status: Optional[str] = None
+    # The renewal date used for this user's license proration.
+    license_renewal_date: Optional[datetime.datetime] = None
+    # The Stripe subscription ID containing this user's business license item.
+    license_stripe_subscription_id: Optional[str] = None
+    # The Stripe subscription item ID used for business user licenses.
+    license_stripe_subscription_item_id: Optional[str] = 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 date and time for the removed at value on this business user.
+    removed_at: Optional[datetime.datetime] = None
+    # The removed by user ID associated with this business user.
+    removed_by_user_id: Optional[str] = None
+    # The role value for this business user.
+    role: Optional[BusinessUserRole] = None
+    # The user value for this business user.
+    user: Optional[IdNamePair] = None
+    # The user email value for this business user.
+    user_email: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> BusinessUserResponse:
+        """
+        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: BusinessUserResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return BusinessUserResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .business_user_role import BusinessUserRole
+        from .id_name_pair import IdNamePair
+
+        from .business_user_role import BusinessUserRole
+        from .id_name_pair import IdNamePair
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "business": lambda n : setattr(self, 'business', n.get_object_value(IdNamePair)),
+            "createdAt": lambda n : setattr(self, 'created_at', n.get_datetime_value()),
+            "createdByUserId": lambda n : setattr(self, 'created_by_user_id', n.get_str_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "lastUsedAt": lambda n : setattr(self, 'last_used_at', n.get_datetime_value()),
+            "licenseBillingStatus": lambda n : setattr(self, 'license_billing_status', n.get_str_value()),
+            "licenseRenewalDate": lambda n : setattr(self, 'license_renewal_date', n.get_datetime_value()),
+            "licenseStripeSubscriptionId": lambda n : setattr(self, 'license_stripe_subscription_id', n.get_str_value()),
+            "licenseStripeSubscriptionItemId": lambda n : setattr(self, 'license_stripe_subscription_item_id', n.get_str_value()),
+            "modifiedAt": lambda n : setattr(self, 'modified_at', n.get_datetime_value()),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "removedAt": lambda n : setattr(self, 'removed_at', n.get_datetime_value()),
+            "removedByUserId": lambda n : setattr(self, 'removed_by_user_id', n.get_str_value()),
+            "role": lambda n : setattr(self, 'role', n.get_enum_value(BusinessUserRole)),
+            "user": lambda n : setattr(self, 'user', n.get_object_value(IdNamePair)),
+            "userEmail": lambda n : setattr(self, 'user_email', 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_object_value("business", self.business)
+        writer.write_datetime_value("createdAt", self.created_at)
+        writer.write_str_value("createdByUserId", self.created_by_user_id)
+        writer.write_str_value("id", self.id)
+        writer.write_datetime_value("lastUsedAt", self.last_used_at)
+        writer.write_str_value("licenseBillingStatus", self.license_billing_status)
+        writer.write_datetime_value("licenseRenewalDate", self.license_renewal_date)
+        writer.write_str_value("licenseStripeSubscriptionId", self.license_stripe_subscription_id)
+        writer.write_str_value("licenseStripeSubscriptionItemId", self.license_stripe_subscription_item_id)
+        writer.write_datetime_value("modifiedAt", self.modified_at)
+        writer.write_str_value("name", self.name)
+        writer.write_datetime_value("removedAt", self.removed_at)
+        writer.write_str_value("removedByUserId", self.removed_by_user_id)
+        writer.write_enum_value("role", self.role)
+        writer.write_object_value("user", self.user)
+        writer.write_str_value("userEmail", self.user_email)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/business_user_role.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class BusinessUserRole(str, Enum):
+    Owner = "Owner",
+    Admin = "Admin",
+    Agent = "Agent",
+