leadping 1.0.0__py3-none-any.whl

leadping/models/customer_analytics_response.py

@@ -0,0 +1,115 @@
+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 .analytics_date_range import AnalyticsDateRange
+    from .customer_activation_health import CustomerActivationHealth
+    from .customer_analytics_summary import CustomerAnalyticsSummary
+    from .customer_automation_health import CustomerAutomationHealth
+    from .customer_communication_usage import CustomerCommunicationUsage
+    from .customer_lead_source_breakdown import CustomerLeadSourceBreakdown
+    from .customer_lead_trend import CustomerLeadTrend
+    from .customer_needs_attention_item import CustomerNeedsAttentionItem
+    from .customer_response_metrics import CustomerResponseMetrics
+
+@dataclass
+class CustomerAnalyticsResponse(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 activationHealth property
+    activation_health: Optional[CustomerActivationHealth] = None
+    # The automationHealth property
+    automation_health: Optional[CustomerAutomationHealth] = None
+    # The communicationUsage property
+    communication_usage: Optional[CustomerCommunicationUsage] = None
+    # The generatedAt property
+    generated_at: Optional[datetime.datetime] = None
+    # The leadSources property
+    lead_sources: Optional[list[CustomerLeadSourceBreakdown]] = None
+    # The leadTrend property
+    lead_trend: Optional[CustomerLeadTrend] = None
+    # The needsAttention property
+    needs_attention: Optional[list[CustomerNeedsAttentionItem]] = None
+    # The range property
+    range: Optional[AnalyticsDateRange] = None
+    # The responseMetrics property
+    response_metrics: Optional[CustomerResponseMetrics] = None
+    # The summary property
+    summary: Optional[CustomerAnalyticsSummary] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CustomerAnalyticsResponse:
+        """
+        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: CustomerAnalyticsResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CustomerAnalyticsResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .analytics_date_range import AnalyticsDateRange
+        from .customer_activation_health import CustomerActivationHealth
+        from .customer_analytics_summary import CustomerAnalyticsSummary
+        from .customer_automation_health import CustomerAutomationHealth
+        from .customer_communication_usage import CustomerCommunicationUsage
+        from .customer_lead_source_breakdown import CustomerLeadSourceBreakdown
+        from .customer_lead_trend import CustomerLeadTrend
+        from .customer_needs_attention_item import CustomerNeedsAttentionItem
+        from .customer_response_metrics import CustomerResponseMetrics
+
+        from .analytics_date_range import AnalyticsDateRange
+        from .customer_activation_health import CustomerActivationHealth
+        from .customer_analytics_summary import CustomerAnalyticsSummary
+        from .customer_automation_health import CustomerAutomationHealth
+        from .customer_communication_usage import CustomerCommunicationUsage
+        from .customer_lead_source_breakdown import CustomerLeadSourceBreakdown
+        from .customer_lead_trend import CustomerLeadTrend
+        from .customer_needs_attention_item import CustomerNeedsAttentionItem
+        from .customer_response_metrics import CustomerResponseMetrics
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "activationHealth": lambda n : setattr(self, 'activation_health', n.get_object_value(CustomerActivationHealth)),
+            "automationHealth": lambda n : setattr(self, 'automation_health', n.get_object_value(CustomerAutomationHealth)),
+            "communicationUsage": lambda n : setattr(self, 'communication_usage', n.get_object_value(CustomerCommunicationUsage)),
+            "generatedAt": lambda n : setattr(self, 'generated_at', n.get_datetime_value()),
+            "leadSources": lambda n : setattr(self, 'lead_sources', n.get_collection_of_object_values(CustomerLeadSourceBreakdown)),
+            "leadTrend": lambda n : setattr(self, 'lead_trend', n.get_object_value(CustomerLeadTrend)),
+            "needsAttention": lambda n : setattr(self, 'needs_attention', n.get_collection_of_object_values(CustomerNeedsAttentionItem)),
+            "range": lambda n : setattr(self, 'range', n.get_object_value(AnalyticsDateRange)),
+            "responseMetrics": lambda n : setattr(self, 'response_metrics', n.get_object_value(CustomerResponseMetrics)),
+            "summary": lambda n : setattr(self, 'summary', n.get_object_value(CustomerAnalyticsSummary)),
+        }
+        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("activationHealth", self.activation_health)
+        writer.write_object_value("automationHealth", self.automation_health)
+        writer.write_object_value("communicationUsage", self.communication_usage)
+        writer.write_datetime_value("generatedAt", self.generated_at)
+        writer.write_collection_of_object_values("leadSources", self.lead_sources)
+        writer.write_object_value("leadTrend", self.lead_trend)
+        writer.write_collection_of_object_values("needsAttention", self.needs_attention)
+        writer.write_object_value("range", self.range)
+        writer.write_object_value("responseMetrics", self.response_metrics)
+        writer.write_object_value("summary", self.summary)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/customer_analytics_summary.py

@@ -0,0 +1,110 @@
+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 .analytics_comparison import AnalyticsComparison
+
+@dataclass
+class CustomerAnalyticsSummary(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 billingStatus property
+    billing_status: Optional[str] = None
+    # The callMinutes property
+    call_minutes: Optional[float] = None
+    # The callsPlaced property
+    calls_placed: Optional[int] = None
+    # The callsReceived property
+    calls_received: Optional[int] = None
+    # The leads property
+    leads: Optional[int] = None
+    # The leadsComparison property
+    leads_comparison: Optional[AnalyticsComparison] = None
+    # The missedCalls property
+    missed_calls: Optional[int] = None
+    # The missedLeads property
+    missed_leads: Optional[int] = None
+    # The respondedWithinFiveMinutesPercent property
+    responded_within_five_minutes_percent: Optional[float] = None
+    # The smsReceived property
+    sms_received: Optional[int] = None
+    # The smsSent property
+    sms_sent: Optional[int] = None
+    # The unreadMessages property
+    unread_messages: Optional[int] = None
+    # The usageSpend property
+    usage_spend: Optional[float] = None
+    # The walletBalance property
+    wallet_balance: Optional[float] = None
+    # The walletStatus property
+    wallet_status: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CustomerAnalyticsSummary:
+        """
+        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: CustomerAnalyticsSummary
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CustomerAnalyticsSummary()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .analytics_comparison import AnalyticsComparison
+
+        from .analytics_comparison import AnalyticsComparison
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "billingStatus": lambda n : setattr(self, 'billing_status', n.get_str_value()),
+            "callMinutes": lambda n : setattr(self, 'call_minutes', n.get_float_value()),
+            "callsPlaced": lambda n : setattr(self, 'calls_placed', n.get_int_value()),
+            "callsReceived": lambda n : setattr(self, 'calls_received', n.get_int_value()),
+            "leads": lambda n : setattr(self, 'leads', n.get_int_value()),
+            "leadsComparison": lambda n : setattr(self, 'leads_comparison', n.get_object_value(AnalyticsComparison)),
+            "missedCalls": lambda n : setattr(self, 'missed_calls', n.get_int_value()),
+            "missedLeads": lambda n : setattr(self, 'missed_leads', n.get_int_value()),
+            "respondedWithinFiveMinutesPercent": lambda n : setattr(self, 'responded_within_five_minutes_percent', n.get_float_value()),
+            "smsReceived": lambda n : setattr(self, 'sms_received', n.get_int_value()),
+            "smsSent": lambda n : setattr(self, 'sms_sent', n.get_int_value()),
+            "unreadMessages": lambda n : setattr(self, 'unread_messages', n.get_int_value()),
+            "usageSpend": lambda n : setattr(self, 'usage_spend', n.get_float_value()),
+            "walletBalance": lambda n : setattr(self, 'wallet_balance', n.get_float_value()),
+            "walletStatus": lambda n : setattr(self, 'wallet_status', 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("billingStatus", self.billing_status)
+        writer.write_float_value("callMinutes", self.call_minutes)
+        writer.write_int_value("callsPlaced", self.calls_placed)
+        writer.write_int_value("callsReceived", self.calls_received)
+        writer.write_int_value("leads", self.leads)
+        writer.write_object_value("leadsComparison", self.leads_comparison)
+        writer.write_int_value("missedCalls", self.missed_calls)
+        writer.write_int_value("missedLeads", self.missed_leads)
+        writer.write_float_value("respondedWithinFiveMinutesPercent", self.responded_within_five_minutes_percent)
+        writer.write_int_value("smsReceived", self.sms_received)
+        writer.write_int_value("smsSent", self.sms_sent)
+        writer.write_int_value("unreadMessages", self.unread_messages)
+        writer.write_float_value("usageSpend", self.usage_spend)
+        writer.write_float_value("walletBalance", self.wallet_balance)
+        writer.write_str_value("walletStatus", self.wallet_status)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/customer_automation_health.py

@@ -0,0 +1,81 @@
+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 .customer_automation_health_last_failure import CustomerAutomationHealth_lastFailure
+    from .customer_failing_automation import CustomerFailingAutomation
+
+@dataclass
+class CustomerAutomationHealth(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 automationCount property
+    automation_count: Optional[int] = None
+    # The enabledCount property
+    enabled_count: Optional[int] = None
+    # The executions property
+    executions: Optional[int] = None
+    # The failingAutomations property
+    failing_automations: Optional[list[CustomerFailingAutomation]] = None
+    # The failureCount property
+    failure_count: Optional[int] = None
+    # The lastFailure property
+    last_failure: Optional[CustomerAutomationHealth_lastFailure] = None
+    # The successCount property
+    success_count: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CustomerAutomationHealth:
+        """
+        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: CustomerAutomationHealth
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CustomerAutomationHealth()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .customer_automation_health_last_failure import CustomerAutomationHealth_lastFailure
+        from .customer_failing_automation import CustomerFailingAutomation
+
+        from .customer_automation_health_last_failure import CustomerAutomationHealth_lastFailure
+        from .customer_failing_automation import CustomerFailingAutomation
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "automationCount": lambda n : setattr(self, 'automation_count', n.get_int_value()),
+            "enabledCount": lambda n : setattr(self, 'enabled_count', n.get_int_value()),
+            "executions": lambda n : setattr(self, 'executions', n.get_int_value()),
+            "failingAutomations": lambda n : setattr(self, 'failing_automations', n.get_collection_of_object_values(CustomerFailingAutomation)),
+            "failureCount": lambda n : setattr(self, 'failure_count', n.get_int_value()),
+            "lastFailure": lambda n : setattr(self, 'last_failure', n.get_object_value(CustomerAutomationHealth_lastFailure)),
+            "successCount": lambda n : setattr(self, 'success_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_int_value("automationCount", self.automation_count)
+        writer.write_int_value("enabledCount", self.enabled_count)
+        writer.write_int_value("executions", self.executions)
+        writer.write_collection_of_object_values("failingAutomations", self.failing_automations)
+        writer.write_int_value("failureCount", self.failure_count)
+        writer.write_object_value("lastFailure", self.last_failure)
+        writer.write_int_value("successCount", self.success_count)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/customer_automation_health_last_failure.py

@@ -0,0 +1,51 @@
+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 .customer_failing_automation import CustomerFailingAutomation
+
+from .customer_failing_automation import CustomerFailingAutomation
+
+@dataclass
+class CustomerAutomationHealth_lastFailure(CustomerFailingAutomation, Parsable):
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CustomerAutomationHealth_lastFailure:
+        """
+        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: CustomerAutomationHealth_lastFailure
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CustomerAutomationHealth_lastFailure()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .customer_failing_automation import CustomerFailingAutomation
+
+        from .customer_failing_automation import CustomerFailingAutomation
+
+        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/customer_communication_usage.py

@@ -0,0 +1,90 @@
+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 .customer_communication_usage_point import CustomerCommunicationUsagePoint
+
+@dataclass
+class CustomerCommunicationUsage(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 answeredCalls property
+    answered_calls: Optional[int] = None
+    # The callMinutes property
+    call_minutes: Optional[float] = None
+    # The callsPlaced property
+    calls_placed: Optional[int] = None
+    # The callsReceived property
+    calls_received: Optional[int] = None
+    # The failedOrBlockedSms property
+    failed_or_blocked_sms: Optional[int] = None
+    # The missedCalls property
+    missed_calls: Optional[int] = None
+    # The smsReceived property
+    sms_received: Optional[int] = None
+    # The smsSent property
+    sms_sent: Optional[int] = None
+    # The trend property
+    trend: Optional[list[CustomerCommunicationUsagePoint]] = None
+    # The usageSpend property
+    usage_spend: Optional[float] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CustomerCommunicationUsage:
+        """
+        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: CustomerCommunicationUsage
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CustomerCommunicationUsage()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .customer_communication_usage_point import CustomerCommunicationUsagePoint
+
+        from .customer_communication_usage_point import CustomerCommunicationUsagePoint
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "answeredCalls": lambda n : setattr(self, 'answered_calls', n.get_int_value()),
+            "callMinutes": lambda n : setattr(self, 'call_minutes', n.get_float_value()),
+            "callsPlaced": lambda n : setattr(self, 'calls_placed', n.get_int_value()),
+            "callsReceived": lambda n : setattr(self, 'calls_received', n.get_int_value()),
+            "failedOrBlockedSms": lambda n : setattr(self, 'failed_or_blocked_sms', n.get_int_value()),
+            "missedCalls": lambda n : setattr(self, 'missed_calls', n.get_int_value()),
+            "smsReceived": lambda n : setattr(self, 'sms_received', n.get_int_value()),
+            "smsSent": lambda n : setattr(self, 'sms_sent', n.get_int_value()),
+            "trend": lambda n : setattr(self, 'trend', n.get_collection_of_object_values(CustomerCommunicationUsagePoint)),
+            "usageSpend": lambda n : setattr(self, 'usage_spend', n.get_float_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_int_value("answeredCalls", self.answered_calls)
+        writer.write_float_value("callMinutes", self.call_minutes)
+        writer.write_int_value("callsPlaced", self.calls_placed)
+        writer.write_int_value("callsReceived", self.calls_received)
+        writer.write_int_value("failedOrBlockedSms", self.failed_or_blocked_sms)
+        writer.write_int_value("missedCalls", self.missed_calls)
+        writer.write_int_value("smsReceived", self.sms_received)
+        writer.write_int_value("smsSent", self.sms_sent)
+        writer.write_collection_of_object_values("trend", self.trend)
+        writer.write_float_value("usageSpend", self.usage_spend)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/customer_communication_usage_point.py

@@ -0,0 +1,76 @@
+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 CustomerCommunicationUsagePoint(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 callMinutes property
+    call_minutes: Optional[float] = None
+    # The calls property
+    calls: Optional[int] = None
+    # The endAt property
+    end_at: Optional[datetime.datetime] = None
+    # The label property
+    label: Optional[str] = None
+    # The smsReceived property
+    sms_received: Optional[int] = None
+    # The smsSent property
+    sms_sent: Optional[int] = None
+    # The spend property
+    spend: Optional[float] = None
+    # The startAt property
+    start_at: Optional[datetime.datetime] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CustomerCommunicationUsagePoint:
+        """
+        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: CustomerCommunicationUsagePoint
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CustomerCommunicationUsagePoint()
+    
+    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]] = {
+            "callMinutes": lambda n : setattr(self, 'call_minutes', n.get_float_value()),
+            "calls": lambda n : setattr(self, 'calls', n.get_int_value()),
+            "endAt": lambda n : setattr(self, 'end_at', n.get_datetime_value()),
+            "label": lambda n : setattr(self, 'label', n.get_str_value()),
+            "smsReceived": lambda n : setattr(self, 'sms_received', n.get_int_value()),
+            "smsSent": lambda n : setattr(self, 'sms_sent', n.get_int_value()),
+            "spend": lambda n : setattr(self, 'spend', n.get_float_value()),
+            "startAt": lambda n : setattr(self, 'start_at', n.get_datetime_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("callMinutes", self.call_minutes)
+        writer.write_int_value("calls", self.calls)
+        writer.write_datetime_value("endAt", self.end_at)
+        writer.write_str_value("label", self.label)
+        writer.write_int_value("smsReceived", self.sms_received)
+        writer.write_int_value("smsSent", self.sms_sent)
+        writer.write_float_value("spend", self.spend)
+        writer.write_datetime_value("startAt", self.start_at)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/customer_failing_automation.py

@@ -0,0 +1,60 @@
+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 CustomerFailingAutomation(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 automationId property
+    automation_id: Optional[str] = None
+    # The error property
+    error: Optional[str] = None
+    # The failedAt property
+    failed_at: Optional[datetime.datetime] = None
+    # The name property
+    name: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CustomerFailingAutomation:
+        """
+        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: CustomerFailingAutomation
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CustomerFailingAutomation()
+    
+    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]] = {
+            "automationId": lambda n : setattr(self, 'automation_id', n.get_str_value()),
+            "error": lambda n : setattr(self, 'error', n.get_str_value()),
+            "failedAt": lambda n : setattr(self, 'failed_at', n.get_datetime_value()),
+            "name": lambda n : setattr(self, '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_str_value("automationId", self.automation_id)
+        writer.write_str_value("error", self.error)
+        writer.write_datetime_value("failedAt", self.failed_at)
+        writer.write_str_value("name", self.name)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/customer_lead_source_breakdown.py

@@ -0,0 +1,55 @@
+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 CustomerLeadSourceBreakdown(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 leads property
+    leads: Optional[int] = None
+    # The percent property
+    percent: Optional[float] = None
+    # The source property
+    source: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CustomerLeadSourceBreakdown:
+        """
+        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: CustomerLeadSourceBreakdown
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CustomerLeadSourceBreakdown()
+    
+    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]] = {
+            "leads": lambda n : setattr(self, 'leads', n.get_int_value()),
+            "percent": lambda n : setattr(self, 'percent', n.get_float_value()),
+            "source": lambda n : setattr(self, 'source', 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_int_value("leads", self.leads)
+        writer.write_float_value("percent", self.percent)
+        writer.write_str_value("source", self.source)
+        writer.write_additional_data_value(self.additional_data)
+    
+