leadping 1.0.0__py3-none-any.whl

leadping/models/sms_warmup_action_status.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+class SmsWarmupActionStatus(str, Enum):
+    Scheduled = "Scheduled",
+    Sending = "Sending",
+    Sent = "Sent",
+    Delivered = "Delivered",
+    Received = "Received",
+    Failed = "Failed",
+    Skipped = "Skipped",
+    Paused = "Paused",
+    Blocked = "Blocked",
+    Cancelled = "Cancelled",
+

leadping/models/sms_warmup_action_type.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class SmsWarmupActionType(str, Enum):
+    OutboundMessage = "OutboundMessage",
+    ReplyMessage = "ReplyMessage",
+    HealthCheck = "HealthCheck",
+    Audit = "Audit",
+

leadping/models/sms_warmup_health_state.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+class SmsWarmupHealthState(str, Enum):
+    NotStarted = "Not Started",
+    Warming = "Warming",
+    Healthy = "Healthy",
+    NeedsAttention = "Needs Attention",
+    Paused = "Paused",
+    Blocked = "Blocked",
+    Ready = "Ready",
+

leadping/models/sms_warmup_status_response.py

@@ -0,0 +1,176 @@
+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 .sms_warmup_action_response import SmsWarmupActionResponse
+    from .sms_warmup_health_state import SmsWarmupHealthState
+    from .sms_warmup_ui_state import SmsWarmupUiState
+
+@dataclass
+class SmsWarmupStatusResponse(AdditionalDataHolder, Parsable):
+    """
+    API response containing SMS warmup status 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 human-readable block reason explaining this SMS warmup status.
+    block_reason: Optional[str] = None
+    # Whether the caller can pause this SMS warmup status.
+    can_pause: Optional[bool] = None
+    # Whether the caller can resume this SMS warmup status.
+    can_resume: Optional[bool] = None
+    # The carrier rejection count for this SMS warmup status.
+    carrier_rejection_count: Optional[int] = None
+    # The date and time for the completed at value on this SMS warmup status.
+    completed_at: Optional[datetime.datetime] = None
+    # The delivered count for this SMS warmup status.
+    delivered_count: Optional[int] = None
+    # The delivery success rate metric for this SMS warmup status.
+    delivery_success_rate: Optional[float] = None
+    # The failure count for this SMS warmup status.
+    failure_count: Optional[int] = None
+    # Whether global warmup is enabled for this SMS warmup status.
+    global_warmup_enabled: Optional[bool] = None
+    # The health score metric for this SMS warmup status.
+    health_score: Optional[int] = None
+    # Whether this SMS warmup status is approved test destination.
+    is_approved_test_destination: Optional[bool] = None
+    # Whether this SMS warmup status is internal pool.
+    is_internal_pool: Optional[bool] = None
+    # Whether this SMS warmup status is messaging program approved.
+    is_messaging_program_approved: Optional[bool] = None
+    # The date and time for the last health snapshot at value on this SMS warmup status.
+    last_health_snapshot_at: Optional[datetime.datetime] = None
+    # The date and time for the last successful message at value on this SMS warmup status.
+    last_successful_message_at: Optional[datetime.datetime] = None
+    # The date and time for the next scheduled action at value on this SMS warmup status.
+    next_scheduled_action_at: Optional[datetime.datetime] = None
+    # The opt out signal count for this SMS warmup status.
+    opt_out_signal_count: Optional[int] = None
+    # The human-readable pause reason explaining this SMS warmup status.
+    pause_reason: Optional[str] = None
+    # The phone number associated with this SMS warmup status.
+    phone_number: Optional[str] = None
+    # The phone number ID associated with this SMS warmup status.
+    phone_number_id: Optional[str] = None
+    # The progress percent metric for this SMS warmup status.
+    progress_percent: Optional[int] = None
+    # The received count for this SMS warmup status.
+    received_count: Optional[int] = None
+    # The recent actions included with this SMS warmup status.
+    recent_actions: Optional[list[SmsWarmupActionResponse]] = None
+    # The sent count for this SMS warmup status.
+    sent_count: Optional[int] = None
+    # The spam signal count for this SMS warmup status.
+    spam_signal_count: Optional[int] = None
+    # The date and time for the started at value on this SMS warmup status.
+    started_at: Optional[datetime.datetime] = None
+    # The current status for this SMS warmup status.
+    status: Optional[SmsWarmupHealthState] = None
+    # The current UI state for this SMS warmup status.
+    ui_state: Optional[SmsWarmupUiState] = None
+    # Whether warmup is enabled for this SMS warmup status.
+    warmup_enabled: Optional[bool] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SmsWarmupStatusResponse:
+        """
+        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: SmsWarmupStatusResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SmsWarmupStatusResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .sms_warmup_action_response import SmsWarmupActionResponse
+        from .sms_warmup_health_state import SmsWarmupHealthState
+        from .sms_warmup_ui_state import SmsWarmupUiState
+
+        from .sms_warmup_action_response import SmsWarmupActionResponse
+        from .sms_warmup_health_state import SmsWarmupHealthState
+        from .sms_warmup_ui_state import SmsWarmupUiState
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "blockReason": lambda n : setattr(self, 'block_reason', n.get_str_value()),
+            "canPause": lambda n : setattr(self, 'can_pause', n.get_bool_value()),
+            "canResume": lambda n : setattr(self, 'can_resume', n.get_bool_value()),
+            "carrierRejectionCount": lambda n : setattr(self, 'carrier_rejection_count', n.get_int_value()),
+            "completedAt": lambda n : setattr(self, 'completed_at', n.get_datetime_value()),
+            "deliveredCount": lambda n : setattr(self, 'delivered_count', n.get_int_value()),
+            "deliverySuccessRate": lambda n : setattr(self, 'delivery_success_rate', n.get_float_value()),
+            "failureCount": lambda n : setattr(self, 'failure_count', n.get_int_value()),
+            "globalWarmupEnabled": lambda n : setattr(self, 'global_warmup_enabled', n.get_bool_value()),
+            "healthScore": lambda n : setattr(self, 'health_score', n.get_int_value()),
+            "isApprovedTestDestination": lambda n : setattr(self, 'is_approved_test_destination', n.get_bool_value()),
+            "isInternalPool": lambda n : setattr(self, 'is_internal_pool', n.get_bool_value()),
+            "isMessagingProgramApproved": lambda n : setattr(self, 'is_messaging_program_approved', n.get_bool_value()),
+            "lastHealthSnapshotAt": lambda n : setattr(self, 'last_health_snapshot_at', n.get_datetime_value()),
+            "lastSuccessfulMessageAt": lambda n : setattr(self, 'last_successful_message_at', n.get_datetime_value()),
+            "nextScheduledActionAt": lambda n : setattr(self, 'next_scheduled_action_at', n.get_datetime_value()),
+            "optOutSignalCount": lambda n : setattr(self, 'opt_out_signal_count', n.get_int_value()),
+            "pauseReason": lambda n : setattr(self, 'pause_reason', 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()),
+            "progressPercent": lambda n : setattr(self, 'progress_percent', n.get_int_value()),
+            "receivedCount": lambda n : setattr(self, 'received_count', n.get_int_value()),
+            "recentActions": lambda n : setattr(self, 'recent_actions', n.get_collection_of_object_values(SmsWarmupActionResponse)),
+            "sentCount": lambda n : setattr(self, 'sent_count', n.get_int_value()),
+            "spamSignalCount": lambda n : setattr(self, 'spam_signal_count', n.get_int_value()),
+            "startedAt": lambda n : setattr(self, 'started_at', n.get_datetime_value()),
+            "status": lambda n : setattr(self, 'status', n.get_enum_value(SmsWarmupHealthState)),
+            "uiState": lambda n : setattr(self, 'ui_state', n.get_object_value(SmsWarmupUiState)),
+            "warmupEnabled": lambda n : setattr(self, 'warmup_enabled', n.get_bool_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("blockReason", self.block_reason)
+        writer.write_bool_value("canPause", self.can_pause)
+        writer.write_bool_value("canResume", self.can_resume)
+        writer.write_int_value("carrierRejectionCount", self.carrier_rejection_count)
+        writer.write_datetime_value("completedAt", self.completed_at)
+        writer.write_int_value("deliveredCount", self.delivered_count)
+        writer.write_float_value("deliverySuccessRate", self.delivery_success_rate)
+        writer.write_int_value("failureCount", self.failure_count)
+        writer.write_bool_value("globalWarmupEnabled", self.global_warmup_enabled)
+        writer.write_int_value("healthScore", self.health_score)
+        writer.write_bool_value("isApprovedTestDestination", self.is_approved_test_destination)
+        writer.write_bool_value("isInternalPool", self.is_internal_pool)
+        writer.write_bool_value("isMessagingProgramApproved", self.is_messaging_program_approved)
+        writer.write_datetime_value("lastHealthSnapshotAt", self.last_health_snapshot_at)
+        writer.write_datetime_value("lastSuccessfulMessageAt", self.last_successful_message_at)
+        writer.write_datetime_value("nextScheduledActionAt", self.next_scheduled_action_at)
+        writer.write_int_value("optOutSignalCount", self.opt_out_signal_count)
+        writer.write_str_value("pauseReason", self.pause_reason)
+        writer.write_str_value("phoneNumber", self.phone_number)
+        writer.write_str_value("phoneNumberId", self.phone_number_id)
+        writer.write_int_value("progressPercent", self.progress_percent)
+        writer.write_int_value("receivedCount", self.received_count)
+        writer.write_collection_of_object_values("recentActions", self.recent_actions)
+        writer.write_int_value("sentCount", self.sent_count)
+        writer.write_int_value("spamSignalCount", self.spam_signal_count)
+        writer.write_datetime_value("startedAt", self.started_at)
+        writer.write_enum_value("status", self.status)
+        writer.write_object_value("uiState", self.ui_state)
+        writer.write_bool_value("warmupEnabled", self.warmup_enabled)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/sms_warmup_ui_state.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 .sms_warmup_health_state import SmsWarmupHealthState
+
+@dataclass
+class SmsWarmupUiState(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing SMS warmup ui state 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 human-readable description of this SMS warmup UI state.
+    description: Optional[str] = None
+    # The human-readable label shown for this SMS warmup UI state.
+    label: Optional[SmsWarmupHealthState] = None
+    # The tone value for this SMS warmup UI state.
+    tone: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SmsWarmupUiState:
+        """
+        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: SmsWarmupUiState
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SmsWarmupUiState()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .sms_warmup_health_state import SmsWarmupHealthState
+
+        from .sms_warmup_health_state import SmsWarmupHealthState
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "description": lambda n : setattr(self, 'description', n.get_str_value()),
+            "label": lambda n : setattr(self, 'label', n.get_enum_value(SmsWarmupHealthState)),
+            "tone": lambda n : setattr(self, 'tone', 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("description", self.description)
+        writer.write_enum_value("label", self.label)
+        writer.write_str_value("tone", self.tone)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/source_metrics_response.py

@@ -0,0 +1,70 @@
+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 .analytics_trend_point_ofint import AnalyticsTrendPointOfint
+
+@dataclass
+class SourceMetricsResponse(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 generatedAt property
+    generated_at: Optional[datetime.datetime] = None
+    # The points property
+    points: Optional[list[AnalyticsTrendPointOfint]] = None
+    # The range property
+    range: Optional[AnalyticsDateRange] = None
+    # The totalLeads property
+    total_leads: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SourceMetricsResponse:
+        """
+        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: SourceMetricsResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SourceMetricsResponse()
+    
+    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 .analytics_trend_point_ofint import AnalyticsTrendPointOfint
+
+        from .analytics_date_range import AnalyticsDateRange
+        from .analytics_trend_point_ofint import AnalyticsTrendPointOfint
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "generatedAt": lambda n : setattr(self, 'generated_at', n.get_datetime_value()),
+            "points": lambda n : setattr(self, 'points', n.get_collection_of_object_values(AnalyticsTrendPointOfint)),
+            "range": lambda n : setattr(self, 'range', n.get_object_value(AnalyticsDateRange)),
+            "totalLeads": lambda n : setattr(self, 'total_leads', 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_datetime_value("generatedAt", self.generated_at)
+        writer.write_collection_of_object_values("points", self.points)
+        writer.write_object_value("range", self.range)
+        writer.write_int_value("totalLeads", self.total_leads)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/source_request.py

@@ -0,0 +1,109 @@
+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 .source_request_admin_enablement_override import SourceRequest_adminEnablementOverride
+
+@dataclass
+class SourceRequest(AdditionalDataHolder, Parsable):
+    """
+    Request payload for source.
+    """
+    # 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 adminEnablementOverride property
+    admin_enablement_override: Optional[SourceRequest_adminEnablementOverride] = None
+    # The allowed products included with this source.
+    allowed_products: Optional[list[str]] = None
+    # The allowed states included with this source.
+    allowed_states: Optional[list[str]] = None
+    # The business ID associated with this source.
+    business_id: Optional[str] = None
+    # Whether this source is compliance approved.
+    compliance_approved: Optional[bool] = None
+    # The compliance notes value for this source.
+    compliance_notes: Optional[str] = None
+    # Tag ids applied automatically to leads created from this source.
+    default_tag_ids: Optional[list[str]] = None
+    # Tag names applied automatically to leads created from this source, creating missing tags when allowed by the caller.
+    default_tag_names: Optional[list[str]] = None
+    # The human-readable description of this source.
+    description: Optional[str] = None
+    # Whether this source is enabled.
+    enabled: Optional[bool] = None
+    # The unique identifier for the entity, when updating an existing entity.
+    id: Optional[str] = None
+    # The display name for the entity.
+    name: Optional[str] = None
+    # Whether regenerate API key applies to this source.
+    regenerate_api_key: Optional[bool] = None
+    # Whether this source requires TrustedForm.
+    requires_trusted_form: Optional[bool] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SourceRequest:
+        """
+        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: SourceRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SourceRequest()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .source_request_admin_enablement_override import SourceRequest_adminEnablementOverride
+
+        from .source_request_admin_enablement_override import SourceRequest_adminEnablementOverride
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "adminEnablementOverride": lambda n : setattr(self, 'admin_enablement_override', n.get_object_value(SourceRequest_adminEnablementOverride)),
+            "allowedProducts": lambda n : setattr(self, 'allowed_products', n.get_collection_of_primitive_values(str)),
+            "allowedStates": lambda n : setattr(self, 'allowed_states', n.get_collection_of_primitive_values(str)),
+            "businessId": lambda n : setattr(self, 'business_id', n.get_str_value()),
+            "complianceApproved": lambda n : setattr(self, 'compliance_approved', n.get_bool_value()),
+            "complianceNotes": lambda n : setattr(self, 'compliance_notes', n.get_str_value()),
+            "defaultTagIds": lambda n : setattr(self, 'default_tag_ids', n.get_collection_of_primitive_values(str)),
+            "defaultTagNames": lambda n : setattr(self, 'default_tag_names', n.get_collection_of_primitive_values(str)),
+            "description": lambda n : setattr(self, 'description', n.get_str_value()),
+            "enabled": lambda n : setattr(self, 'enabled', n.get_bool_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "regenerateApiKey": lambda n : setattr(self, 'regenerate_api_key', n.get_bool_value()),
+            "requiresTrustedForm": lambda n : setattr(self, 'requires_trusted_form', n.get_bool_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_object_value("adminEnablementOverride", self.admin_enablement_override)
+        writer.write_collection_of_primitive_values("allowedProducts", self.allowed_products)
+        writer.write_collection_of_primitive_values("allowedStates", self.allowed_states)
+        writer.write_str_value("businessId", self.business_id)
+        writer.write_bool_value("complianceApproved", self.compliance_approved)
+        writer.write_str_value("complianceNotes", self.compliance_notes)
+        writer.write_collection_of_primitive_values("defaultTagIds", self.default_tag_ids)
+        writer.write_collection_of_primitive_values("defaultTagNames", self.default_tag_names)
+        writer.write_str_value("description", self.description)
+        writer.write_bool_value("enabled", self.enabled)
+        writer.write_str_value("id", self.id)
+        writer.write_str_value("name", self.name)
+        writer.write_bool_value("regenerateApiKey", self.regenerate_api_key)
+        writer.write_bool_value("requiresTrustedForm", self.requires_trusted_form)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/source_request_admin_enablement_override.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 .admin_enablement_override import AdminEnablementOverride
+
+from .admin_enablement_override import AdminEnablementOverride
+
+@dataclass
+class SourceRequest_adminEnablementOverride(AdminEnablementOverride, Parsable):
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SourceRequest_adminEnablementOverride:
+        """
+        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: SourceRequest_adminEnablementOverride
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SourceRequest_adminEnablementOverride()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .admin_enablement_override import AdminEnablementOverride
+
+        from .admin_enablement_override import AdminEnablementOverride
+
+        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)
+    
+