leadping 1.0.0__py3-none-any.whl

leadping/models/usage_ledger_table_row.py

@@ -0,0 +1,148 @@
+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 .billable_unit import BillableUnit
+    from .usage_channel import UsageChannel
+    from .usage_record_status import UsageRecordStatus
+
+@dataclass
+class UsageLedgerTableRow(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing usage ledger 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 billable unit value for this usage ledger.
+    billable_unit: Optional[BillableUnit] = None
+    # The business ID associated with this usage ledger.
+    business_id: Optional[str] = None
+    # The business name value for this usage ledger.
+    business_name: Optional[str] = None
+    # The channel value for this usage ledger.
+    channel: Optional[UsageChannel] = None
+    # The correlation ID associated with this usage ledger.
+    correlation_id: Optional[str] = None
+    # The date and time for the created at value on this usage ledger.
+    created_at: Optional[datetime.datetime] = None
+    # The monetary customer charge amount for this usage ledger.
+    customer_charge_amount: Optional[float] = None
+    # The human-readable description of this usage ledger.
+    description: Optional[str] = None
+    # The unique ID for this usage ledger.
+    id: Optional[str] = None
+    # The idempotency key value for this usage ledger.
+    idempotency_key: Optional[str] = None
+    # Whether this usage ledger is billable.
+    is_billable: Optional[bool] = None
+    # Whether this usage ledger is internal.
+    is_internal: Optional[bool] = None
+    # The lead ID associated with this usage ledger.
+    lead_id: Optional[str] = None
+    # The lead name value for this usage ledger.
+    lead_name: Optional[str] = None
+    # The phone number associated with this usage ledger.
+    phone_number: Optional[str] = None
+    # The phone number ID associated with this usage ledger.
+    phone_number_id: Optional[str] = None
+    # The quantity value for this usage ledger.
+    quantity: Optional[float] = None
+    # The source event ID associated with this usage ledger.
+    source_event_id: Optional[str] = None
+    # The current status for this usage ledger.
+    status: Optional[UsageRecordStatus] = None
+    # The unit price value for this usage ledger.
+    unit_price: Optional[float] = None
+    # The user ID associated with this usage ledger.
+    user_id: Optional[str] = None
+    # The user name value for this usage ledger.
+    user_name: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UsageLedgerTableRow:
+        """
+        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: UsageLedgerTableRow
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UsageLedgerTableRow()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .billable_unit import BillableUnit
+        from .usage_channel import UsageChannel
+        from .usage_record_status import UsageRecordStatus
+
+        from .billable_unit import BillableUnit
+        from .usage_channel import UsageChannel
+        from .usage_record_status import UsageRecordStatus
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "billableUnit": lambda n : setattr(self, 'billable_unit', n.get_enum_value(BillableUnit)),
+            "businessId": lambda n : setattr(self, 'business_id', n.get_str_value()),
+            "businessName": lambda n : setattr(self, 'business_name', n.get_str_value()),
+            "channel": lambda n : setattr(self, 'channel', n.get_enum_value(UsageChannel)),
+            "correlationId": lambda n : setattr(self, 'correlation_id', n.get_str_value()),
+            "createdAt": lambda n : setattr(self, 'created_at', n.get_datetime_value()),
+            "customerChargeAmount": lambda n : setattr(self, 'customer_charge_amount', n.get_float_value()),
+            "description": lambda n : setattr(self, 'description', n.get_str_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "idempotencyKey": lambda n : setattr(self, 'idempotency_key', n.get_str_value()),
+            "isBillable": lambda n : setattr(self, 'is_billable', n.get_bool_value()),
+            "isInternal": lambda n : setattr(self, 'is_internal', n.get_bool_value()),
+            "leadId": lambda n : setattr(self, 'lead_id', n.get_str_value()),
+            "leadName": lambda n : setattr(self, 'lead_name', n.get_str_value()),
+            "phoneNumber": lambda n : setattr(self, 'phone_number', n.get_str_value()),
+            "phoneNumberId": lambda n : setattr(self, 'phone_number_id', n.get_str_value()),
+            "quantity": lambda n : setattr(self, 'quantity', n.get_float_value()),
+            "sourceEventId": lambda n : setattr(self, 'source_event_id', n.get_str_value()),
+            "status": lambda n : setattr(self, 'status', n.get_enum_value(UsageRecordStatus)),
+            "unitPrice": lambda n : setattr(self, 'unit_price', n.get_float_value()),
+            "userId": lambda n : setattr(self, 'user_id', n.get_str_value()),
+            "userName": lambda n : setattr(self, 'user_name', 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_enum_value("billableUnit", self.billable_unit)
+        writer.write_str_value("businessId", self.business_id)
+        writer.write_str_value("businessName", self.business_name)
+        writer.write_enum_value("channel", self.channel)
+        writer.write_str_value("correlationId", self.correlation_id)
+        writer.write_datetime_value("createdAt", self.created_at)
+        writer.write_float_value("customerChargeAmount", self.customer_charge_amount)
+        writer.write_str_value("description", self.description)
+        writer.write_str_value("id", self.id)
+        writer.write_str_value("idempotencyKey", self.idempotency_key)
+        writer.write_bool_value("isBillable", self.is_billable)
+        writer.write_bool_value("isInternal", self.is_internal)
+        writer.write_str_value("leadId", self.lead_id)
+        writer.write_str_value("leadName", self.lead_name)
+        writer.write_str_value("phoneNumber", self.phone_number)
+        writer.write_str_value("phoneNumberId", self.phone_number_id)
+        writer.write_float_value("quantity", self.quantity)
+        writer.write_str_value("sourceEventId", self.source_event_id)
+        writer.write_enum_value("status", self.status)
+        writer.write_float_value("unitPrice", self.unit_price)
+        writer.write_str_value("userId", self.user_id)
+        writer.write_str_value("userName", self.user_name)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/usage_record_status.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+class UsageRecordStatus(str, Enum):
+    Recorded = "recorded",
+    Rated = "rated",
+    Pending_invoice = "pending_invoice",
+    Invoiced = "invoiced",
+    Charged = "charged",
+    Failed = "failed",
+    Refunded_credited = "refunded_credited",
+    Non_billable_internal = "non_billable_internal",
+    Blocked_due_to_billing = "blocked_due_to_billing",
+

leadping/models/usage_summary_line.py

@@ -0,0 +1,91 @@
+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 .billable_unit import BillableUnit
+    from .usage_channel import UsageChannel
+    from .usage_record_status import UsageRecordStatus
+
+@dataclass
+class UsageSummaryLine(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing usage summary line 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 billable unit value for this usage summary line.
+    billable_unit: Optional[BillableUnit] = None
+    # The channel value for this usage summary line.
+    channel: Optional[UsageChannel] = None
+    # The monetary customer charge amount for this usage summary line.
+    customer_charge_amount: Optional[float] = None
+    # The monetary internal cost amount for this usage summary line.
+    internal_cost_amount: Optional[float] = None
+    # The monetary provider cost amount for this usage summary line.
+    provider_cost_amount: Optional[float] = None
+    # The quantity value for this usage summary line.
+    quantity: Optional[float] = None
+    # The record count for this usage summary line.
+    record_count: Optional[int] = None
+    # The current status for this usage summary line.
+    status: Optional[UsageRecordStatus] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UsageSummaryLine:
+        """
+        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: UsageSummaryLine
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UsageSummaryLine()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .billable_unit import BillableUnit
+        from .usage_channel import UsageChannel
+        from .usage_record_status import UsageRecordStatus
+
+        from .billable_unit import BillableUnit
+        from .usage_channel import UsageChannel
+        from .usage_record_status import UsageRecordStatus
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "billableUnit": lambda n : setattr(self, 'billable_unit', n.get_enum_value(BillableUnit)),
+            "channel": lambda n : setattr(self, 'channel', n.get_enum_value(UsageChannel)),
+            "customerChargeAmount": lambda n : setattr(self, 'customer_charge_amount', n.get_float_value()),
+            "internalCostAmount": lambda n : setattr(self, 'internal_cost_amount', n.get_float_value()),
+            "providerCostAmount": lambda n : setattr(self, 'provider_cost_amount', n.get_float_value()),
+            "quantity": lambda n : setattr(self, 'quantity', n.get_float_value()),
+            "recordCount": lambda n : setattr(self, 'record_count', n.get_int_value()),
+            "status": lambda n : setattr(self, 'status', n.get_enum_value(UsageRecordStatus)),
+        }
+        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("billableUnit", self.billable_unit)
+        writer.write_enum_value("channel", self.channel)
+        writer.write_float_value("customerChargeAmount", self.customer_charge_amount)
+        writer.write_float_value("internalCostAmount", self.internal_cost_amount)
+        writer.write_float_value("providerCostAmount", self.provider_cost_amount)
+        writer.write_float_value("quantity", self.quantity)
+        writer.write_int_value("recordCount", self.record_count)
+        writer.write_enum_value("status", self.status)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/usage_summary_response.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 .usage_counter_line import UsageCounterLine
+    from .usage_summary_line import UsageSummaryLine
+
+@dataclass
+class UsageSummaryResponse(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing usage summary response data.
+    """
+    # 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 billable quantity total for this usage summary.
+    billable_quantity_total: Optional[float] = None
+    # The billing blocked count for this usage summary.
+    billing_blocked_count: Optional[int] = None
+    # The named usage counters included with this usage summary.
+    counters: Optional[list[UsageCounterLine]] = None
+    # The customer charge total for this usage summary.
+    customer_charge_total: Optional[float] = None
+    # The failed count for this usage summary.
+    failed_count: Optional[int] = None
+    # The internal cost total for this usage summary.
+    internal_cost_total: Optional[float] = None
+    # The lines included with this usage summary.
+    lines: Optional[list[UsageSummaryLine]] = None
+    # The non billable internal count for this usage summary.
+    non_billable_internal_count: Optional[int] = None
+    # The pending invoice count for this usage summary.
+    pending_invoice_count: Optional[int] = None
+    # The date and time for the period end value on this usage summary.
+    period_end: Optional[datetime.datetime] = None
+    # The date and time for the period start value on this usage summary.
+    period_start: Optional[datetime.datetime] = None
+    # The provider cost total for this usage summary.
+    provider_cost_total: Optional[float] = None
+    # The usage record count for this usage summary.
+    usage_record_count: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UsageSummaryResponse:
+        """
+        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: UsageSummaryResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UsageSummaryResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .usage_counter_line import UsageCounterLine
+        from .usage_summary_line import UsageSummaryLine
+
+        from .usage_counter_line import UsageCounterLine
+        from .usage_summary_line import UsageSummaryLine
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "billableQuantityTotal": lambda n : setattr(self, 'billable_quantity_total', n.get_float_value()),
+            "billingBlockedCount": lambda n : setattr(self, 'billing_blocked_count', n.get_int_value()),
+            "counters": lambda n : setattr(self, 'counters', n.get_collection_of_object_values(UsageCounterLine)),
+            "customerChargeTotal": lambda n : setattr(self, 'customer_charge_total', n.get_float_value()),
+            "failedCount": lambda n : setattr(self, 'failed_count', n.get_int_value()),
+            "internalCostTotal": lambda n : setattr(self, 'internal_cost_total', n.get_float_value()),
+            "lines": lambda n : setattr(self, 'lines', n.get_collection_of_object_values(UsageSummaryLine)),
+            "nonBillableInternalCount": lambda n : setattr(self, 'non_billable_internal_count', n.get_int_value()),
+            "pendingInvoiceCount": lambda n : setattr(self, 'pending_invoice_count', n.get_int_value()),
+            "periodEnd": lambda n : setattr(self, 'period_end', n.get_datetime_value()),
+            "periodStart": lambda n : setattr(self, 'period_start', n.get_datetime_value()),
+            "providerCostTotal": lambda n : setattr(self, 'provider_cost_total', n.get_float_value()),
+            "usageRecordCount": lambda n : setattr(self, 'usage_record_count', n.get_int_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_float_value("billableQuantityTotal", self.billable_quantity_total)
+        writer.write_int_value("billingBlockedCount", self.billing_blocked_count)
+        writer.write_collection_of_object_values("counters", self.counters)
+        writer.write_float_value("customerChargeTotal", self.customer_charge_total)
+        writer.write_int_value("failedCount", self.failed_count)
+        writer.write_float_value("internalCostTotal", self.internal_cost_total)
+        writer.write_collection_of_object_values("lines", self.lines)
+        writer.write_int_value("nonBillableInternalCount", self.non_billable_internal_count)
+        writer.write_int_value("pendingInvoiceCount", self.pending_invoice_count)
+        writer.write_datetime_value("periodEnd", self.period_end)
+        writer.write_datetime_value("periodStart", self.period_start)
+        writer.write_float_value("providerCostTotal", self.provider_cost_total)
+        writer.write_int_value("usageRecordCount", self.usage_record_count)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/user_compliance.py

@@ -0,0 +1,85 @@
+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 .trusted_form_certificate import TrustedFormCertificate
+
+@dataclass
+class UserCompliance(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing user compliance 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 the user accepted BAA for this user compliance.
+    accepted_baa: Optional[bool] = None
+    # Whether the user accepted email for this user compliance.
+    accepted_email: Optional[bool] = None
+    # Whether the user accepted SMS for this user compliance.
+    accepted_sms: Optional[bool] = None
+    # Whether the user accepted terms for this user compliance.
+    accepted_terms: Optional[bool] = None
+    # Whether the user accepted subscription for this user compliance.
+    accepted_to_subscription: Optional[bool] = None
+    # The licensed products included with this user compliance.
+    licensed_products: Optional[list[str]] = None
+    # The licensed states included with this user compliance.
+    licensed_states: Optional[list[str]] = None
+    # The TrustedForm certificates included with this user compliance.
+    trusted_form_certificates: Optional[list[TrustedFormCertificate]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserCompliance:
+        """
+        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: UserCompliance
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserCompliance()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .trusted_form_certificate import TrustedFormCertificate
+
+        from .trusted_form_certificate import TrustedFormCertificate
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "acceptedBaa": lambda n : setattr(self, 'accepted_baa', n.get_bool_value()),
+            "acceptedEmail": lambda n : setattr(self, 'accepted_email', n.get_bool_value()),
+            "acceptedSms": lambda n : setattr(self, 'accepted_sms', n.get_bool_value()),
+            "acceptedTerms": lambda n : setattr(self, 'accepted_terms', n.get_bool_value()),
+            "acceptedToSubscription": lambda n : setattr(self, 'accepted_to_subscription', n.get_bool_value()),
+            "licensedProducts": lambda n : setattr(self, 'licensed_products', n.get_collection_of_primitive_values(str)),
+            "licensedStates": lambda n : setattr(self, 'licensed_states', n.get_collection_of_primitive_values(str)),
+            "trustedFormCertificates": lambda n : setattr(self, 'trusted_form_certificates', n.get_collection_of_object_values(TrustedFormCertificate)),
+        }
+        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("acceptedBaa", self.accepted_baa)
+        writer.write_bool_value("acceptedEmail", self.accepted_email)
+        writer.write_bool_value("acceptedSms", self.accepted_sms)
+        writer.write_bool_value("acceptedTerms", self.accepted_terms)
+        writer.write_bool_value("acceptedToSubscription", self.accepted_to_subscription)
+        writer.write_collection_of_primitive_values("licensedProducts", self.licensed_products)
+        writer.write_collection_of_primitive_values("licensedStates", self.licensed_states)
+        writer.write_collection_of_object_values("trustedFormCertificates", self.trusted_form_certificates)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/user_data_export_file.py

@@ -0,0 +1,59 @@
+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 UserDataExportFile(AdditionalDataHolder, Parsable):
+    # 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 category property
+    category: Optional[str] = None
+    # The contentType property
+    content_type: Optional[str] = None
+    # The fileName property
+    file_name: Optional[str] = None
+    # The rowCount property
+    row_count: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserDataExportFile:
+        """
+        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: UserDataExportFile
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserDataExportFile()
+    
+    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]] = {
+            "category": lambda n : setattr(self, 'category', n.get_str_value()),
+            "contentType": lambda n : setattr(self, 'content_type', n.get_str_value()),
+            "fileName": lambda n : setattr(self, 'file_name', n.get_str_value()),
+            "rowCount": lambda n : setattr(self, 'row_count', n.get_int_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("category", self.category)
+        writer.write_str_value("contentType", self.content_type)
+        writer.write_str_value("fileName", self.file_name)
+        writer.write_int_value("rowCount", self.row_count)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/user_data_export_response.py

@@ -0,0 +1,110 @@
+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_data_export_file import UserDataExportFile
+    from .user_data_export_statuses import UserDataExportStatuses
+
+@dataclass
+class UserDataExportResponse(AdditionalDataHolder, Parsable):
+    # 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 completedAt property
+    completed_at: Optional[datetime.datetime] = None
+    # The contentType property
+    content_type: Optional[str] = None
+    # The downloadCount property
+    download_count: Optional[int] = None
+    # The downloadUrl property
+    download_url: Optional[str] = None
+    # The expiresAt property
+    expires_at: Optional[datetime.datetime] = None
+    # The failedAt property
+    failed_at: Optional[datetime.datetime] = None
+    # The fileName property
+    file_name: Optional[str] = None
+    # The files property
+    files: Optional[list[UserDataExportFile]] = None
+    # The id property
+    id: Optional[str] = None
+    # The maxDownloadCount property
+    max_download_count: Optional[int] = None
+    # The message property
+    message: Optional[str] = None
+    # The requestedAt property
+    requested_at: Optional[datetime.datetime] = None
+    # The startedAt property
+    started_at: Optional[datetime.datetime] = None
+    # Defines the supported user data export statuses values.
+    status: Optional[UserDataExportStatuses] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserDataExportResponse:
+        """
+        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: UserDataExportResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserDataExportResponse()
+    
+    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_data_export_file import UserDataExportFile
+        from .user_data_export_statuses import UserDataExportStatuses
+
+        from .user_data_export_file import UserDataExportFile
+        from .user_data_export_statuses import UserDataExportStatuses
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "completedAt": lambda n : setattr(self, 'completed_at', n.get_datetime_value()),
+            "contentType": lambda n : setattr(self, 'content_type', n.get_str_value()),
+            "downloadCount": lambda n : setattr(self, 'download_count', n.get_int_value()),
+            "downloadUrl": lambda n : setattr(self, 'download_url', n.get_str_value()),
+            "expiresAt": lambda n : setattr(self, 'expires_at', n.get_datetime_value()),
+            "failedAt": lambda n : setattr(self, 'failed_at', n.get_datetime_value()),
+            "fileName": lambda n : setattr(self, 'file_name', n.get_str_value()),
+            "files": lambda n : setattr(self, 'files', n.get_collection_of_object_values(UserDataExportFile)),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "maxDownloadCount": lambda n : setattr(self, 'max_download_count', n.get_int_value()),
+            "message": lambda n : setattr(self, 'message', n.get_str_value()),
+            "requestedAt": lambda n : setattr(self, 'requested_at', n.get_datetime_value()),
+            "startedAt": lambda n : setattr(self, 'started_at', n.get_datetime_value()),
+            "status": lambda n : setattr(self, 'status', n.get_enum_value(UserDataExportStatuses)),
+        }
+        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("completedAt", self.completed_at)
+        writer.write_str_value("contentType", self.content_type)
+        writer.write_int_value("downloadCount", self.download_count)
+        writer.write_str_value("downloadUrl", self.download_url)
+        writer.write_datetime_value("expiresAt", self.expires_at)
+        writer.write_datetime_value("failedAt", self.failed_at)
+        writer.write_str_value("fileName", self.file_name)
+        writer.write_collection_of_object_values("files", self.files)
+        writer.write_str_value("id", self.id)
+        writer.write_int_value("maxDownloadCount", self.max_download_count)
+        writer.write_str_value("message", self.message)
+        writer.write_datetime_value("requestedAt", self.requested_at)
+        writer.write_datetime_value("startedAt", self.started_at)
+        writer.write_enum_value("status", self.status)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/user_data_export_statuses.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class UserDataExportStatuses(str, Enum):
+    Pending = "Pending",
+    Processing = "Processing",
+    Completed = "Completed",
+    Failed = "Failed",
+    Expired = "Expired",
+